@instantdb/core 0.22.88 → 0.22.89-experimental.drewh-ssr.20277611943.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instantdb/core",
-  "version": "0.22.88",
+  "version": "0.22.89-experimental.drewh-ssr.20277611943.1",
   "description": "Instant's core local abstraction",
   "homepage": "https://github.com/instantdb/instant/tree/main/client/packages/core",
   "repository": {
@@ -53,7 +53,7 @@
   "dependencies": {
     "mutative": "^1.0.10",
     "uuid": "^11.1.0",
-    "@instantdb/version": "0.22.88"
+    "@instantdb/version": "0.22.89-experimental.drewh-ssr.20277611943.1"
   },
   "scripts": {
     "test": "vitest",

package/src/Reactor.js

@@ -1,7 +1,7 @@
 // @ts-check
 import weakHash from './utils/weakHash.ts';
 import instaql from './instaql.ts';
-import * as instaml from './instaml.js';
+import * as instaml from './instaml.ts';
 import * as s from './store.ts';
 import uuid from './utils/uuid.ts';
 import IndexedDBStorage from './IndexedDBStorage.ts';
@@ -36,6 +36,8 @@ import { SyncTable } from './SyncTable.ts';
 /** @typedef {import('./Connection.ts').Connection} Connection */
 /** @typedef {import('./Connection.ts').TransportType} TransportType */
 /** @typedef {import('./Connection.ts').EventSourceConstructor} EventSourceConstructor */
+/** @typedef {import('./reactorTypes.ts').QuerySub} QuerySub */
+/** @typedef {import('./reactorTypes.ts').QuerySubInStorage} QuerySubInStorage */
 
 const STATUS = {
   CONNECTING: 'connecting',
@@ -107,27 +109,52 @@ const ignoreLogging = {
   'patch-presence': true,
 };
 
+/**
+ * @param {QuerySubInStorage} x
+ * @param {boolean | null} useDateObjects
+ * @returns {QuerySub}
+ */
 function querySubFromStorage(x, useDateObjects) {
   const v = typeof x === 'string' ? JSON.parse(x) : x;
 
   if (v?.result?.store) {
-    const storeJSON = v.result.store;
-    v.result.store = s.fromJSON({
-      ...storeJSON,
-      useDateObjects: useDateObjects,
-    });
+    const attrsStore = s.attrsStoreFromJSON(
+      v.result.attrsStore,
+      v.result.store,
+    );
+    if (attrsStore) {
+      const storeJSON = v.result.store;
+      v.result.store = s.fromJSON(attrsStore, {
+        ...storeJSON,
+        useDateObjects: useDateObjects,
+      });
+      v.result.attrsStore = attrsStore;
+    }
   }
 
   return v;
 }
 
+/**
+ *
+ * @param {string} _key
+ * @param {QuerySub} sub
+ * @returns QuerySubInStorage
+ */
 function querySubToStorage(_key, sub) {
-  const jsonSub = { ...sub };
-  if (sub.result?.store) {
-    jsonSub.result = {
-      ...sub.result,
-      store: s.toJSON(sub.result.store),
+  const { result, ...rest } = sub;
+  const jsonSub = /** @type {import('./reactorTypes.ts').QuerySubInStorage} */ (
+    rest
+  );
+  if (result) {
+    /** @type {import('./reactorTypes.ts').QuerySubResultInStorage} */
+    const jsonResult = {
+      ...result,
+      store: s.toJSON(result.store),
+      attrsStore: result.attrsStore.toJSON(),
     };
+
+    jsonSub.result = jsonResult;
   }
   return jsonSub;
 }
@@ -176,12 +203,13 @@ function sortedMutationEntries(entries) {
  * @template {import('./presence.ts').RoomSchemaShape} [RoomSchema = {}]
  */
 export default class Reactor {
+  /** @type {s.AttrsStore | undefined} */
   attrs;
   _isOnline = true;
   _isShutdown = false;
   status = STATUS.CONNECTING;
 
-  /** @type {PersistedObject} */
+  /** @type {PersistedObject<string, QuerySub, QuerySubInStorage>} */
   querySubs;
 
   /** @type {PersistedObject} */
@@ -306,20 +334,31 @@ export default class Reactor {
         useDateObjects: this.config.useDateObjects,
       },
       this._log,
-      (triples) =>
-        s.createStore(
-          this.attrs,
+      (triples) => {
+        return s.createStore(
+          this.ensureAttrs(),
           triples,
           this.config.enableCardinalityInference,
-          this._linkIndex,
           this.config.useDateObjects,
-        ),
+        );
+      },
+      () => this.ensureAttrs(),
     );
 
     this._oauthCallbackResponse = this._oauthLoginInit();
 
     // kick off a request to cache it
-    this.getCurrentUser();
+    this.getCurrentUser().then((userInfo) => {
+      this.syncUserToEndpoint(userInfo.user);
+    });
+
+    setInterval(
+      async () => {
+        const currentUser = await this.getCurrentUser();
+        this.syncUserToEndpoint(currentUser.user);
+      },
+      1000 * 60 * 20,
+    );
 
     NetworkListener.getIsOnline().then((isOnline) => {
       this._isOnline = isOnline;
@@ -353,6 +392,13 @@ export default class Reactor {
     }
   }
 
+  ensureAttrs() {
+    if (!this.attrs) {
+      throw new Error('attrs have not loaded.');
+    }
+    return this.attrs;
+  }
+
   updateSchema(schema) {
     this.config = {
       ...this.config,
@@ -383,7 +429,7 @@ export default class Reactor {
       serialize: querySubToStorage,
       parse: (_key, x) => querySubFromStorage(x, this.config.useDateObjects),
       // objectSize
-      objectSize: (x) => x.result?.store?.triples?.length ?? 0,
+      objectSize: (x) => x?.result?.store?.triples?.length ?? 0,
       logger: this._log,
       preloadEntryCount: 10,
       gc: {
@@ -513,6 +559,43 @@ export default class Reactor {
     }
   }
 
+  /**
+   * Does the same thing as add-query-ok
+   * but called as a result of receiving query info from ssr
+   * @param {any} q
+   * @param {{ triples: any; pageInfo: any; }} result
+   * @param {boolean} enableCardinalityInference
+   */
+  _addQueryData(q, result, enableCardinalityInference) {
+    if (!this.attrs) {
+      throw new Error('Attrs in reactor have not been set');
+    }
+    const queryHash = weakHash(q);
+    const attrsStore = this.ensureAttrs();
+    const store = s.createStore(
+      this.attrs,
+      result.triples,
+      enableCardinalityInference,
+      this.config.useDateObjects,
+    );
+    this.querySubs.updateInPlace((prev) => {
+      prev[queryHash] = {
+        result: {
+          store,
+          attrsStore,
+          pageInfo: result.pageInfo,
+          processedTxId: undefined,
+          isExternal: true,
+        },
+        q,
+      };
+    });
+    this._cleanupPendingMutationsQueries();
+    this.notifyOne(queryHash);
+    this.notifyOneQueryOnce(queryHash);
+    this._cleanupPendingMutationsTimeout();
+  }
+
   _handleReceive(connId, msg) {
     // opt-out, enabled by default if schema
     const enableCardinalityInference =
@@ -552,13 +635,14 @@ export default class Reactor {
         const pageInfo = result?.[0]?.data?.['page-info'];
         const aggregate = result?.[0]?.data?.['aggregate'];
         const triples = extractTriples(result);
+        const attrsStore = this.ensureAttrs();
         const store = s.createStore(
-          this.attrs,
+          attrsStore,
           triples,
           enableCardinalityInference,
-          this._linkIndex,
           this.config.useDateObjects,
         );
+
         this.querySubs.updateInPlace((prev) => {
           if (!prev[hash]) {
             this._log.info('Missing value in querySubs', { hash, q });
@@ -566,6 +650,7 @@ export default class Reactor {
           }
           prev[hash].result = {
             store,
+            attrsStore,
             pageInfo,
             aggregate,
             processedTxId: msg['processed-tx-id'],
@@ -603,7 +688,7 @@ export default class Reactor {
         this._cleanupPendingMutationsTimeout();
 
         const rewrittenMutations = this._rewriteMutations(
-          this.attrs,
+          this.ensureAttrs(),
           this._pendingMutations(),
           processedTxId,
         );
@@ -624,32 +709,49 @@ export default class Reactor {
           const result = x['instaql-result'];
           const hash = weakHash(q);
           const triples = extractTriples(result);
+          const attrsStore = this.ensureAttrs();
           const store = s.createStore(
-            this.attrs,
+            attrsStore,
             triples,
             enableCardinalityInference,
-            this._linkIndex,
             this.config.useDateObjects,
           );
-          const newStore = this._applyOptimisticUpdates(
-            store,
-            mutations,
-            processedTxId,
-          );
+          const { store: newStore, attrsStore: newAttrsStore } =
+            this._applyOptimisticUpdates(
+              store,
+              attrsStore,
+              mutations,
+              processedTxId,
+            );
           const pageInfo = result?.[0]?.data?.['page-info'];
           const aggregate = result?.[0]?.data?.['aggregate'];
-          return { q, hash, store: newStore, pageInfo, aggregate };
+          return {
+            q,
+            hash,
+            store: newStore,
+            attrsStore: newAttrsStore,
+            pageInfo,
+            aggregate,
+          };
         });
 
-        updates.forEach(({ hash, q, store, pageInfo, aggregate }) => {
-          this.querySubs.updateInPlace((prev) => {
-            if (!prev[hash]) {
-              this._log.error('Missing value in querySubs', { hash, q });
-              return;
-            }
-            prev[hash].result = { store, pageInfo, aggregate, processedTxId };
-          });
-        });
+        updates.forEach(
+          ({ hash, q, store, attrsStore, pageInfo, aggregate }) => {
+            this.querySubs.updateInPlace((prev) => {
+              if (!prev[hash]) {
+                this._log.error('Missing value in querySubs', { hash, q });
+                return;
+              }
+              prev[hash].result = {
+                store,
+                attrsStore,
+                pageInfo,
+                aggregate,
+                processedTxId,
+              };
+            });
+          },
+        );
 
         this._cleanupPendingMutationsQueries();
 
@@ -664,7 +766,7 @@ export default class Reactor {
         this._inFlightMutationEventIds.delete(eventId);
 
         const muts = this._rewriteMutations(
-          this.attrs,
+          this.ensureAttrs(),
           this._pendingMutations(),
         );
         const prevMutation = muts.get(eventId);
@@ -681,12 +783,17 @@ export default class Reactor {
           });
         });
 
-        const newAttrs = prevMutation['tx-steps']
-          .filter(([action, ..._args]) => action === 'add-attr')
-          .map(([_action, attr]) => attr)
-          .concat(Object.values(this.attrs));
-
-        this._setAttrs(newAttrs);
+        const newAttrs = [];
+        for (const step of prevMutation['tx-steps']) {
+          if (step[0] === 'add-attr') {
+            const attr = step[1];
+            newAttrs.push(attr);
+          }
+        }
+        if (newAttrs.length) {
+          const existingAttrs = Object.values(this.ensureAttrs().attrs);
+          this._setAttrs([...existingAttrs, ...newAttrs]);
+        }
 
         this._finishTransaction('synced', eventId);
 
@@ -870,10 +977,13 @@ export default class Reactor {
   }
 
   _setAttrs(attrs) {
-    this.attrs = attrs.reduce((acc, attr) => {
-      acc[attr.id] = attr;
-      return acc;
-    }, {});
+    this.attrs = new s.AttrsStoreClass(
+      attrs.reduce((acc, attr) => {
+        acc[attr.id] = attr;
+        return acc;
+      }, {}),
+      this._linkIndex,
+    );
 
     this.notifyAttrsSubs();
   }
@@ -1022,17 +1132,23 @@ export default class Reactor {
   // We remove `add-attr` commands for attrs that already exist.
   // We update `add-triple` and `retract-triple` commands to use the
   // server attr-ids.
+  /**
+   *
+   * @param {s.AttrsStore} attrs
+   * @param {any} muts
+   * @param {number} [processedTxId]
+   */
   _rewriteMutations(attrs, muts, processedTxId) {
     if (!attrs) return muts;
     if (!muts) return new Map();
     const findExistingAttr = (attr) => {
       const [_, etype, label] = attr['forward-identity'];
-      const existing = instaml.getAttrByFwdIdentName(attrs, etype, label);
+      const existing = s.getAttrByFwdIdentName(attrs, etype, label);
       return existing;
     };
     const findReverseAttr = (attr) => {
       const [_, etype, label] = attr['forward-identity'];
-      const revAttr = instaml.getAttrByReverseIdentName(attrs, etype, label);
+      const revAttr = s.getAttrByReverseIdentName(attrs, etype, label);
       return revAttr;
     };
     const mapping = { attrIdMap: {}, refSwapAttrIds: new Set() };
@@ -1109,6 +1225,9 @@ export default class Reactor {
   // ---------------------------
   // Transact
 
+  /**
+   * @returns {s.AttrsStore}
+   */
   optimisticAttrs() {
     const pendingMutationSteps = [...this._pendingMutations().values()] // hack due to Map()
       .flatMap((x) => x['tx-steps']);
@@ -1126,27 +1245,30 @@ export default class Reactor {
       } else if (
         _action === 'update-attr' &&
         attr.id &&
-        this.attrs?.[attr.id]
+        this.attrs?.getAttr(attr.id)
       ) {
-        const fullAttr = { ...this.attrs[attr.id], ...attr };
+        const fullAttr = { ...this.attrs.getAttr(attr.id), ...attr };
         pendingAttrs.push(fullAttr);
       }
     }
 
-    const attrsWithoutDeleted = [
-      ...Object.values(this.attrs || {}),
-      ...pendingAttrs,
-    ].filter((a) => !deletedAttrIds.has(a.id));
+    if (!deletedAttrIds.size && !pendingAttrs.length) {
+      return this.attrs || new s.AttrsStoreClass({}, this._linkIndex);
+    }
 
-    const attrsRecord = Object.fromEntries(
-      attrsWithoutDeleted.map((a) => [a.id, a]),
-    );
+    const attrs = { ...(this.attrs?.attrs || {}) };
+    for (const attr of pendingAttrs) {
+      attrs[attr.id] = attr;
+    }
+    for (const id of deletedAttrIds) {
+      delete attrs[id];
+    }
 
-    return attrsRecord;
+    return new s.AttrsStoreClass(attrs, this._linkIndex);
   }
 
   /** Runs instaql on a query and a store */
-  dataForQuery(hash) {
+  dataForQuery(hash, applyOptimistic = true) {
     const errorMessage = this._errorMessage;
     if (errorMessage) {
       return { error: errorMessage };
@@ -1170,28 +1292,41 @@ export default class Reactor {
       return cached;
     }
 
-    const { store, pageInfo, aggregate, processedTxId } = result;
+    let store = result.store;
+    let attrsStore = result.attrsStore;
+    const { pageInfo, aggregate, processedTxId } = result;
     const mutations = this._rewriteMutationsSorted(
-      store.attrs,
+      attrsStore,
       pendingMutations,
     );
-    const newStore = this._applyOptimisticUpdates(
-      store,
-      mutations,
-      processedTxId,
+    if (applyOptimistic) {
+      const optimisticResult = this._applyOptimisticUpdates(
+        store,
+        attrsStore,
+        mutations,
+        processedTxId,
+      );
+
+      store = optimisticResult.store;
+      attrsStore = optimisticResult.attrsStore;
+    }
+    const resp = instaql(
+      { store: store, attrsStore: attrsStore, pageInfo, aggregate },
+      q,
     );
-    const resp = instaql({ store: newStore, pageInfo, aggregate }, q);
 
     return { data: resp, querySubVersion, pendingMutationsVersion };
   }
 
-  _applyOptimisticUpdates(store, mutations, processedTxId) {
+  _applyOptimisticUpdates(store, attrsStore, mutations, processedTxId) {
     for (const [_, mut] of mutations) {
       if (!mut['tx-id'] || (processedTxId && mut['tx-id'] > processedTxId)) {
-        store = s.transact(store, mut['tx-steps']);
+        const result = s.transact(store, attrsStore, mut['tx-steps']);
+        store = result.store;
+        attrsStore = result.attrsStore;
       }
     }
-    return store;
+    return { store, attrsStore };
   }
 
   /** Re-run instaql and call all callbacks with new data */
@@ -1248,7 +1383,7 @@ export default class Reactor {
     try {
       const txSteps = instaml.transform(
         {
-          attrs: this.optimisticAttrs(),
+          attrsStore: this.optimisticAttrs(),
           schema: this.config.schema,
           stores: Object.values(this.querySubs.currentValue).map(
             (sub) => sub?.result?.store,
@@ -1366,7 +1501,7 @@ export default class Reactor {
       });
 
     const muts = this._rewriteMutationsSorted(
-      this.attrs,
+      this.ensureAttrs(),
       this._pendingMutations(),
     );
     muts.forEach(([eventId, mut]) => {
@@ -1822,7 +1957,7 @@ export default class Reactor {
     this.attrsCbs.push(cb);
 
     if (this.attrs) {
-      cb(this.attrs);
+      cb(this.attrs.attrs);
     }
 
     return () => {
@@ -1841,7 +1976,7 @@ export default class Reactor {
   notifyAttrsSubs() {
     if (!this.attrs) return;
     const oas = this.optimisticAttrs();
-    this.attrsCbs.forEach((cb) => cb(oas));
+    this.attrsCbs.forEach((cb) => cb(oas.attrs));
   }
 
   notifyConnectionStatusSubs(status) {
@@ -1912,7 +2047,27 @@ export default class Reactor {
     }
   }
 
+  async syncUserToEndpoint(user) {
+    if (this.config.cookieEndpoint) {
+      try {
+        fetch(this.config.cookieEndpoint + '/sync-auth', {
+          method: 'POST',
+          body: JSON.stringify({
+            user: user,
+          }),
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        });
+      } catch (error) {
+        console.error('Error syncing user with external endpoint', error);
+      }
+    }
+  }
+
   updateUser(newUser) {
+    this.syncUserToEndpoint(newUser);
+
     const newV = { error: undefined, user: newUser };
     this._currentUserCached = { isLoading: false, ...newV };
     this._dataForQueryCache = {};