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

package/src/instaql.ts

@@ -47,8 +47,8 @@ class AttrNotFoundError extends Error {
   }
 }
 
-function idAttr(attrsStore: s.AttrsStore, ns: string): InstantDBAttr {
-  const attr = s.getPrimaryKeyAttr(attrsStore, ns);
+function idAttr(store: s.Store, ns: string): InstantDBAttr {
+  const attr = s.getPrimaryKeyAttr(store, ns);
 
   if (!attr) {
     throw new AttrNotFoundError(`Could not find id attr for ${ns}`);
@@ -58,22 +58,22 @@ function idAttr(attrsStore: s.AttrsStore, ns: string): InstantDBAttr {
 
 function defaultWhere(
   makeVar: MakeVar,
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   etype: string,
   level: number,
 ): Pats {
-  return [eidWhere(makeVar, attrsStore, etype, level)];
+  return [eidWhere(makeVar, store, etype, level)];
 }
 
 function eidWhere(
   makeVar: MakeVar,
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   etype: string,
   level: number,
 ): Pat {
   return [
     makeVar(etype, level),
-    idAttr(attrsStore, etype).id,
+    idAttr(store, etype).id,
     makeVar(etype, level),
     makeVar('time', level),
   ];
@@ -85,13 +85,13 @@ function replaceInAttrPat(attrPat: Pat, needle: string, v: any): Pat {
 
 function refAttrPat(
   makeVar: MakeVar,
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   etype: string,
   level: number,
   label: string,
 ): [string, number, Pat, InstantDBAttr, boolean] {
-  const fwdAttr = s.getAttrByFwdIdentName(attrsStore, etype, label);
-  const revAttr = s.getAttrByReverseIdentName(attrsStore, etype, label);
+  const fwdAttr = s.getAttrByFwdIdentName(store, etype, label);
+  const revAttr = s.getAttrByReverseIdentName(store, etype, label);
   const attr = fwdAttr || revAttr;
 
   if (!attr) {
@@ -235,18 +235,14 @@ function parseValue(attr: InstantDBAttr, v: any) {
 
 function valueAttrPat(
   makeVar: MakeVar,
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   valueEtype: string,
   valueLevel: number,
   valueLabel: string,
   v: any,
 ): Pat {
-  const fwdAttr = s.getAttrByFwdIdentName(attrsStore, valueEtype, valueLabel);
-  const revAttr = s.getAttrByReverseIdentName(
-    attrsStore,
-    valueEtype,
-    valueLabel,
-  );
+  const fwdAttr = s.getAttrByFwdIdentName(store, valueEtype, valueLabel);
+  const revAttr = s.getAttrByReverseIdentName(store, valueEtype, valueLabel);
   const attr = fwdAttr || revAttr;
 
   if (!attr) {
@@ -256,7 +252,7 @@ function valueAttrPat(
   }
 
   if (v?.hasOwnProperty('$isNull')) {
-    const idAttr = s.getAttrByFwdIdentName(attrsStore, valueEtype, 'id');
+    const idAttr = s.getAttrByFwdIdentName(store, valueEtype, 'id');
     if (!idAttr) {
       throw new AttrNotFoundError(
         `No attr for etype = ${valueEtype} label = id`,
@@ -284,7 +280,7 @@ function valueAttrPat(
 
 function refAttrPats(
   makeVar: MakeVar,
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   etype: string,
   level: number,
   refsPath: string[],
@@ -294,7 +290,7 @@ function refAttrPats(
       const [etype, level, attrPats] = acc;
       const [nextEtype, nextLevel, attrPat] = refAttrPat(
         makeVar,
-        attrsStore,
+        store,
         etype,
         level,
         label,
@@ -309,7 +305,7 @@ function refAttrPats(
 
 function whereCondAttrPats(
   makeVar: MakeVar,
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   etype: string,
   level: number,
   path: string[],
@@ -319,14 +315,14 @@ function whereCondAttrPats(
   const valueLabel = path[path.length - 1];
   const [lastEtype, lastLevel, refPats] = refAttrPats(
     makeVar,
-    attrsStore,
+    store,
     etype,
     level,
     refsPath,
   );
   const valuePat = valueAttrPat(
     makeVar,
-    attrsStore,
+    store,
     lastEtype,
     lastLevel,
     valueLabel,
@@ -363,7 +359,7 @@ function genMakeVar(baseMakeVar: MakeVar, joinSym: string, orIdx: number) {
 function parseWhereClauses(
   makeVar: MakeVar,
   clauseType: 'or' | 'and' /* 'or' | 'and' */,
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   etype: string,
   level: number,
   whereValue: any,
@@ -371,7 +367,7 @@ function parseWhereClauses(
   const joinSym = makeVar(etype, level);
   const patterns: FullPats = whereValue.map((w, i) => {
     const makeNamespacedVar = genMakeVar(makeVar, joinSym, i);
-    return parseWhere(makeNamespacedVar, attrsStore, etype, level, w);
+    return parseWhere(makeNamespacedVar, store, etype, level, w);
   });
   return { [clauseType]: { patterns, joinSym } } as AndPat | OrPat;
 }
@@ -390,31 +386,29 @@ function growPath<T>(path: T[]) {
 // to capture any intermediate nulls
 function whereCondAttrPatsForNullIsTrue(
   makeVar: MakeVar,
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   etype: string,
   level: number,
   path: string[],
 ): Pats[] {
   return growPath(path).map((path) =>
-    whereCondAttrPats(makeVar, attrsStore, etype, level, path, {
-      $isNull: true,
-    }),
+    whereCondAttrPats(makeVar, store, etype, level, path, { $isNull: true }),
   );
 }
 
 function parseWhere(
   makeVar: MakeVar,
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   etype: string,
   level: number,
   where: Record<string, any>,
 ): FullPats {
   return Object.entries(where).flatMap(([k, v]) => {
     if (isOrClauses([k, v])) {
-      return parseWhereClauses(makeVar, 'or', attrsStore, etype, level, v);
+      return parseWhereClauses(makeVar, 'or', store, etype, level, v);
     }
     if (isAndClauses([k, v])) {
-      return parseWhereClauses(makeVar, 'and', attrsStore, etype, level, v);
+      return parseWhereClauses(makeVar, 'and', store, etype, level, v);
     }
 
     // Temporary hack until we have support for a uuid index on `id`
@@ -433,17 +427,10 @@ function parseWhere(
     if (v?.hasOwnProperty('$not')) {
       // `$not` won't pick up entities that are missing the attr, so we
       // add in a `$isNull` to catch those too.
-      const notPats = whereCondAttrPats(
-        makeVar,
-        attrsStore,
-        etype,
-        level,
-        path,
-        v,
-      );
+      const notPats = whereCondAttrPats(makeVar, store, etype, level, path, v);
       const nilPats = whereCondAttrPatsForNullIsTrue(
         makeVar,
-        attrsStore,
+        store,
         etype,
         level,
         path,
@@ -466,7 +453,7 @@ function parseWhere(
           or: {
             patterns: whereCondAttrPatsForNullIsTrue(
               makeVar,
-              attrsStore,
+              store,
               etype,
               level,
               path,
@@ -477,22 +464,22 @@ function parseWhere(
       ];
     }
 
-    return whereCondAttrPats(makeVar, attrsStore, etype, level, path, v);
+    return whereCondAttrPats(makeVar, store, etype, level, path, v);
   });
 }
 
 function makeWhere(
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   etype: string,
   level: number,
   where: Record<string, any> | null,
 ): FullPats {
   const makeVar = makeVarImpl;
   if (!where) {
-    return defaultWhere(makeVar, attrsStore, etype, level);
+    return defaultWhere(makeVar, store, etype, level);
   }
-  const parsedWhere = parseWhere(makeVar, attrsStore, etype, level, where);
-  return parsedWhere.concat(defaultWhere(makeVar, attrsStore, etype, level));
+  const parsedWhere = parseWhere(makeVar, store, etype, level, where);
+  return parsedWhere.concat(defaultWhere(makeVar, store, etype, level));
 }
 
 // Find
@@ -507,7 +494,7 @@ function makeFind(makeVar: MakeVar, etype: string, level: number) {
 
 function makeJoin(
   makeVar: MakeVar,
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   etype: string,
   level: number,
   label: string,
@@ -515,7 +502,7 @@ function makeJoin(
 ) {
   const [nextEtype, nextLevel, pat, attr, isForward] = refAttrPat(
     makeVar,
-    attrsStore,
+    store,
     etype,
     level,
     label,
@@ -524,13 +511,7 @@ function makeJoin(
   return [nextEtype, nextLevel, actualized, attr, isForward];
 }
 
-function extendObjects(
-  makeVar: MakeVar,
-  store: s.Store,
-  attrsStore: s.AttrsStore,
-  { etype, level, form },
-  objects,
-) {
+function extendObjects(makeVar, store, { etype, level, form }, objects) {
   const childQueries = Object.keys(form).filter((c) => c !== '$');
   if (!childQueries.length) {
     return Object.values(objects);
@@ -539,20 +520,20 @@ function extendObjects(
     const childResults = childQueries.map(function getChildResult(label) {
       const isSingular = Boolean(
         store.cardinalityInference &&
-          attrsStore.linkIndex?.[etype]?.[label]?.isSingular,
+          store.linkIndex?.[etype]?.[label]?.isSingular,
       );
 
       try {
         const [nextEtype, nextLevel, join] = makeJoin(
           makeVar,
-          attrsStore,
+          store,
           etype,
           level,
           label,
           eid,
         );
 
-        const childrenArray = queryOne(store, attrsStore, {
+        const childrenArray = queryOne(store, {
           etype: nextEtype,
           level: nextLevel,
           form: form[label],
@@ -643,38 +624,38 @@ function isBefore(startCursor, orderAttr, direction, idVec) {
   );
 }
 
-function orderAttrFromCursor(attrsStore: s.AttrsStore, cursor) {
+function orderAttrFromCursor(store: s.Store, cursor) {
   const cursorAttrId = cursor[1];
-  return attrsStore.getAttr(cursorAttrId);
+  return store.attrs[cursorAttrId];
 }
 
-function orderAttrFromOrder(attrsStore: s.AttrsStore, etype, order) {
+function orderAttrFromOrder(store: s.Store, etype, order) {
   const label = Object.keys(order)[0];
-  return s.getAttrByFwdIdentName(attrsStore, etype, label);
+  return s.getAttrByFwdIdentName(store, etype, label);
 }
 
-function getOrderAttr(attrsStore: s.AttrsStore, etype, cursor, order) {
+function getOrderAttr(store: s.Store, etype, cursor, order) {
   if (cursor) {
-    return orderAttrFromCursor(attrsStore, cursor);
+    return orderAttrFromCursor(store, cursor);
   }
   if (order) {
-    return orderAttrFromOrder(attrsStore, etype, order);
+    return orderAttrFromOrder(store, etype, order);
   }
 }
 
 function objectAttrs(
-  attrsStore: s.AttrsStore,
+  store: s.Store,
   etype,
   dq,
 ): Map<string, InstantDBAttr> | undefined {
   if (!Array.isArray(dq.fields)) {
-    return s.getBlobAttrs(attrsStore, etype);
+    return s.getBlobAttrs(store, etype);
   }
 
   const attrs = new Map();
 
   for (const field of dq.fields) {
-    const attr = s.getAttrByFwdIdentName(attrsStore, etype, field);
+    const attr = s.getAttrByFwdIdentName(store, etype, field);
     const label = attr?.['forward-identity']?.[2];
     if (label && s.isBlob(attr)) {
       attrs.set(label, attr);
@@ -682,7 +663,7 @@ function objectAttrs(
   }
   // Ensure we add the id field to avoid empty objects
   if (!attrs.has('id')) {
-    const attr = s.getAttrByFwdIdentName(attrsStore, etype, 'id');
+    const attr = s.getAttrByFwdIdentName(store, etype, 'id');
     const label = attr?.['forward-identity']?.[2];
     if (label) {
       attrs.set(label, attr);
@@ -694,7 +675,6 @@ function objectAttrs(
 
 function runDataloadAndReturnObjects(
   store: s.Store,
-  attrsStore: s.AttrsStore,
   { etype, pageInfo, dq, form },
 ) {
   const order = form?.$?.order;
@@ -704,7 +684,7 @@ function runDataloadAndReturnObjects(
   let idVecs = datalogQuery(store, dq);
 
   const startCursor = pageInfo?.['start-cursor'];
-  const orderAttr = getOrderAttr(attrsStore, etype, startCursor, order);
+  const orderAttr = getOrderAttr(store, etype, startCursor, order);
 
   if (orderAttr && orderAttr?.['forward-identity']?.[2] !== 'id') {
     const isDate = orderAttr['checked-data-type'] === 'date';
@@ -731,7 +711,7 @@ function runDataloadAndReturnObjects(
   );
 
   let objects = {};
-  const attrs = objectAttrs(attrsStore, etype, dq);
+  const attrs = objectAttrs(store, etype, dq);
 
   for (const idVec of idVecs) {
     const [id] = idVec;
@@ -791,7 +771,6 @@ function isLeading(form) {
  */
 function resolveObjects(
   store: s.Store,
-  attrsStore: s.AttrsStore,
   { etype, level, form, join, pageInfo },
 ) {
   // Wait for server to tell us where we start if we don't start from the beginning
@@ -799,14 +778,11 @@ function resolveObjects(
     return [];
   }
 
-  const where = withJoin(
-    makeWhere(attrsStore, etype, level, form.$?.where),
-    join,
-  );
+  const where = withJoin(makeWhere(store, etype, level, form.$?.where), join);
   const find = makeFind(makeVarImpl, etype, level);
   const fields = form.$?.fields;
 
-  const objs = runDataloadAndReturnObjects(store, attrsStore, {
+  const objs = runDataloadAndReturnObjects(store, {
     etype,
     pageInfo,
     form,
@@ -840,9 +816,9 @@ function resolveObjects(
  * This swallows the missing attr error and returns
  * an empty result instead
  */
-function guardedResolveObjects(store: s.Store, attrsStore: s.AttrsStore, opts) {
+function guardedResolveObjects(store: s.Store, opts) {
   try {
-    return resolveObjects(store, attrsStore, opts);
+    return resolveObjects(store, opts);
   } catch (e) {
     if (e instanceof AttrNotFoundError) {
       return {};
@@ -863,9 +839,9 @@ function guardedResolveObjects(store: s.Store, attrsStore: s.AttrsStore, opts) {
  * `guardResolveObjects` will return the relevant `users` objects
  * `extendObjects` will then extend each `user` object with relevant `posts`.
  */
-function queryOne(store: s.Store, attrsStore: s.AttrsStore, opts) {
-  const objects = guardedResolveObjects(store, attrsStore, opts);
-  return extendObjects(makeVarImpl, store, attrsStore, opts, objects);
+function queryOne(store: s.Store, opts) {
+  const objects = guardedResolveObjects(store, opts);
+  return extendObjects(makeVarImpl, store, opts, objects);
 }
 
 function formatPageInfo(
@@ -894,12 +870,10 @@ function formatPageInfo(
 export default function query(
   {
     store,
-    attrsStore,
     pageInfo,
     aggregate,
   }: {
     store: s.Store;
-    attrsStore: s.AttrsStore;
     pageInfo: any;
     aggregate: any;
   },
@@ -911,7 +885,7 @@ export default function query(
       // so don't bother querying further
       return res;
     }
-    res[k] = queryOne(store, attrsStore, {
+    res[k] = queryOne(store, {
       etype: k,
       form: q[k],
       level: 0,