@instantdb/core 0.22.88-experimental.drewh-ssr.20251523170.1 → 0.22.88-experimental.split-store.20252005043.1

package/dist/esm/Reactor.js

@@ -21,7 +21,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 // @ts-check
 import weakHash from "./utils/weakHash.js";
 import instaql from "./instaql.js";
-import * as instaml from './instaml.js';
+import * as instaml from "./instaml.js";
 import * as s from "./store.js";
 import uuid from "./utils/uuid.js";
 import IndexedDBStorage from "./IndexedDBStorage.js";
@@ -49,6 +49,8 @@ import { SyncTable } from "./SyncTable.js";
 /** @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',
     OPENED: 'opened',
@@ -101,20 +103,37 @@ const ignoreLogging = {
     'refresh-presence': true,
     'patch-presence': true,
 };
+/**
+ * @param {QuerySubInStorage} x
+ * @param {boolean | null} useDateObjects
+ * @returns {QuerySub}
+ */
 function querySubFromStorage(x, useDateObjects) {
     var _a;
     const v = typeof x === 'string' ? JSON.parse(x) : x;
     if ((_a = v === null || v === void 0 ? void 0 : v.result) === null || _a === void 0 ? void 0 : _a.store) {
-        const storeJSON = v.result.store;
-        v.result.store = s.fromJSON(Object.assign(Object.assign({}, 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, Object.assign(Object.assign({}, storeJSON), { useDateObjects: useDateObjects }));
+            v.result.attrsStore = attrsStore;
+        }
     }
     return v;
 }
+/**
+ *
+ * @param {string} _key
+ * @param {QuerySub} sub
+ * @returns QuerySubInStorage
+ */
 function querySubToStorage(_key, sub) {
-    var _a;
-    const jsonSub = Object.assign({}, sub);
-    if ((_a = sub.result) === null || _a === void 0 ? void 0 : _a.store) {
-        jsonSub.result = Object.assign(Object.assign({}, sub.result), { store: s.toJSON(sub.result.store) });
+    const { result } = sub, rest = __rest(sub, ["result"]);
+    const jsonSub = /** @type {import('./reactorTypes.ts').QuerySubInStorage} */ (rest);
+    if (result) {
+        /** @type {import('./reactorTypes.ts').QuerySubResultInStorage} */
+        const jsonResult = Object.assign(Object.assign({}, result), { store: s.toJSON(result.store), attrsStore: result.attrsStore.toJSON() });
+        jsonSub.result = jsonResult;
     }
     return jsonSub;
 }
@@ -259,7 +278,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) => { var _a; return (_a = sub === null || sub === void 0 ? void 0 : sub.result) === null || _a === void 0 ? void 0 : _a.store; }),
                     useDateObjects: this.config.useDateObjects,
@@ -425,16 +444,12 @@ export default class Reactor {
         this._initStorage(Storage);
         this._syncTable = new SyncTable(this._trySendAuthed.bind(this), new Storage(this.config.appId, 'syncSubs'), {
             useDateObjects: this.config.useDateObjects,
-        }, this._log, (triples) => s.createStore(this.attrs, triples, this.config.enableCardinalityInference, this._linkIndex, this.config.useDateObjects));
+        }, this._log, (triples) => {
+            return s.createStore(this.ensureAttrs(), triples, this.config.enableCardinalityInference, this.config.useDateObjects);
+        }, () => this.ensureAttrs());
         this._oauthCallbackResponse = this._oauthLoginInit();
         // kick off a request to cache it
-        this.getCurrentUser().then((userInfo) => {
-            this.syncUserToEndpoint(userInfo.user);
-        });
-        setInterval(() => __awaiter(this, void 0, void 0, function* () {
-            const currentUser = yield this.getCurrentUser();
-            this.syncUserToEndpoint(currentUser.user);
-        }), 1000 * 60 * 20);
+        this.getCurrentUser();
         NetworkListener.getIsOnline().then((isOnline) => {
             this._isOnline = isOnline;
             this._startSocket();
@@ -461,6 +476,12 @@ export default class Reactor {
             addEventListener('beforeunload', this._beforeUnload);
         }
     }
+    ensureAttrs() {
+        if (!this.attrs) {
+            throw new Error('attrs have not loaded.');
+        }
+        return this.attrs;
+    }
     updateSchema(schema) {
         this.config = Object.assign(Object.assign({}, this.config), { schema: schema, cardinalityInference: Boolean(schema) });
         this._linkIndex = schema ? createLinkIndex(this.config.schema) : null;
@@ -484,7 +505,7 @@ export default class Reactor {
             serialize: querySubToStorage,
             parse: (_key, x) => querySubFromStorage(x, this.config.useDateObjects),
             // objectSize
-            objectSize: (x) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = x.result) === null || _a === void 0 ? void 0 : _a.store) === null || _b === void 0 ? void 0 : _b.triples) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0; },
+            objectSize: (x) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = x === null || x === void 0 ? void 0 : x.result) === null || _a === void 0 ? void 0 : _a.store) === null || _b === void 0 ? void 0 : _b.triples) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0; },
             logger: this._log,
             preloadEntryCount: 10,
             gc: {
@@ -580,35 +601,6 @@ 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 store = s.createStore(this.attrs, result.triples, enableCardinalityInference, this._linkIndex, this.config.useDateObjects);
-        this.querySubs.updateInPlace((prev) => {
-            prev[queryHash] = {
-                result: {
-                    store,
-                    pageInfo: result.pageInfo,
-                    processedTxId: undefined,
-                    isExternal: true,
-                },
-                q,
-            };
-        });
-        this._cleanupPendingMutationsQueries();
-        this.notifyOne(queryHash);
-        this.notifyOneQueryOnce(queryHash);
-        this._cleanupPendingMutationsTimeout();
-    }
     _handleReceive(connId, msg) {
         var _a, _b, _c, _d, _e, _f;
         // opt-out, enabled by default if schema
@@ -647,7 +639,8 @@ export default class Reactor {
                 const pageInfo = (_d = (_c = result === null || result === void 0 ? void 0 : result[0]) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d['page-info'];
                 const aggregate = (_f = (_e = result === null || result === void 0 ? void 0 : result[0]) === null || _e === void 0 ? void 0 : _e.data) === null || _f === void 0 ? void 0 : _f['aggregate'];
                 const triples = extractTriples(result);
-                const store = s.createStore(this.attrs, triples, enableCardinalityInference, this._linkIndex, this.config.useDateObjects);
+                const attrsStore = this.ensureAttrs();
+                const store = s.createStore(attrsStore, triples, enableCardinalityInference, this.config.useDateObjects);
                 this.querySubs.updateInPlace((prev) => {
                     if (!prev[hash]) {
                         this._log.info('Missing value in querySubs', { hash, q });
@@ -655,6 +648,7 @@ export default class Reactor {
                     }
                     prev[hash].result = {
                         store,
+                        attrsStore,
                         pageInfo,
                         aggregate,
                         processedTxId: msg['processed-tx-id'],
@@ -689,7 +683,7 @@ export default class Reactor {
                     this._setAttrs(attrs);
                 }
                 this._cleanupPendingMutationsTimeout();
-                const rewrittenMutations = this._rewriteMutations(this.attrs, this._pendingMutations(), processedTxId);
+                const rewrittenMutations = this._rewriteMutations(this.ensureAttrs(), this._pendingMutations(), processedTxId);
                 if (rewrittenMutations !== this._pendingMutations()) {
                     // We know we've changed the mutations to fix the attr ids and removed
                     // processed attrs, so we'll persist those changes to prevent optimisticAttrs
@@ -705,19 +699,33 @@ export default class Reactor {
                     const result = x['instaql-result'];
                     const hash = weakHash(q);
                     const triples = extractTriples(result);
-                    const store = s.createStore(this.attrs, triples, enableCardinalityInference, this._linkIndex, this.config.useDateObjects);
-                    const newStore = this._applyOptimisticUpdates(store, mutations, processedTxId);
+                    const attrsStore = this.ensureAttrs();
+                    const store = s.createStore(attrsStore, triples, enableCardinalityInference, this.config.useDateObjects);
+                    const { store: newStore, attrsStore: newAttrsStore } = this._applyOptimisticUpdates(store, attrsStore, mutations, processedTxId);
                     const pageInfo = (_b = (_a = result === null || result === void 0 ? void 0 : result[0]) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b['page-info'];
                     const aggregate = (_d = (_c = result === null || result === void 0 ? void 0 : result[0]) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d['aggregate'];
-                    return { q, hash, store: newStore, pageInfo, aggregate };
+                    return {
+                        q,
+                        hash,
+                        store: newStore,
+                        attrsStore: newAttrsStore,
+                        pageInfo,
+                        aggregate,
+                    };
                 });
-                updates.forEach(({ hash, q, store, pageInfo, aggregate }) => {
+                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, pageInfo, aggregate, processedTxId };
+                        prev[hash].result = {
+                            store,
+                            attrsStore,
+                            pageInfo,
+                            aggregate,
+                            processedTxId,
+                        };
                     });
                 });
                 this._cleanupPendingMutationsQueries();
@@ -729,7 +737,7 @@ export default class Reactor {
             case 'transact-ok': {
                 const { 'client-event-id': eventId, 'tx-id': txId } = msg;
                 this._inFlightMutationEventIds.delete(eventId);
-                const muts = this._rewriteMutations(this.attrs, this._pendingMutations());
+                const muts = this._rewriteMutations(this.ensureAttrs(), this._pendingMutations());
                 const prevMutation = muts.get(eventId);
                 if (!prevMutation) {
                     break;
@@ -738,11 +746,17 @@ export default class Reactor {
                 this._updatePendingMutations((prev) => {
                     prev.set(eventId, Object.assign(Object.assign({}, prev.get(eventId)), { 'tx-id': txId, confirmed: Date.now() }));
                 });
-                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);
                 this._cleanupPendingMutationsTimeout();
                 break;
@@ -903,10 +917,10 @@ export default class Reactor {
         this._completeQueryOnce(q, hash, r.dfd);
     }
     _setAttrs(attrs) {
-        this.attrs = attrs.reduce((acc, attr) => {
+        this.attrs = new s.AttrsStoreClass(attrs.reduce((acc, attr) => {
             acc[attr.id] = attr;
             return acc;
-        }, {});
+        }, {}), this._linkIndex);
         this.notifyAttrsSubs();
     }
     _startQuerySub(q, hash) {
@@ -1012,6 +1026,12 @@ 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;
@@ -1019,12 +1039,12 @@ export default class Reactor {
             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() };
@@ -1087,8 +1107,11 @@ export default class Reactor {
     }
     // ---------------------------
     // Transact
+    /**
+     * @returns {s.AttrsStore}
+     */
     optimisticAttrs() {
-        var _a;
+        var _a, _b;
         const pendingMutationSteps = [...this._pendingMutations().values()] // hack due to Map()
             .flatMap((x) => x['tx-steps']);
         const deletedAttrIds = new Set(pendingMutationSteps
@@ -1101,20 +1124,25 @@ export default class Reactor {
             }
             else if (_action === 'update-attr' &&
                 attr.id &&
-                ((_a = this.attrs) === null || _a === void 0 ? void 0 : _a[attr.id])) {
-                const fullAttr = Object.assign(Object.assign({}, this.attrs[attr.id]), attr);
+                ((_a = this.attrs) === null || _a === void 0 ? void 0 : _a.getAttr(attr.id))) {
+                const fullAttr = Object.assign(Object.assign({}, this.attrs.getAttr(attr.id)), attr);
                 pendingAttrs.push(fullAttr);
             }
         }
-        const attrsWithoutDeleted = [
-            ...Object.values(this.attrs || {}),
-            ...pendingAttrs,
-        ].filter((a) => !deletedAttrIds.has(a.id));
-        const attrsRecord = Object.fromEntries(attrsWithoutDeleted.map((a) => [a.id, a]));
-        return attrsRecord;
+        if (!deletedAttrIds.size && !pendingAttrs.length) {
+            return this.attrs || new s.AttrsStoreClass({}, this._linkIndex);
+        }
+        const attrs = Object.assign({}, (((_b = this.attrs) === null || _b === void 0 ? void 0 : _b.attrs) || {}));
+        for (const attr of pendingAttrs) {
+            attrs[attr.id] = attr;
+        }
+        for (const id of deletedAttrIds) {
+            delete attrs[id];
+        }
+        return new s.AttrsStoreClass(attrs, this._linkIndex);
     }
     /** Runs instaql on a query and a store */
-    dataForQuery(hash, applyOptimistic = true) {
+    dataForQuery(hash) {
         const errorMessage = this._errorMessage;
         if (errorMessage) {
             return { error: errorMessage };
@@ -1136,22 +1164,21 @@ export default class Reactor {
             pendingMutationsVersion === cached.pendingMutationsVersion) {
             return cached;
         }
-        let store = result.store;
-        const { pageInfo, aggregate, processedTxId } = result;
-        const mutations = this._rewriteMutationsSorted(store.attrs, pendingMutations);
-        if (applyOptimistic) {
-            store = this._applyOptimisticUpdates(store, mutations, processedTxId);
-        }
-        const resp = instaql({ store: store, pageInfo, aggregate }, q);
+        const { store, attrsStore, pageInfo, aggregate, processedTxId } = result;
+        const mutations = this._rewriteMutationsSorted(attrsStore, pendingMutations);
+        const { store: newStore, attrsStore: newAttrsStore } = this._applyOptimisticUpdates(store, attrsStore, mutations, processedTxId);
+        const resp = instaql({ store: newStore, attrsStore: newAttrsStore, 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-compute all subscriptions */
     notifyAll() {
@@ -1231,7 +1258,7 @@ export default class Reactor {
             .forEach(({ eventId, q }) => {
             this._trySendAuthed(eventId, { op: 'add-query', q });
         });
-        const muts = this._rewriteMutationsSorted(this.attrs, this._pendingMutations());
+        const muts = this._rewriteMutationsSorted(this.ensureAttrs(), this._pendingMutations());
         muts.forEach(([eventId, mut]) => {
             if (!mut['tx-id']) {
                 this._sendMutation(eventId, mut);
@@ -1518,7 +1545,7 @@ export default class Reactor {
     subscribeAttrs(cb) {
         this.attrsCbs.push(cb);
         if (this.attrs) {
-            cb(this.attrs);
+            cb(this.attrs.attrs);
         }
         return () => {
             this.attrsCbs = this.attrsCbs.filter((x) => x !== cb);
@@ -1534,7 +1561,7 @@ export default class Reactor {
         if (!this.attrs)
             return;
         const oas = this.optimisticAttrs();
-        this.attrsCbs.forEach((cb) => cb(oas));
+        this.attrsCbs.forEach((cb) => cb(oas.attrs));
     }
     notifyConnectionStatusSubs(status) {
         this.connectionStatusCbs.forEach((cb) => cb(status));
@@ -1606,28 +1633,7 @@ export default class Reactor {
             }
         });
     }
-    syncUserToEndpoint(user) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 = Object.assign({ isLoading: false }, newV);
         this._dataForQueryCache = {};