@instantdb/core 0.22.57 → 0.22.58

package/dist/commonjs/Reactor.js

@@ -139,30 +139,46 @@ const ignoreLogging = {
     'refresh-presence': true,
     'patch-presence': true,
 };
-function querySubsFromStorage(x, useDateObjects) {
+function querySubFromStorage(x, useDateObjects) {
     var _a;
-    const parsed = typeof x === 'string' ? JSON.parse(x) : x;
-    for (const key in parsed) {
-        const v = parsed[key];
-        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 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 }));
     }
-    return parsed;
+    return v;
 }
-function querySubsToStorage(querySubs) {
+function querySubToStorage(_key, sub) {
     var _a;
-    const jsonSubs = {};
-    for (const key in querySubs) {
-        const sub = querySubs[key];
-        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) });
-        }
-        jsonSubs[key] = jsonSub;
+    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) });
+    }
+    return jsonSub;
+}
+function kvFromStorage(key, x) {
+    switch (key) {
+        case 'pendingMutations':
+            return new Map(typeof x === 'string' ? JSON.parse(x) : x);
+        default:
+            return x;
     }
-    return jsonSubs;
+}
+function kvToStorage(key, x) {
+    switch (key) {
+        case 'pendingMutations':
+            return [...x.entries()];
+        default:
+            return x;
+    }
+}
+function onMergeQuerySub(_k, storageSub, inMemorySub) {
+    const storageResult = storageSub === null || storageSub === void 0 ? void 0 : storageSub.result;
+    const memoryResult = inMemorySub === null || inMemorySub === void 0 ? void 0 : inMemorySub.result;
+    if (storageResult && !memoryResult && inMemorySub) {
+        inMemorySub.result = storageResult;
+    }
+    return inMemorySub || storageSub;
 }
 function sortedMutationEntries(entries) {
     return [...entries].sort((a, b) => {
@@ -217,65 +233,27 @@ class Reactor {
         this._beforeUnloadCbs = [];
         this._dataForQueryCache = {};
         this._inFlightMutationEventIds = new Set();
-        /**
-         *  merge querySubs from storage and in memory. Has the following side
-         *  effects:
-         *  - We notify all queryCbs because results may been added during merge
-         */
-        this._onMergeQuerySubs = (_storageSubs, inMemorySubs) => {
-            const storageSubs = _storageSubs || {};
-            const ret = Object.assign({}, inMemorySubs);
-            // Consider an inMemorySub with no result;
-            // If we have a result from storageSubs, let's add it
-            Object.entries(inMemorySubs).forEach(([hash, querySub]) => {
-                var _a;
-                const storageResult = (_a = storageSubs === null || storageSubs === void 0 ? void 0 : storageSubs[hash]) === null || _a === void 0 ? void 0 : _a.result;
-                const memoryResult = querySub.result;
-                if (storageResult && !memoryResult) {
-                    ret[hash].result = storageResult;
-                }
-            });
-            // Consider a storageSub with no corresponding inMemorySub
-            // This means that at least at this point,
-            // the user has not asked to subscribe to the query.
-            // We may _still_ want to add it, because in just a
-            // few milliseconds, the user will ask to subscribe to the
-            // query.
-            // For now, we can't really tell if the user will ask to subscribe
-            // or not. So for now let's just add the first 10 queries from storage.
-            // Eventually, we could be smarter about this. For example,
-            // we can keep usage information about which queries are popular.
-            const storageKsToAdd = Object.keys(storageSubs)
-                .filter((k) => !inMemorySubs[k])
-                .sort((a, b) => {
-                var _a, _b;
-                // Sort by lastAccessed, newest first
-                const aTime = ((_a = storageSubs[a]) === null || _a === void 0 ? void 0 : _a.lastAccessed) || 0;
-                const bTime = ((_b = storageSubs[b]) === null || _b === void 0 ? void 0 : _b.lastAccessed) || 0;
-                return bTime - aTime;
-            })
-                .slice(0, this.queryCacheLimit);
-            storageKsToAdd.forEach((k) => {
-                ret[k] = storageSubs[k];
-            });
-            // Okay, now we have merged our querySubs
-            this.querySubs.set((_) => ret);
-            this.loadedNotifyAll();
-        };
-        /**
-         * merge pendingMutations from storage and in memory. Has a side effect of
-         * sending mutations that were stored but not acked
-         */
-        this._onMergePendingMutations = (storageMuts, inMemoryMuts) => {
-            const ret = new Map([...storageMuts.entries(), ...inMemoryMuts.entries()]);
-            this.pendingMutations.set((_) => ret);
-            this.loadedNotifyAll();
-            const rewrittenStorageMuts = this._rewriteMutationsSorted(this.attrs, storageMuts);
-            rewrittenStorageMuts.forEach(([k, mut]) => {
-                if (!inMemoryMuts.has(k) && !mut['tx-id']) {
-                    this._sendMutation(k, mut);
+        this._onMergeKv = (key, storageV, inMemoryV) => {
+            var _a, _b;
+            switch (key) {
+                case 'pendingMutations': {
+                    const storageEntries = (_a = storageV === null || storageV === void 0 ? void 0 : storageV.entries()) !== null && _a !== void 0 ? _a : [];
+                    const inMemoryEntries = (_b = inMemoryV === null || inMemoryV === void 0 ? void 0 : inMemoryV.entries()) !== null && _b !== void 0 ? _b : [];
+                    const muts = new Map([...storageEntries, ...inMemoryEntries]);
+                    const rewrittenStorageMuts = storageV
+                        ? this._rewriteMutationsSorted(this.attrs, storageV)
+                        : [];
+                    rewrittenStorageMuts.forEach(([k, mut]) => {
+                        var _a;
+                        if (!((_a = inMemoryV === null || inMemoryV === void 0 ? void 0 : inMemoryV.pendingMutations) === null || _a === void 0 ? void 0 : _a.has(k)) && !mut['tx-id']) {
+                            this._sendMutation(k, mut);
+                        }
+                    });
+                    return muts;
                 }
-            });
+                default:
+                    return inMemoryV || storageV;
+            }
         };
         // ---------------------------
         // Queries
@@ -334,7 +312,7 @@ class Reactor {
          */
         this.pushOps = (txSteps, error) => {
             const eventId = (0, uuid_ts_1.default)();
-            const mutations = [...this.pendingMutations.currentValue.values()];
+            const mutations = [...this._pendingMutations().values()];
             const order = Math.max(0, ...mutations.map((mut) => mut.order || 0)) + 1;
             const mutation = {
                 op: 'transact',
@@ -343,9 +321,8 @@ class Reactor {
                 error,
                 order,
             };
-            this.pendingMutations.set((prev) => {
+            this._updatePendingMutations((prev) => {
                 prev.set(eventId, mutation);
-                return prev;
             });
             const dfd = new Deferred_js_1.Deferred();
             this.mutationDeferredStore.set(eventId, dfd);
@@ -474,7 +451,7 @@ class Reactor {
             }));
         }
         this._initStorage(Storage);
-        this._syncTable = new SyncTable_ts_1.SyncTable(this._trySendAuthed.bind(this), this._persister, {
+        this._syncTable = new SyncTable_ts_1.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._oauthCallbackResponse = this._oauthLoginInit();
@@ -513,21 +490,55 @@ class Reactor {
     _reactorStats() {
         return {
             inFlightMutationCount: this._inFlightMutationEventIds.size,
-            pendingMutationCount: this.pendingMutations.currentValue.size,
+            pendingMutationCount: this._pendingMutations().size,
             transportType: this._transportType,
         };
     }
+    _onQuerySubLoaded(hash) {
+        this.kv
+            .waitForKeyToLoad('pendingMutations')
+            .then(() => this.notifyOne(hash));
+    }
     _initStorage(Storage) {
-        this._persister = new Storage(`instant_${this.config.appId}_5`);
-        this.querySubs = new PersistedObject_ts_1.PersistedObject(this._persister, 'querySubs', {}, this._onMergeQuerySubs, querySubsToStorage, (x) => querySubsFromStorage(x, this.config.useDateObjects));
-        this.pendingMutations = new PersistedObject_ts_1.PersistedObject(this._persister, 'pendingMutations', new Map(), this._onMergePendingMutations, (x) => {
-            return [...x.entries()];
-        }, (x) => {
-            return new Map(typeof x === 'string' ? JSON.parse(x) : x);
-        }, 100, // throttle
-        100);
+        this.querySubs = new PersistedObject_ts_1.PersistedObject({
+            persister: new Storage(this.config.appId, 'querySubs'),
+            merge: onMergeQuerySub,
+            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; },
+            logger: this._log,
+            preloadEntryCount: 10,
+            gc: {
+                maxAgeMs: 1000 * 60 * 60 * 24 * 7 * 52, // 1 year
+                maxEntries: 1000,
+                // Size of each query is the number of triples
+                maxSize: 1000000, // 1 million triples
+            },
+        });
+        this.querySubs.onKeyLoaded = (k) => this._onQuerySubLoaded(k);
+        this.kv = new PersistedObject_ts_1.PersistedObject({
+            persister: new Storage(this.config.appId, 'kv'),
+            merge: this._onMergeKv,
+            serialize: kvToStorage,
+            parse: kvFromStorage,
+            objectSize: () => 0,
+            logger: this._log,
+            saveThrottleMs: 100,
+            idleCallbackMaxWaitMs: 100,
+            // Don't GC the kv store
+            gc: null,
+        });
+        this.kv.onKeyLoaded = (k) => {
+            if (k === 'pendingMutations') {
+                this.notifyAll();
+            }
+        };
+        // Trigger immediate load for pendingMutations and currentUser
+        this.kv.waitForKeyToLoad('pendingMutations');
+        this.kv.waitForKeyToLoad(currentUserKey);
         this._beforeUnloadCbs.push(() => {
-            this.pendingMutations.flush();
+            this.kv.flush();
             this.querySubs.flush();
         });
     }
@@ -623,18 +634,24 @@ class Reactor {
             case 'add-query-ok': {
                 const { q, result } = msg;
                 const hash = (0, weakHash_ts_1.default)(q);
+                if (!this._hasQueryListeners() && !this.querySubs.currentValue[hash]) {
+                    break;
+                }
                 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 = (0, instaqlResult_js_1.extractTriples)(result);
                 const store = s.createStore(this.attrs, triples, enableCardinalityInference, this._linkIndex, this.config.useDateObjects);
-                this.querySubs.set((prev) => {
+                this.querySubs.updateInPlace((prev) => {
+                    if (!prev[hash]) {
+                        this._log.info('Missing value in querySubs', { hash, q });
+                        return;
+                    }
                     prev[hash].result = {
                         store,
                         pageInfo,
                         aggregate,
                         processedTxId: msg['processed-tx-id'],
                     };
-                    return prev;
                 });
                 this._cleanupPendingMutationsQueries();
                 this.notifyOne(hash);
@@ -665,12 +682,14 @@ class Reactor {
                     this._setAttrs(attrs);
                 }
                 this._cleanupPendingMutationsTimeout();
-                const rewrittenMutations = this._rewriteMutations(this.attrs, this.pendingMutations.currentValue, processedTxId);
-                if (rewrittenMutations !== this.pendingMutations.currentValue) {
+                const rewrittenMutations = this._rewriteMutations(this.attrs, 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
                     // from using old attr definitions
-                    this.pendingMutations.set(() => rewrittenMutations);
+                    this.kv.updateInPlace((prev) => {
+                        prev.pendingMutations = rewrittenMutations;
+                    });
                 }
                 const mutations = sortedMutationEntries(rewrittenMutations.entries());
                 const updates = computations.map((x) => {
@@ -683,12 +702,15 @@ class Reactor {
                     const newStore = this._applyOptimisticUpdates(store, 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 { hash, store: newStore, pageInfo, aggregate };
+                    return { q, hash, store: newStore, pageInfo, aggregate };
                 });
-                updates.forEach(({ hash, store, pageInfo, aggregate }) => {
-                    this.querySubs.set((prev) => {
+                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 };
-                        return prev;
                     });
                 });
                 this._cleanupPendingMutationsQueries();
@@ -700,15 +722,14 @@ 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.currentValue);
+                const muts = this._rewriteMutations(this.attrs, this._pendingMutations());
                 const prevMutation = muts.get(eventId);
                 if (!prevMutation) {
                     break;
                 }
                 // update pendingMutation with server-side tx-id
-                this.pendingMutations.set((prev) => {
+                this._updatePendingMutations((prev) => {
                     prev.set(eventId, Object.assign(Object.assign({}, prev.get(eventId)), { 'tx-id': txId, confirmed: Date.now() }));
-                    return prev;
                 });
                 const newAttrs = prevMutation['tx-steps']
                     .filter(([action, ..._args]) => action === 'add-attr')
@@ -775,15 +796,27 @@ class Reactor {
                 break;
         }
     }
+    _pendingMutations() {
+        var _a;
+        return (_a = this.kv.currentValue.pendingMutations) !== null && _a !== void 0 ? _a : new Map();
+    }
+    _updatePendingMutations(f) {
+        this.kv.updateInPlace((prev) => {
+            var _a;
+            const muts = (_a = prev.pendingMutations) !== null && _a !== void 0 ? _a : new Map();
+            prev.pendingMutations = muts;
+            f(muts);
+        });
+    }
     /**
      * @param {'timeout' | 'error'} status
      * @param {string} eventId
      * @param {{message: string, type?: string, status?: number, hint?: unknown}} errorMsg
      */
     _handleMutationError(status, eventId, errorMsg) {
-        const mut = this.pendingMutations.currentValue.get(eventId);
+        const mut = this._pendingMutations().get(eventId);
         if (mut && (status !== 'timeout' || !mut['tx-id'])) {
-            this.pendingMutations.set((prev) => {
+            this._updatePendingMutations((prev) => {
                 prev.delete(eventId);
                 return prev;
             });
@@ -804,7 +837,7 @@ class Reactor {
         const eventId = msg['client-event-id'];
         // This might not be a mutation, but it can't hurt to delete it
         this._inFlightMutationEventIds.delete(eventId);
-        const prevMutation = this.pendingMutations.currentValue.get(eventId);
+        const prevMutation = this._pendingMutations().get(eventId);
         const errorMessage = {
             message: msg.message || 'Uh-oh, something went wrong. Ping Joe & Stopa.',
         };
@@ -871,10 +904,9 @@ class Reactor {
     }
     _startQuerySub(q, hash) {
         const eventId = (0, uuid_ts_1.default)();
-        this.querySubs.set((prev) => {
+        this.querySubs.updateInPlace((prev) => {
             prev[hash] = prev[hash] || { q, result: null, eventId };
             prev[hash].lastAccessed = Date.now();
-            return prev;
         });
         this._trySendAuthed(eventId, { op: 'add-query', q });
         return eventId;
@@ -948,13 +980,18 @@ class Reactor {
         this.queryCbs[hash] = this.queryCbs[hash].filter((r) => r.cb !== cb);
         this._cleanupQuery(q, hash);
     }
-    _cleanupQuery(q, hash) {
+    _hasQueryListeners(hash) {
         var _a, _b;
-        const hasListeners = ((_a = this.queryCbs[hash]) === null || _a === void 0 ? void 0 : _a.length) || ((_b = this.queryOnceDfds[hash]) === null || _b === void 0 ? void 0 : _b.length);
+        return !!(((_a = this.queryCbs[hash]) === null || _a === void 0 ? void 0 : _a.length) || ((_b = this.queryOnceDfds[hash]) === null || _b === void 0 ? void 0 : _b.length));
+    }
+    _cleanupQuery(q, hash) {
+        const hasListeners = this._hasQueryListeners(hash);
         if (hasListeners)
             return;
         delete this.queryCbs[hash];
         delete this.queryOnceDfds[hash];
+        delete this._dataForQueryCache[hash];
+        this.querySubs.unloadKey(hash);
         this._trySendAuthed((0, uuid_ts_1.default)(), { op: 'remove-query', q });
     }
     // When we `pushTx`, it's possible that we don't yet have `this.attrs`
@@ -971,6 +1008,8 @@ class Reactor {
     _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);
@@ -1043,9 +1082,7 @@ class Reactor {
     // Transact
     optimisticAttrs() {
         var _a;
-        const pendingMutationSteps = [
-            ...this.pendingMutations.currentValue.values(),
-        ] // hack due to Map()
+        const pendingMutationSteps = [...this._pendingMutations().values()] // hack due to Map()
             .flatMap((x) => x['tx-steps']);
         const deletedAttrIds = new Set(pendingMutationSteps
             .filter(([action, _attr]) => action === 'delete-attr')
@@ -1077,12 +1114,12 @@ class Reactor {
         }
         if (!this.querySubs)
             return;
-        if (!this.pendingMutations)
+        if (!this.kv.currentValue.pendingMutations)
             return;
         const querySubVersion = this.querySubs.version();
         const querySubs = this.querySubs.currentValue;
-        const pendingMutationsVersion = this.pendingMutations.version();
-        const pendingMutations = this.pendingMutations.currentValue;
+        const pendingMutationsVersion = this.kv.version();
+        const pendingMutations = this._pendingMutations();
         const { q, result } = querySubs[hash] || {};
         if (!result)
             return;
@@ -1114,13 +1151,17 @@ class Reactor {
     /** Re-compute all subscriptions */
     notifyAll() {
         Object.keys(this.queryCbs).forEach((hash) => {
-            this.notifyOne(hash);
+            this.querySubs
+                .waitForKeyToLoad(hash)
+                .then(() => this.notifyOne(hash))
+                .catch(() => this.notifyOne(hash));
         });
     }
     loadedNotifyAll() {
-        if (this.pendingMutations.isLoading() || this.querySubs.isLoading())
-            return;
-        this.notifyAll();
+        this.kv
+            .waitForKeyToLoad('pendingMutations')
+            .then(() => this.notifyAll())
+            .catch(() => this.notifyAll());
     }
     shutdown() {
         var _a;
@@ -1148,7 +1189,7 @@ class Reactor {
         }
         const timeoutMs = Math.max(6000, Math.min(this._inFlightMutationEventIds.size + 1, 
         // Defensive code in case we don't clean up in flight mutation event ids
-        this.pendingMutations.currentValue.size + 1) * 6000);
+        this._pendingMutations().size + 1) * 6000);
         if (!this._isOnline) {
             this._finishTransaction('enqueued', eventId);
         }
@@ -1185,7 +1226,7 @@ class Reactor {
             .forEach(({ eventId, q }) => {
             this._trySendAuthed(eventId, { op: 'add-query', q });
         });
-        const muts = this._rewriteMutationsSorted(this.attrs, this.pendingMutations.currentValue);
+        const muts = this._rewriteMutationsSorted(this.attrs, this._pendingMutations());
         muts.forEach(([eventId, mut]) => {
             if (!mut['tx-id']) {
                 this._sendMutation(eventId, mut);
@@ -1203,13 +1244,12 @@ class Reactor {
                 minProcessedTxId = Math.min(minProcessedTxId, result === null || result === void 0 ? void 0 : result.processedTxId);
             }
         }
-        this.pendingMutations.set((prev) => {
+        this._updatePendingMutations((prev) => {
             for (const [eventId, mut] of Array.from(prev.entries())) {
                 if (mut['tx-id'] && mut['tx-id'] <= minProcessedTxId) {
                     prev.delete(eventId);
                 }
             }
-            return prev;
         });
     }
     /**
@@ -1218,19 +1258,17 @@ class Reactor {
      * unaffected by this mutation and it’s safe to delete it from local queue
      */
     _cleanupPendingMutationsTimeout() {
-        if (this.pendingMutations.currentValue.size <
-            this._pendingMutationCleanupThreshold) {
+        if (this._pendingMutations().size < this._pendingMutationCleanupThreshold) {
             return;
         }
         const now = Date.now();
-        this.pendingMutations.set((prev) => {
+        this._updatePendingMutations((prev) => {
             for (const [eventId, mut] of Array.from(prev.entries())) {
                 if (mut.confirmed &&
                     mut.confirmed + this._pendingTxCleanupTimeout < now) {
                     prev.delete(eventId);
                 }
             }
-            return prev;
         });
     }
     _trySendAuthed(...args) {
@@ -1306,23 +1344,24 @@ class Reactor {
      *
      * Note: If the user deletes their local storage, this id will change.
      *
-     * We use this._localIdPromises to ensure that we only generate a local
-     * id once, even if multiple callers call this function concurrently.
      */
     getLocalId(name) {
         return __awaiter(this, void 0, void 0, function* () {
             const k = `localToken_${name}`;
-            const id = yield this._persister.getItem(k);
-            if (id)
-                return id;
-            if (this._localIdPromises[k]) {
-                return this._localIdPromises[k];
+            if (this.kv.currentValue[k]) {
+                return this.kv.currentValue[k];
+            }
+            const current = yield this.kv.waitForKeyToLoad(k);
+            if (current) {
+                return current;
             }
             const newId = (0, uuid_ts_1.default)();
-            this._localIdPromises[k] = this._persister
-                .setItem(k, newId)
-                .then(() => newId);
-            return this._localIdPromises[k];
+            this.kv.updateInPlace((prev) => {
+                if (prev[k])
+                    return;
+                prev[k] = newId;
+            });
+            return yield this.kv.waitForKeyToLoad(k);
         });
     }
     // ----
@@ -1497,7 +1536,10 @@ class Reactor {
     }
     setCurrentUser(user) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this._persister.setItem(currentUserKey, user);
+            this.kv.updateInPlace((prev) => {
+                prev[currentUserKey] = user;
+            });
+            yield this.kv.waitForKeyToLoad(currentUserKey);
         });
     }
     getCurrentUserCached() {
@@ -1505,7 +1547,7 @@ class Reactor {
     }
     _getCurrentUser() {
         return __awaiter(this, void 0, void 0, function* () {
-            const user = yield this._persister.getItem(currentUserKey);
+            const user = yield this.kv.waitForKeyToLoad(currentUserKey);
             return typeof user === 'string' ? JSON.parse(user) : user;
         });
     }
@@ -1517,16 +1559,25 @@ class Reactor {
                 this._currentUserCached = Object.assign({ isLoading: false }, errorV);
                 return errorV;
             }
-            const user = yield this._getCurrentUser();
-            const userV = { user: user, error: undefined };
-            this._currentUserCached = Object.assign({ isLoading: false }, userV);
-            return userV;
+            try {
+                const user = yield this._getCurrentUser();
+                const userV = { user: user, error: undefined };
+                this._currentUserCached = Object.assign({ isLoading: false }, userV);
+                return userV;
+            }
+            catch (e) {
+                return {
+                    user: undefined,
+                    isLoading: false,
+                    error: { message: (e === null || e === void 0 ? void 0 : e.message) || 'Error loading user' },
+                };
+            }
         });
     }
     _hasCurrentUser() {
         return __awaiter(this, void 0, void 0, function* () {
-            const user = yield this._persister.getItem(currentUserKey);
-            return JSON.parse(user) != null;
+            const user = yield this.kv.waitForKeyToLoad(currentUserKey);
+            return typeof user === 'string' ? JSON.parse(user) != null : user != null;
         });
     }
     changeCurrentUser(newUser) {
@@ -1554,11 +1605,10 @@ class Reactor {
         const newV = { error: undefined, user: newUser };
         this._currentUserCached = Object.assign({ isLoading: false }, newV);
         this._dataForQueryCache = {};
-        this.querySubs.set((prev) => {
+        this.querySubs.updateInPlace((prev) => {
             Object.keys(prev).forEach((k) => {
                 delete prev[k].result;
             });
-            return prev;
         });
         this._reconnectTimeoutMs = 0;
         this._transport.close();