@instantdb/core 0.22.86-experimental.separate-attrs.20122276424.1 → 0.22.86-experimental.split-store.20178922132.1

package/src/store.ts

@@ -7,26 +7,22 @@ import { LinkIndex } from './utils/linkIndex.ts';
 type Triple = [string, string, any, number];
 type Attrs = Record<string, InstantDBAttr>;
 
-type AttrIndexes = {
+interface AttrIndexes {
   blobAttrs: Map<string, Map<string, InstantDBAttr>>;
   primaryKeys: Map<string, InstantDBAttr>;
   forwardIdents: Map<string, Map<string, InstantDBAttr>>;
   revIdents: Map<string, Map<string, InstantDBAttr>>;
-};
+}
 
 export type Store = {
   eav: Map<string, Map<string, Map<any, Triple>>>;
   aev: Map<string, Map<string, Map<any, Triple>>>;
   vae: Map<any, Map<string, Map<string, Triple>>>;
   useDateObjects: boolean | null;
-  attrs: Attrs;
-  attrIndexes: AttrIndexes;
   cardinalityInference: boolean | null;
-  linkIndex: LinkIndex | null;
-  __type: 'store';
 };
 
-export type StoreJson = {
+type StoreJsonVersion0 = {
   __type: 'store';
   attrs: Attrs;
   triples: Triple[];
@@ -35,6 +31,131 @@ export type StoreJson = {
   useDateObjects: boolean | null;
 };
 
+type StoreJsonVersion1 = {
+  triples: Triple[];
+  cardinalityInference: boolean | null;
+  useDateObjects: boolean | null;
+  version: 1;
+};
+
+export type StoreJson = StoreJsonVersion0 | StoreJsonVersion1;
+
+export type AttrsStoreJson = {
+  attrs: Attrs;
+  linkIndex: LinkIndex | null;
+};
+
+export class AttrsStore {
+  public attrs: Attrs;
+  public linkIndex: LinkIndex | null;
+  private _blobAttrs: Map<string, Map<string, InstantDBAttr>> | null = null;
+  private _primaryKeys: Map<string, InstantDBAttr> | null = null;
+  private _forwardIdents: Map<string, Map<string, InstantDBAttr>> | null = null;
+  private _revIdents: Map<string, Map<string, InstantDBAttr>> | null = null;
+  constructor(attrs: Attrs, linkIndex: LinkIndex | null) {
+    console.log('attrs init', new Error('trace'));
+    this.attrs = attrs;
+    this.linkIndex = linkIndex;
+  }
+
+  public resetAttrIndexes() {
+    this._blobAttrs = null;
+    this._primaryKeys = null;
+    this._forwardIdents = null;
+    this._revIdents = null;
+  }
+
+  public addAttr(attr: InstantDBAttr) {
+    this.attrs[attr.id] = attr;
+    this.resetAttrIndexes();
+  }
+
+  public deleteAttr(attrId: string) {
+    delete this.attrs[attrId];
+    this.resetAttrIndexes();
+  }
+
+  public updateAttr(partialAttr: Partial<InstantDBAttr> & { id: string }) {
+    const attr = this.attrs[partialAttr.id];
+    if (!attr) return;
+    this.attrs[partialAttr.id] = { ...attr, ...partialAttr };
+    this.resetAttrIndexes();
+  }
+
+  public getAttr(id: string): InstantDBAttr | undefined {
+    return this.attrs[id];
+  }
+
+  // XXX: Might be better to create all of the indexes at once as soon as someone
+  //      requests one index
+  get blobAttrs(): Map<string, Map<string, InstantDBAttr>> {
+    if (this._blobAttrs) {
+      return this._blobAttrs;
+    }
+    console.log('blobAttrs');
+    this._blobAttrs = new Map();
+    for (const attr of Object.values(this.attrs)) {
+      if (isBlob(attr)) {
+        const [_, fwdEtype, fwdLabel] = attr['forward-identity'];
+        setInMap(this.blobAttrs, [fwdEtype, fwdLabel], attr);
+      }
+    }
+    return this._blobAttrs;
+  }
+
+  get primaryKeys(): Map<string, InstantDBAttr> {
+    if (this._primaryKeys) {
+      return this._primaryKeys;
+    }
+    console.log('primayKeys');
+    this._primaryKeys = new Map();
+
+    for (const attr of Object.values(this.attrs)) {
+      if (attr['primary?']) {
+        const [_, fwdEtype] = attr['forward-identity'];
+        setInMap(this._primaryKeys, [fwdEtype], attr);
+      }
+    }
+    return this._primaryKeys;
+  }
+
+  get forwardIdents(): Map<string, Map<string, InstantDBAttr>> {
+    if (this._forwardIdents) {
+      return this._forwardIdents;
+    }
+    console.log('fwdIdents');
+    this._forwardIdents = new Map();
+
+    for (const attr of Object.values(this.attrs)) {
+      const fwdIdent = attr['forward-identity'];
+      const [_, fwdEtype, fwdLabel] = fwdIdent;
+      setInMap(this._forwardIdents, [fwdEtype, fwdLabel], attr);
+    }
+    return this._forwardIdents;
+  }
+
+  get revIdents(): Map<string, Map<string, InstantDBAttr>> {
+    if (this._revIdents) {
+      return this._revIdents;
+    }
+    console.log('revIdents');
+    this._revIdents = new Map();
+
+    for (const attr of Object.values(this.attrs)) {
+      const revIdent = attr['reverse-identity'];
+      if (revIdent) {
+        const [_, revEtype, revLabel] = revIdent;
+        setInMap(this._revIdents, [revEtype, revLabel], attr);
+      }
+    }
+    return this._revIdents;
+  }
+
+  public toJSON(): AttrsStoreJson {
+    return { attrs: this.attrs, linkIndex: this.linkIndex };
+  }
+}
+
 function hasEA(attr: InstantDBAttr) {
   return attr['cardinality'] === 'one';
 }
@@ -86,7 +207,7 @@ function isDateAttr(attr: InstantDBAttr) {
 }
 
 function createTripleIndexes(
-  attrs: Record<string, InstantDBAttr>,
+  attrsStore: AttrsStore,
   triples: Triple[],
   useDateObjects: boolean | null,
 ): Pick<Store, 'eav' | 'aev' | 'vae'> {
@@ -94,10 +215,10 @@ function createTripleIndexes(
   const aev = new Map();
   const vae = new Map();
   for (const triple of triples) {
-    let [eid, aid, v, t] = triple;
-    const attr = getAttr(attrs, aid);
+    let [eid, aid, v] = triple;
+    const attr = attrsStore.getAttr(aid);
     if (!attr) {
-      console.warn('no such attr', eid, attrs);
+      console.warn('no such attr', aid, eid);
       continue;
     }
 
@@ -142,27 +263,36 @@ function createAttrIndexes(attrs: Record<string, InstantDBAttr>): AttrIndexes {
   return { blobAttrs, primaryKeys, forwardIdents, revIdents };
 }
 
-export function toJSON(store: Store): StoreJson {
+export function toJSON(store: Store): StoreJsonVersion1 {
   return {
-    __type: store.__type,
-    attrs: store.attrs,
     triples: allMapValues(store.eav, 3),
     cardinalityInference: store.cardinalityInference,
-    linkIndex: store.linkIndex,
     useDateObjects: store.useDateObjects,
+    version: 1,
   };
 }
 
-export function fromJSON(storeJSON: StoreJson): Store {
+export function fromJSON(attrsStore: AttrsStore, storeJSON: StoreJson): Store {
   return createStore(
-    storeJSON.attrs,
+    attrsStore,
     storeJSON.triples,
     storeJSON.cardinalityInference,
-    storeJSON.linkIndex,
     storeJSON.useDateObjects,
   );
 }
 
+export function attrsStoreFromJSON(
+  attrsStoreJSON: AttrsStoreJson | null,
+  storeJSON: StoreJson | null,
+): AttrsStore | undefined {
+  if (attrsStoreJSON) {
+    return new AttrsStore(attrsStoreJSON.attrs, attrsStoreJSON.linkIndex);
+  }
+  if (storeJSON && '__type' in storeJSON) {
+    return new AttrsStore(storeJSON.attrs, storeJSON.linkIndex);
+  }
+}
+
 export function hasTriple(store: Store, [e, a, v]: [string, string, any]) {
   return getInMap(store.eav, [e, a, v]) !== undefined;
 }
@@ -171,29 +301,19 @@ export function hasEntity(store: Store, e: string) {
   return getInMap(store.eav, [e]) !== undefined;
 }
 
-function resetAttrIndexes(store: Store) {
-  store.attrIndexes = createAttrIndexes(store.attrs);
-}
-
 export function createStore(
-  attrs: Record<string, InstantDBAttr>,
+  attrsStore: AttrsStore,
   triples: Triple[],
   enableCardinalityInference: boolean | null,
-  linkIndex: LinkIndex | null,
   useDateObjects: boolean | null,
 ): Store {
   const store = createTripleIndexes(
-    attrs,
+    attrsStore,
     triples,
     useDateObjects,
   ) as unknown as Store;
-  store.useDateObjects = useDateObjects;
-  store.attrs = attrs;
-  store.attrIndexes = createAttrIndexes(attrs);
   store.cardinalityInference = enableCardinalityInference;
-  store.linkIndex = linkIndex;
-  store.__type = 'store';
-
+  store.useDateObjects = useDateObjects;
   return store;
 }
 
@@ -254,13 +374,17 @@ function resolveLookupRefs(store: Store, triple: Triple): Triple | null {
   }
 }
 
-export function retractTriple(store: Store, rawTriple: Triple): void {
+export function retractTriple(
+  store: Store,
+  attrsStore: AttrsStore,
+  rawTriple: Triple,
+): void {
   const triple = resolveLookupRefs(store, rawTriple);
   if (!triple) {
     return;
   }
   const [eid, aid, v] = triple;
-  const attr = getAttr(store.attrs, aid);
+  const attr = attrsStore.getAttr(aid);
   if (!attr) {
     return;
   }
@@ -310,13 +434,17 @@ function getCreatedAt(
   return createdAt || Date.now() * 10 + _seed++;
 }
 
-export function addTriple(store: Store, rawTriple: Triple) {
+export function addTriple(
+  store: Store,
+  attrsStore: AttrsStore,
+  rawTriple: Triple,
+) {
   const triple = resolveLookupRefs(store, rawTriple);
   if (!triple) {
     return;
   }
   let [eid, aid, v] = triple;
-  const attr = getAttr(store.attrs, aid);
+  const attr = attrsStore.getAttr(aid);
   if (!attr) {
     // (XXX): Due to the way we're handling attrs, it's
     // possible to enter a state where we receive a triple without an attr.
@@ -349,14 +477,14 @@ export function addTriple(store: Store, rawTriple: Triple) {
   }
 }
 
-function mergeTriple(store: Store, rawTriple: Triple) {
+function mergeTriple(store: Store, attrsStore: AttrsStore, rawTriple: Triple) {
   const triple = resolveLookupRefs(store, rawTriple);
   if (!triple) {
     return;
   }
 
   const [eid, aid, update] = triple;
-  const attr = getAttr(store.attrs, aid);
+  const attr = attrsStore.getAttr(aid);
 
   if (!attr) return;
 
@@ -382,7 +510,7 @@ function mergeTriple(store: Store, rawTriple: Triple) {
   setInMap(store.eav, [eid, aid], new Map([[updatedValue, enhancedTriple]]));
 }
 
-function deleteEntity(store: Store, args: any[]) {
+function deleteEntity(store: Store, attrsStore: AttrsStore, args: any[]) {
   const [lookup, etype] = args;
   const triple = resolveLookupRefs(store, [lookup] as unknown as Triple);
 
@@ -395,13 +523,13 @@ function deleteEntity(store: Store, args: any[]) {
   const eMap = store.eav.get(id);
   if (eMap) {
     for (const a of eMap.keys()) {
-      const attr = store.attrs[a];
+      const attr = attrsStore.getAttr(a);
 
       // delete cascade refs
       if (attr && attr['on-delete-reverse'] === 'cascade') {
         allMapValues(eMap.get(a), 1).forEach(
           ([e, a, v]: [string, string, any]) =>
-            deleteEntity(store, [v, attr['reverse-identity']?.[1]]),
+            deleteEntity(store, attrsStore, [v, attr['reverse-identity']?.[1]]),
         );
       }
 
@@ -430,7 +558,7 @@ function deleteEntity(store: Store, args: any[]) {
   if (vaeTriples) {
     vaeTriples.forEach((triple: Triple) => {
       const [e, a, v] = triple;
-      const attr = store.attrs[a];
+      const attr = attrsStore.getAttr(a);
       if (!etype || !attr || attr['reverse-identity']?.[1] === etype) {
         deleteInMap(store.eav, [e, a, v]);
         deleteInMap(store.aev, [a, e, v]);
@@ -441,7 +569,7 @@ function deleteEntity(store: Store, args: any[]) {
         attr['on-delete'] === 'cascade' &&
         attr['reverse-identity']?.[1] === etype
       ) {
-        deleteEntity(store, [e, attr['forward-identity']?.[1]]);
+        deleteEntity(store, attrsStore, [e, attr['forward-identity']?.[1]]);
       }
     });
   }
@@ -458,9 +586,9 @@ function deleteEntity(store: Store, args: any[]) {
 // * We could batch this reset at the end
 // * We could add an ave index for all triples, so removing the
 //   right triples is easy and fast.
-function resetIndexMap(store: Store, newTriples: Triple[]) {
+function resetIndexMap(store: Store, attrsStore, newTriples: Triple[]) {
   const newIndexMap = createTripleIndexes(
-    store.attrs,
+    attrsStore,
     newTriples,
     store.useDateObjects,
   );
@@ -469,57 +597,55 @@ function resetIndexMap(store: Store, newTriples: Triple[]) {
   });
 }
 
-function addAttr(store: Store, [attr]: [InstantDBAttr]) {
-  store.attrs[attr.id] = attr;
-  resetAttrIndexes(store);
+function addAttr(attrsStore: AttrsStore, [attr]: [InstantDBAttr]) {
+  attrsStore.addAttr(attr);
 }
 
 function getAllTriples(store: Store): Triple[] {
   return allMapValues(store.eav, 3);
 }
 
-function deleteAttr(store: Store, [id]: [string]) {
-  if (!store.attrs[id]) return;
+function deleteAttr(store: Store, attrsStore: AttrsStore, [id]: [string]) {
+  if (!attrsStore.getAttr(id)) return;
   const newTriples = getAllTriples(store).filter(([_, aid]) => aid !== id);
-  delete store.attrs[id];
-  resetAttrIndexes(store);
-  resetIndexMap(store, newTriples);
+  attrsStore.deleteAttr(id);
+  resetIndexMap(store, attrsStore, newTriples);
 }
 
 function updateAttr(
   store: Store,
+  attrsStore: AttrsStore,
   [partialAttr]: [Partial<InstantDBAttr> & { id: string }],
 ) {
-  const attr = store.attrs[partialAttr.id];
+  const attr = attrsStore.getAttr(partialAttr.id);
   if (!attr) return;
-  store.attrs[partialAttr.id] = { ...attr, ...partialAttr };
-  resetAttrIndexes(store);
-  resetIndexMap(store, getAllTriples(store));
+  attrsStore.updateAttr(partialAttr);
+  resetIndexMap(store, attrsStore, getAllTriples(store));
 }
 
-function applyTxStep(store: Store, txStep) {
+function applyTxStep(store: Store, attrsStore: AttrsStore, txStep) {
   const [action, ...args] = txStep;
   switch (action) {
     case 'add-triple':
-      addTriple(store, args);
+      addTriple(store, attrsStore, args);
       break;
     case 'deep-merge-triple':
-      mergeTriple(store, args);
+      mergeTriple(store, attrsStore, args);
       break;
     case 'retract-triple':
-      retractTriple(store, args);
+      retractTriple(store, attrsStore, args);
       break;
     case 'delete-entity':
-      deleteEntity(store, args);
+      deleteEntity(store, attrsStore, args);
       break;
     case 'add-attr':
-      addAttr(store, args);
+      addAttr(attrsStore, args);
       break;
     case 'delete-attr':
-      deleteAttr(store, args);
+      deleteAttr(store, attrsStore, args);
       break;
     case 'update-attr':
-      updateAttr(store, args);
+      updateAttr(store, attrsStore, args);
       break;
     case 'restore-attr':
       break;
@@ -700,35 +826,36 @@ export function getAsObject(
 }
 
 export function getAttrByFwdIdentName(
-  store: Store,
+  attrsStore: AttrsStore,
   inputEtype: string,
   inputLabel: string,
 ) {
-  return store.attrIndexes.forwardIdents.get(inputEtype)?.get(inputLabel);
+  return attrsStore.forwardIdents.get(inputEtype)?.get(inputLabel);
 }
 
 export function getAttrByReverseIdentName(
-  store: Store,
+  attrsStore: AttrsStore,
   inputEtype: string,
   inputLabel: string,
 ) {
-  return store.attrIndexes.revIdents.get(inputEtype)?.get(inputLabel);
+  return attrsStore.revIdents.get(inputEtype)?.get(inputLabel);
 }
 
-export function getBlobAttrs(store: Store, etype: string) {
-  return store.attrIndexes.blobAttrs.get(etype);
+export function getBlobAttrs(attrsStore: AttrsStore, etype: string) {
+  return attrsStore.blobAttrs.get(etype);
 }
 
-export function getPrimaryKeyAttr(store: Store, etype: string) {
-  const fromPrimary = store.attrIndexes.primaryKeys.get(etype);
+export function getPrimaryKeyAttr(attrsStore: AttrsStore, etype: string) {
+  const fromPrimary = attrsStore.primaryKeys.get(etype);
   if (fromPrimary) {
     return fromPrimary;
   }
-  return store.attrIndexes.forwardIdents.get(etype)?.get('id');
+  return attrsStore.forwardIdents.get(etype)?.get('id');
 }
 
 function findTriple(
   store: Store,
+  attrsStore: AttrsStore,
   rawTriple: [string, string, any] | Triple,
 ): Triple | undefined {
   const triple = resolveLookupRefs(store, rawTriple as Triple);
@@ -737,7 +864,7 @@ function findTriple(
   }
 
   const [eid, aid, v] = triple;
-  const attr = getAttr(store.attrs, aid);
+  const attr = attrsStore.getAttr(aid);
   if (!attr) {
     // (XXX): Due to the way we're handling attrs, it's
     // possible to enter a state where we receive a triple without an attr.
@@ -749,7 +876,7 @@ function findTriple(
   return getInMap(store.eav, [eid, aid]);
 }
 
-export function transact(store: Store, txSteps) {
+export function transact(store: Store, attrsStore: AttrsStore, txSteps) {
   const txStepsFiltered = txSteps.filter(
     ([action, eid, attrId, value, opts]) => {
       if (action !== 'add-triple' && action !== 'deep-merge-triple') {
@@ -763,10 +890,13 @@ export function transact(store: Store, txSteps) {
 
       let exists = false;
 
-      const attr = getAttr(store.attrs, attrId);
+      const attr = attrsStore.getAttr(attrId);
       if (attr) {
-        const idAttr = getPrimaryKeyAttr(store, attr['forward-identity'][1]);
-        exists = !!findTriple(store, [
+        const idAttr = getPrimaryKeyAttr(
+          attrsStore,
+          attr['forward-identity'][1],
+        );
+        exists = !!findTriple(store, attrsStore, [
           eid as string,
           idAttr?.id as string,
           eid,
@@ -787,7 +917,7 @@ export function transact(store: Store, txSteps) {
 
   return create(store, (draft) => {
     txStepsFiltered.forEach((txStep) => {
-      applyTxStep(draft, txStep);
+      applyTxStep(draft, attrsStore, txStep);
     });
   });
 }