@instantdb/core 0.22.86-experimental.split-store.20178922132.1 → 0.22.87-experimental.drewh-explorer-component.20180358679.1

package/src/{instaml.ts → instaml.js}

@@ -1,32 +1,13 @@
-import {
-  allMapValues,
-  AttrsStore,
-  getAttrByFwdIdentName,
-  getAttrByReverseIdentName,
-  Store,
-} from './store.ts';
+import { allMapValues } from './store.ts';
 import { getOps, isLookup, parseLookup } from './instatx.ts';
 import { immutableRemoveUndefined } from './utils/object.js';
 import { coerceToDate } from './utils/dates.ts';
 import uuid from './utils/uuid.ts';
-import {
-  EntitiesWithLinks,
-  IContainEntitiesAndLinks,
-  LinkDef,
-} from './schemaTypes.ts';
-import { InstantDBAttr, InstantDBIdent } from './attrTypes.ts';
-
-export type AttrMapping = {
-  attrIdMap: Record<string, string>;
-  refSwapAttrIds: Set<string>;
-};
-
-type TXStep = any[];
 
 // Rewrites optimistic attrs with the attrs we get back from the server.
-export function rewriteStep(attrMapping: AttrMapping, txStep: TXStep): TXStep {
+export function rewriteStep(attrMapping, txStep) {
   const { attrIdMap, refSwapAttrIds } = attrMapping;
-  const rewritten: TXStep = [];
+  const rewritten = [];
   for (const part of txStep) {
     const newValue = attrIdMap[part];
 
@@ -54,6 +35,22 @@ export function rewriteStep(attrMapping: AttrMapping, txStep: TXStep): TXStep {
   return rewritten;
 }
 
+export function getAttrByFwdIdentName(attrs, inputEtype, inputIdentName) {
+  return Object.values(attrs).find((attr) => {
+    const [_id, etype, label] = attr['forward-identity'];
+    return etype === inputEtype && label === inputIdentName;
+  });
+}
+
+export function getAttrByReverseIdentName(attrs, inputEtype, inputIdentName) {
+  return Object.values(attrs).find((attr) => {
+    const revIdent = attr['reverse-identity'];
+    if (!revIdent) return false;
+    const [_id, etype, label] = revIdent;
+    return etype === inputEtype && label === inputIdentName;
+  });
+}
+
 function explodeLookupRef(eid) {
   if (Array.isArray(eid)) {
     return eid;
@@ -67,7 +64,7 @@ function explodeLookupRef(eid) {
   return entries[0];
 }
 
-function isRefLookupIdent(attrs: AttrsStore, etype: string, identName: string) {
+function isRefLookupIdent(attrs, etype, identName) {
   return (
     identName.indexOf('.') !== -1 &&
     // attr names can have `.` in them, so use the attr we find with a `.`
@@ -85,11 +82,7 @@ function extractRefLookupFwdName(identName) {
   return fwdName;
 }
 
-function lookupIdentToAttr(
-  attrs: AttrsStore,
-  etype: string,
-  identName: string,
-) {
+function lookupIdentToAttr(attrs, etype, identName) {
   if (!isRefLookupIdent(attrs, etype, identName)) {
     return getAttrByFwdIdentName(attrs, etype, identName);
   }
@@ -116,7 +109,7 @@ function lookupPairOfEid(eid) {
     : explodeLookupRef(eid);
 }
 
-function extractLookup(attrs: AttrsStore, etype: string, eid: string) {
+function extractLookup(attrs, etype, eid) {
   const lookupPair = lookupPairOfEid(eid);
 
   if (lookupPair === null) {
@@ -131,12 +124,7 @@ function extractLookup(attrs: AttrsStore, etype: string, eid: string) {
   return [attr.id, value];
 }
 
-function withIdAttrForLookup(
-  attrs: AttrsStore,
-  etype: string,
-  eidA: string,
-  txSteps: TXStep[],
-) {
+function withIdAttrForLookup(attrs, etype, eidA, txSteps) {
   const lookup = extractLookup(attrs, etype, eidA);
   if (!Array.isArray(lookup)) {
     return txSteps;
@@ -144,72 +132,63 @@ function withIdAttrForLookup(
   const idTuple = [
     'add-triple',
     lookup,
-    getAttrByFwdIdentName(attrs, etype, 'id')?.id,
+    getAttrByFwdIdentName(attrs, etype, 'id').id,
     lookup,
   ];
   return [idTuple].concat(txSteps);
 }
 
-function expandLink({ attrsStore }: Ctx, [etype, eidA, obj]) {
+function expandLink({ attrs }, [etype, eidA, obj]) {
   const addTriples = Object.entries(obj).flatMap(([label, eidOrEids]) => {
     const eids = Array.isArray(eidOrEids) ? eidOrEids : [eidOrEids];
-    const fwdAttr = getAttrByFwdIdentName(attrsStore, etype, label);
-    const revAttr = getAttrByReverseIdentName(attrsStore, etype, label);
+    const fwdAttr = getAttrByFwdIdentName(attrs, etype, label);
+    const revAttr = getAttrByReverseIdentName(attrs, etype, label);
     return eids.map((eidB) => {
       const txStep = fwdAttr
         ? [
             'add-triple',
-            extractLookup(attrsStore, etype, eidA),
+            extractLookup(attrs, etype, eidA),
             fwdAttr.id,
-            // XXX: Better error here
-            extractLookup(attrsStore, fwdAttr!['reverse-identity']![1], eidB),
+            extractLookup(attrs, fwdAttr['reverse-identity'][1], eidB),
           ]
         : [
             'add-triple',
-            // XXX: Better error here
-            extractLookup(attrsStore, revAttr!['forward-identity']![1], eidB),
-            revAttr?.id,
-            extractLookup(attrsStore, etype, eidA),
+            extractLookup(attrs, revAttr['forward-identity'][1], eidB),
+            revAttr.id,
+            extractLookup(attrs, etype, eidA),
           ];
       return txStep;
     });
   });
-  return withIdAttrForLookup(attrsStore, etype, eidA, addTriples);
+  return withIdAttrForLookup(attrs, etype, eidA, addTriples);
 }
 
-function expandUnlink({ attrsStore }: Ctx, [etype, eidA, obj]) {
+function expandUnlink({ attrs }, [etype, eidA, obj]) {
   const retractTriples = Object.entries(obj).flatMap(([label, eidOrEids]) => {
     const eids = Array.isArray(eidOrEids) ? eidOrEids : [eidOrEids];
-    const fwdAttr = getAttrByFwdIdentName(attrsStore, etype, label);
-    const revAttr = getAttrByReverseIdentName(attrsStore, etype, label);
+    const fwdAttr = getAttrByFwdIdentName(attrs, etype, label);
+    const revAttr = getAttrByReverseIdentName(attrs, etype, label);
     return eids.map((eidB) => {
       const txStep = fwdAttr
         ? [
             'retract-triple',
-            extractLookup(attrsStore, etype, eidA),
+            extractLookup(attrs, etype, eidA),
             fwdAttr.id,
-            // XXX: Better error here
-            extractLookup(attrsStore, fwdAttr!['reverse-identity']![1], eidB),
+            extractLookup(attrs, fwdAttr['reverse-identity'][1], eidB),
           ]
         : [
             'retract-triple',
-            // XXX: Better error here
-            extractLookup(attrsStore, revAttr!['forward-identity'][1], eidB),
-            revAttr!.id,
-            extractLookup(attrsStore, etype, eidA),
+            extractLookup(attrs, revAttr['forward-identity'][1], eidB),
+            revAttr.id,
+            extractLookup(attrs, etype, eidA),
           ];
       return txStep;
     });
   });
-  return withIdAttrForLookup(attrsStore, etype, eidA, retractTriples);
+  return withIdAttrForLookup(attrs, etype, eidA, retractTriples);
 }
 
-function checkEntityExists(
-  stores: (Store | undefined)[],
-  attrsStore: AttrsStore,
-  etype: string,
-  eid: string,
-) {
+function checkEntityExists(stores, etype, eid) {
   if (Array.isArray(eid)) {
     // lookup ref
     const [entity_a, entity_v] = eid;
@@ -230,7 +209,7 @@ function checkEntityExists(
       const av = store?.eav.get(eid);
       if (av) {
         for (const attr_id of av.keys()) {
-          if (attrsStore.getAttr(attr_id)?.['forward-identity'][1] == etype) {
+          if (store.attrs[attr_id]['forward-identity'][1] == etype) {
             return true;
           }
         }
@@ -240,34 +219,26 @@ function checkEntityExists(
   return false;
 }
 
-type Ctx = {
-  stores: (Store | undefined)[];
-  attrsStore: AttrsStore;
-  schema: Schema;
-  useDateObjects: boolean | null;
-};
-
-function convertOpts({ stores, attrsStore }: Ctx, [etype, eid, obj_, opts]) {
+function convertOpts({ stores, attrs }, [etype, eid, obj_, opts]) {
   return opts?.upsert === false
     ? { mode: 'update' }
     : opts?.upsert === true
       ? null
-      : checkEntityExists(stores, attrsStore, etype, eid)
+      : checkEntityExists(stores, etype, eid)
         ? { mode: 'update' }
         : null; // auto mode chooses between update and upsert, not update and create, just in case
 }
 
-function expandCreate(ctx: Ctx, step) {
-  const { attrsStore } = ctx;
+function expandCreate(ctx, step) {
+  const { stores, attrs } = ctx;
   const [etype, eid, obj_, opts] = step;
   const obj = immutableRemoveUndefined(obj_);
-  const lookup = extractLookup(attrsStore, etype, eid);
+  const lookup = extractLookup(attrs, etype, eid);
   // id first so that we don't clobber updates on the lookup field
   const attrTuples = [['id', lookup]]
     .concat(Object.entries(obj))
-    .map(([identName, value]: [string, any]) => {
-      // XXX: missing attr?
-      const attr = getAttrByFwdIdentName(attrsStore, etype, identName)!;
+    .map(([identName, value]) => {
+      const attr = getAttrByFwdIdentName(attrs, etype, identName);
 
       if (attr['checked-data-type'] === 'date' && ctx.useDateObjects) {
         value = coerceToDate(value);
@@ -278,17 +249,17 @@ function expandCreate(ctx: Ctx, step) {
   return attrTuples;
 }
 
-function expandUpdate(ctx: Ctx, step) {
-  const { attrsStore } = ctx;
+function expandUpdate(ctx, step) {
+  const { stores, attrs } = ctx;
   const [etype, eid, obj_, opts] = step;
   const obj = immutableRemoveUndefined(obj_);
-  const lookup = extractLookup(attrsStore, etype, eid);
+  const lookup = extractLookup(attrs, etype, eid);
   const serverOpts = convertOpts(ctx, [etype, lookup, obj_, opts]);
   // id first so that we don't clobber updates on the lookup field
   const attrTuples = [['id', lookup]]
     .concat(Object.entries(obj))
-    .map(([identName, value]: [string, any]) => {
-      const attr = getAttrByFwdIdentName(attrsStore, etype, identName)!;
+    .map(([identName, value]) => {
+      const attr = getAttrByFwdIdentName(attrs, etype, identName);
 
       if (attr['checked-data-type'] === 'date' && ctx.useDateObjects) {
         value = coerceToDate(value);
@@ -305,19 +276,19 @@ function expandUpdate(ctx: Ctx, step) {
   return attrTuples;
 }
 
-function expandDelete({ attrsStore }: Ctx, [etype, eid]) {
-  const lookup = extractLookup(attrsStore, etype, eid);
+function expandDelete({ attrs }, [etype, eid]) {
+  const lookup = extractLookup(attrs, etype, eid);
   return [['delete-entity', lookup, etype]];
 }
 
-function expandDeepMerge(ctx: Ctx, step) {
-  const { attrsStore } = ctx;
+function expandDeepMerge(ctx, step) {
+  const { stores, attrs } = ctx;
   const [etype, eid, obj_, opts] = step;
   const obj = immutableRemoveUndefined(obj_);
-  const lookup = extractLookup(attrsStore, etype, eid);
+  const lookup = extractLookup(attrs, etype, eid);
   const serverOpts = convertOpts(ctx, [etype, lookup, obj_, opts]);
   const attrTuples = Object.entries(obj).map(([identName, value]) => {
-    const attr = getAttrByFwdIdentName(attrsStore, etype, identName)!;
+    const attr = getAttrByFwdIdentName(attrs, etype, identName);
     return [
       'deep-merge-triple',
       lookup,
@@ -330,7 +301,7 @@ function expandDeepMerge(ctx: Ctx, step) {
   const idTuple = [
     'add-triple',
     lookup,
-    getAttrByFwdIdentName(attrsStore, etype, 'id')!.id,
+    getAttrByFwdIdentName(attrs, etype, 'id').id,
     lookup,
     ...(serverOpts ? [serverOpts] : []),
   ];
@@ -339,8 +310,8 @@ function expandDeepMerge(ctx: Ctx, step) {
   return [idTuple].concat(attrTuples);
 }
 
-function expandRuleParams({ attrsStore }: Ctx, [etype, eid, ruleParams]) {
-  const lookup = extractLookup(attrsStore, etype, eid);
+function expandRuleParams({ attrs }, [etype, eid, ruleParams]) {
+  const lookup = extractLookup(attrs, etype, eid);
   return [['rule-params', lookup, etype, ruleParams]];
 }
 
@@ -354,7 +325,7 @@ function removeIdFromArgs(step) {
   return [op, etype, eid, newObj, ...(opts ? [opts] : [])];
 }
 
-function toTxSteps(ctx: Ctx, step) {
+function toTxSteps(ctx, step) {
   const [action, ...args] = removeIdFromArgs(step);
   switch (action) {
     case 'merge':
@@ -427,12 +398,8 @@ function createObjectAttr(schema, etype, label, props) {
   };
 }
 
-type Link = LinkDef<any, any, any, any, any, any, any>;
-type Schema = IContainEntitiesAndLinks<any, any>;
-
-function findSchemaLink(schema: Schema, etype, label): Link | undefined {
-  const links: Link[] = Object.values(schema.links);
-  const found = links.find((x: Link) => {
+function findSchemaLink(schema, etype, label) {
+  const found = Object.values(schema.links).find((x) => {
     return (
       (x.forward.on === etype && x.forward.label === label) ||
       (x.reverse.on === etype && x.reverse.label === label)
@@ -441,7 +408,7 @@ function findSchemaLink(schema: Schema, etype, label): Link | undefined {
   return found;
 }
 
-function refPropsFromSchema(schema: Schema, etype, label) {
+function refPropsFromSchema(schema, etype, label) {
   const found = findSchemaLink(schema, etype, label);
   if (!found) {
     throw new Error(`Couldn't find the link ${etype}.${label} in your schema`);
@@ -457,26 +424,18 @@ function refPropsFromSchema(schema: Schema, etype, label) {
   };
 }
 
-function createRefAttr(
-  schema: Schema,
-  etype: string,
-  label: string,
-  props?: Partial<InstantDBAttr> | undefined,
-): InstantDBAttr {
+function createRefAttr(schema, etype, label, props) {
   const schemaRefProps = schema
     ? refPropsFromSchema(schema, etype, label)
     : null;
   const attrId = uuid();
-  const fwdIdent: InstantDBIdent = [uuid(), etype, label];
-  const revIdent: InstantDBIdent = [uuid(), label, etype];
+  const fwdIdent = [uuid(), etype, label];
+  const revIdent = [uuid(), label, etype];
   return {
     id: attrId,
-    // @ts-ignore: ts thinks it's any[]
     'forward-identity': fwdIdent,
-    // @ts-ignore: ts thinks it's any[]
     'reverse-identity': revIdent,
     'value-type': 'ref',
-    // @ts-ignore: ts thinks it's type string
     cardinality: 'many',
     'unique?': false,
     'index?': false,
@@ -500,14 +459,11 @@ const SUPPORTS_LOOKUP_ACTIONS = new Set([
   'ruleParams',
 ]);
 
-const lookupProps: Partial<InstantDBAttr> = { 'unique?': true, 'index?': true };
-const refLookupProps: Partial<InstantDBAttr> = {
-  ...lookupProps,
-  cardinality: 'one',
-};
+const lookupProps = { 'unique?': true, 'index?': true };
+const refLookupProps = { ...lookupProps, cardinality: 'one' };
 
 function lookupPairsOfOp(op) {
-  const res: { etype: string; lookupPair: any; linkLabel?: string }[] = [];
+  const res = [];
   const [action, etype, eid, obj] = op;
   if (!SUPPORTS_LOOKUP_ACTIONS.has(action)) {
     return res;
@@ -535,72 +491,24 @@ function lookupPairsOfOp(op) {
   return res;
 }
 
-function createMissingAttrs(
-  { attrsStore, schema }: Ctx,
-  ops,
-): [AttrsStore, TXStep[]] {
-  const addedIds = new Set();
-  const localAttrs: InstantDBAttr[] = [];
-  const addOps: TXStep[] = [];
-
-  function attrByFwdIdent(etype, label): InstantDBAttr | undefined {
-    return (
-      getAttrByFwdIdentName(attrsStore, etype, label) ||
-      localAttrs.find(
-        (x) =>
-          x['forward-identity'][1] === etype &&
-          x['forward-identity'][2] === label,
-      )
-    );
-  }
-
-  function attrByRevIdent(etype, label): InstantDBAttr | undefined {
-    return (
-      getAttrByReverseIdentName(attrsStore, etype, label) ||
-      localAttrs.find(
-        (x) =>
-          x['reverse-identity']?.[1] === etype &&
-          x['reverse-identity']?.[2] === label,
-      )
-    );
-  }
-
-  function addAttr(attr: InstantDBAttr) {
-    localAttrs.push(attr);
+function createMissingAttrs({ attrs: existingAttrs, schema }, ops) {
+  const [addedIds, attrs, addOps] = [new Set(), { ...existingAttrs }, []];
+  function addAttr(attr) {
+    attrs[attr.id] = attr;
     addOps.push(['add-attr', attr]);
     addedIds.add(attr.id);
   }
-  function addUnsynced(
-    attr:
-      | (InstantDBAttr & { isUnsynced?: boolean })
-      | InstantDBAttr
-      | undefined,
-  ) {
-    if (
-      attr &&
-      'isUnsynced' in attr &&
-      attr.isUnsynced &&
-      !addedIds.has(attr.id)
-    ) {
-      localAttrs.push(attr);
+  function addUnsynced(attr) {
+    if (attr?.isUnsynced && !addedIds.has(attr.id)) {
       addOps.push(['add-attr', attr]);
       addedIds.add(attr.id);
     }
   }
 
-  function isRefLookupIdentLocal(etype: string, identName: string) {
-    return (
-      identName.indexOf('.') !== -1 &&
-      // attr names can have `.` in them, so use the attr we find with a `.`
-      // before assuming it's a ref lookup.
-      !attrByRevIdent(etype, identName)
-    );
-  }
-
   // Adds attrs needed for a ref lookup
   function addForRef(etype, label) {
-    const fwdAttr = attrByFwdIdent(etype, label);
-    const revAttr = attrByRevIdent(etype, label);
+    const fwdAttr = getAttrByFwdIdentName(attrs, etype, label);
+    const revAttr = getAttrByReverseIdentName(attrs, etype, label);
     addUnsynced(fwdAttr);
     addUnsynced(revAttr);
     if (!fwdAttr && !revAttr) {
@@ -622,18 +530,18 @@ function createMissingAttrs(
 
         // Figure out the link etype so we can make sure we have the attrs
         // for the link lookup
-        const fwdAttr = attrByFwdIdent(etype, linkLabel);
-        const revAttr = attrByRevIdent(etype, linkLabel);
+        const fwdAttr = getAttrByFwdIdentName(attrs, etype, linkLabel);
+        const revAttr = getAttrByReverseIdentName(attrs, etype, linkLabel);
         addUnsynced(fwdAttr);
         addUnsynced(revAttr);
         const linkEtype =
           fwdAttr?.['reverse-identity']?.[1] ||
           revAttr?.['forward-identity']?.[1] ||
           linkLabel;
-        if (isRefLookupIdentLocal(linkEtype, identName)) {
+        if (isRefLookupIdent(attrs, linkEtype, identName)) {
           addForRef(linkEtype, extractRefLookupFwdName(identName));
         } else {
-          const attr = attrByFwdIdent(linkEtype, identName);
+          const attr = getAttrByFwdIdentName(attrs, linkEtype, identName);
           if (!attr) {
             addAttr(
               createObjectAttr(schema, linkEtype, identName, lookupProps),
@@ -641,10 +549,10 @@ function createMissingAttrs(
           }
           addUnsynced(attr);
         }
-      } else if (isRefLookupIdentLocal(etype, identName)) {
+      } else if (isRefLookupIdent(attrs, etype, identName)) {
         addForRef(etype, extractRefLookupFwdName(identName));
       } else {
-        const attr = attrByFwdIdent(etype, identName);
+        const attr = getAttrByFwdIdentName(attrs, etype, identName);
         if (!attr) {
           addAttr(createObjectAttr(schema, etype, identName, lookupProps));
         }
@@ -657,14 +565,14 @@ function createMissingAttrs(
   for (const op of ops) {
     const [action, etype, eid, obj] = op;
     if (OBJ_ACTIONS.has(action)) {
-      const idAttr = attrByFwdIdent(etype, 'id');
+      const idAttr = getAttrByFwdIdentName(attrs, etype, 'id');
       addUnsynced(idAttr);
       if (!idAttr) {
         addAttr(createObjectAttr(schema, etype, 'id', { 'unique?': true }));
       }
 
       for (const label of Object.keys(obj)) {
-        const fwdAttr = attrByFwdIdent(etype, label);
+        const fwdAttr = getAttrByFwdIdentName(attrs, etype, label);
         addUnsynced(fwdAttr);
         if (UPDATE_ACTIONS.has(action)) {
           if (!fwdAttr) {
@@ -679,7 +587,7 @@ function createMissingAttrs(
           }
         }
         if (REF_ACTIONS.has(action)) {
-          const revAttr = attrByRevIdent(etype, label);
+          const revAttr = getAttrByReverseIdentName(attrs, etype, label);
           if (!fwdAttr && !revAttr) {
             addAttr(createRefAttr(schema, etype, label));
           }
@@ -688,22 +596,14 @@ function createMissingAttrs(
       }
     }
   }
-
-  if (localAttrs.length) {
-    const nextAttrs = { ...attrsStore.attrs };
-    for (const attr of localAttrs) {
-      nextAttrs[attr.id] = attr;
-    }
-    return [new AttrsStore(nextAttrs, attrsStore.linkIndex), addOps];
-  }
-  return [attrsStore, addOps];
+  return [attrs, addOps];
 }
 
-export function transform(ctx: Ctx, inputChunks) {
+export function transform(ctx, inputChunks) {
   const chunks = Array.isArray(inputChunks) ? inputChunks : [inputChunks];
   const ops = chunks.flatMap((tx) => getOps(tx));
   const [newAttrs, addAttrTxSteps] = createMissingAttrs(ctx, ops);
-  const newCtx = { ...ctx, attrsStore: newAttrs };
+  const newCtx = { ...ctx, attrs: newAttrs };
   const txSteps = ops.flatMap((op) => toTxSteps(newCtx, op));
   return [...addAttrTxSteps, ...txSteps];
 }