1+ import isEqual from 'lodash/isEqual' ;
2+
13import {
24 IndexerDBClient ,
35 asExpressions ,
46 addExplicitParens ,
57 separatedByCommas ,
8+ loaderFor ,
9+ internalKeyFor ,
10+ Deferred ,
11+ identifyCard ,
12+ apiFor ,
13+ loadCard ,
14+ baseCardRef ,
15+ type CodeRef ,
16+ type CardResource ,
17+ type Expression ,
618 type IndexedCardsTable ,
719 type RealmVersionsTable ,
820} from '@cardstack/runtime-common' ;
921
22+ import type { CardDef } from 'https://cardstack.com/base/card-api' ;
23+
24+ import { testRealmURL } from './const' ;
25+
26+ let defaultIndexEntry = {
27+ realm_version : 1 ,
28+ realm_url : testRealmURL ,
29+ } ;
30+
31+ let typesCache = new WeakMap < typeof CardDef , Promise < string [ ] > > ( ) ;
32+
33+ // this leverages the logic from current-run.ts to generate the types for a card
34+ // that are serialized in the same manner as they appear in the index
35+ export async function getTypes ( instance : CardDef ) : Promise < string [ ] > {
36+ let loader = loaderFor ( instance ) ;
37+ let card = Reflect . getPrototypeOf ( instance ) ! . constructor as typeof CardDef ;
38+ let cached = typesCache . get ( card ) ;
39+ if ( cached ) {
40+ return await cached ;
41+ }
42+ let ref = identifyCard ( card ) ;
43+ if ( ! ref ) {
44+ throw new Error ( `could not identify card ${ card . name } ) ;
45+ }
46+ let deferred = new Deferred < string [ ] > ( ) ;
47+ typesCache . set ( card , deferred . promise ) ;
48+ let types : string [ ] = [ ] ;
49+ let fullRef : CodeRef = ref ;
50+ while ( fullRef ) {
51+ let loadedCard , loadedCardRef ;
52+ loadedCard = await loadCard ( fullRef , { loader } ) ;
53+ loadedCardRef = identifyCard ( loadedCard ) ;
54+ if ( ! loadedCardRef ) {
55+ throw new Error ( `could not identify card ${ loadedCard . name } ) ;
56+ }
57+ types . push ( internalKeyFor ( loadedCardRef , undefined ) ) ;
58+ if ( ! isEqual ( loadedCardRef , baseCardRef ) ) {
59+ fullRef = {
60+ type : 'ancestorOf' ,
61+ card : loadedCardRef ,
62+ } ;
63+ } else {
64+ break ;
65+ }
66+ }
67+ deferred . fulfill ( types ) ;
68+ return types ;
69+ }
70+
71+ export async function serializeCard ( card : CardDef ) : Promise < CardResource > {
72+ let api = await apiFor ( card ) ;
73+ return api . serializeCard ( card ) . data as CardResource ;
74+ }
75+
76+ type TestIndexRow =
77+ | ( Pick < IndexedCardsTable , 'card_url' > &
78+ Partial < Omit < IndexedCardsTable , 'card_url' > > )
79+ | CardDef
80+ | {
81+ card : CardDef ;
82+ data : Partial <
83+ Omit < IndexedCardsTable , 'card_url' | 'pristine_doc' | 'types' >
84+ > ;
85+ } ;
86+
87+ // There are 3 ways to setup an index:
88+ // 1. provide the raw data for each row in the indexed_cards table
89+ // 2. provide a card instance for each row in the indexed_cards table
90+ // 3. provide an object { card, data } where the card instance is used for each
91+ // row in the indexed_cards table, as well as any additional fields that you
92+ // wish to set from the `data` object.
93+ //
94+ // the realm version table will default to version 1 of the testRealmURL if no
95+ // value is supplied
96+ export async function setupIndex (
97+ client : IndexerDBClient ,
98+ indexRows : TestIndexRow [ ] ,
99+ ) : Promise < void > ;
10100export async function setupIndex (
11101 client : IndexerDBClient ,
12102 versionRows : RealmVersionsTable [ ] ,
13- // only assert that the non-null columns need to be present in rows objects
14- indexRows : ( Pick <
15- IndexedCardsTable ,
16- 'card_url' | 'realm_version' | 'realm_url'
17- > &
18- Partial <
19- Omit < IndexedCardsTable , 'card_url' | 'realm_version' | 'realm_url' >
20- > ) [ ] ,
21- ) {
22- let indexedCardsExpressions = indexRows . map ( ( r ) =>
23- asExpressions ( r , {
24- jsonFields : [ 'deps' , 'types' , 'pristine_doc' , 'error_doc' , 'search_doc' ] ,
103+ indexRows : TestIndexRow [ ] ,
104+ ) : Promise < void > ;
105+ export async function setupIndex (
106+ client : IndexerDBClient ,
107+ maybeVersionRows : RealmVersionsTable [ ] | TestIndexRow [ ] ,
108+ indexRows ?: TestIndexRow [ ] ,
109+ ) : Promise < void > {
110+ let versionRows : RealmVersionsTable [ ] ;
111+ if ( ! indexRows ) {
112+ versionRows = [ { realm_url : testRealmURL , current_version : 1 } ] ;
113+ indexRows = maybeVersionRows as TestIndexRow [ ] ;
114+ } else {
115+ versionRows = maybeVersionRows as RealmVersionsTable [ ] ;
116+ }
117+ let indexedCardsExpressions = await Promise . all (
118+ indexRows . map ( async ( r ) => {
119+ let row : Pick < IndexedCardsTable , 'card_url' > &
120+ Partial < Omit < IndexedCardsTable , 'card_url' > > ;
121+ if ( 'card_url' in r ) {
122+ row = r ;
123+ } else if ( 'card' in r ) {
124+ row = {
125+ card_url : r . card . id ,
126+ pristine_doc : await serializeCard ( r . card ) ,
127+ types : await getTypes ( r . card ) ,
128+ ...r . data ,
129+ } ;
130+ } else {
131+ row = {
132+ card_url : r . id ,
133+ pristine_doc : await serializeCard ( r ) ,
134+ types : await getTypes ( r ) ,
135+ } ;
136+ }
137+ return asExpressions (
138+ { ...defaultIndexEntry , ...row } ,
139+ {
140+ jsonFields : [
141+ 'deps' ,
142+ 'types' ,
143+ 'pristine_doc' ,
144+ 'error_doc' ,
145+ 'search_doc' ,
146+ ] ,
147+ } ,
148+ ) ;
25149 } ) ,
26150 ) ;
27151 let versionExpressions = versionRows . map ( ( r ) => asExpressions ( r ) ) ;
@@ -38,7 +162,7 @@ export async function setupIndex(
38162 addExplicitParens ( separatedByCommas ( row . valueExpressions ) ) ,
39163 ) ,
40164 ) ,
41- ] ) ;
165+ ] as Expression ) ;
42166 }
43167
44168 if ( versionExpressions . length > 0 ) {
@@ -53,6 +177,6 @@ export async function setupIndex(
53177 addExplicitParens ( separatedByCommas ( row . valueExpressions ) ) ,
54178 ) ,
55179 ) ,
56- ] ) ;
180+ ] as Expression ) ;
57181 }
58182}
0 commit comments