@instantdb/core 0.22.96-experimental.drewh-ts-target.20761590091.1 → 0.22.97-experimental.bump-next-cia.20761479934.1

package/dist/esm/utils/PersistedObject.js

@@ -12,6 +12,15 @@
 // Each PersistedObject provides it's own `onMerge`
 // function to handle the merge of data from storage and memory
 // on load
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 // Uses `requestIdleCallback` if available, otherwise calls the
 // callback immediately
 import { create } from 'mutative';
@@ -28,40 +37,29 @@ export class StorageInterface {
     constructor(appId, storeName) { }
 }
 export class PersistedObject {
-    currentValue;
-    _subs = [];
-    _persister;
-    _merge;
-    serialize;
-    parse;
-    _saveThrottleMs;
-    _idleCallbackMaxWaitMs;
-    _nextSave = null;
-    _nextGc = null;
-    _pendingSaveKeys = new Set();
-    _loadedKeys = new Set();
-    _loadingKeys;
-    _objectSize;
-    _log;
-    onKeyLoaded;
-    _version = 0;
-    _meta = {
-        isLoading: true,
-        onLoadCbs: [],
-        value: null,
-        error: null,
-        attempts: 0,
-    };
-    _gcOpts;
     constructor(opts) {
+        var _a, _b;
+        this._subs = [];
+        this._nextSave = null;
+        this._nextGc = null;
+        this._pendingSaveKeys = new Set();
+        this._loadedKeys = new Set();
+        this._version = 0;
+        this._meta = {
+            isLoading: true,
+            onLoadCbs: [],
+            value: null,
+            error: null,
+            attempts: 0,
+        };
         this._persister = opts.persister;
         this._merge = opts.merge;
         this.serialize = opts.serialize;
         this.parse = opts.parse;
         this._objectSize = opts.objectSize;
         this._log = opts.logger;
-        this._saveThrottleMs = opts.saveThrottleMs ?? 100;
-        this._idleCallbackMaxWaitMs = opts.idleCallbackMaxWaitMs ?? 1000;
+        this._saveThrottleMs = (_a = opts.saveThrottleMs) !== null && _a !== void 0 ? _a : 100;
+        this._idleCallbackMaxWaitMs = (_b = opts.idleCallbackMaxWaitMs) !== null && _b !== void 0 ? _b : 1000;
         this._gcOpts = opts.gc;
         this.currentValue = {};
         this._loadedKeys = new Set();
@@ -71,85 +69,97 @@ export class PersistedObject {
             this._preloadEntries(opts.preloadEntryCount);
         }
     }
-    async _initMeta() {
-        if (this._meta.loadingPromise) {
-            await this._meta.loadingPromise;
-        }
-        try {
-            const p = this._persister.getItem(META_KEY);
-            this._meta.loadingPromise = p;
-            const v = await p;
-            this._meta.isLoading = false;
-            this._meta.error = null;
-            this._meta.loadingPromise = null;
-            this._meta.attempts = 0;
-            const existingObjects = this._meta.value?.objects ?? {};
-            const value = v ?? {};
-            const objects = value.objects ?? {};
-            // Merge the values from storage with in-memory values
-            this._meta.value = {
-                ...value,
-                objects: { ...existingObjects, ...objects },
-            };
-        }
-        catch (e) {
-            this._meta.error = e;
-            this._meta.attempts++;
-            this._meta.loadingPromise = null;
-        }
+    _initMeta() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (this._meta.loadingPromise) {
+                yield this._meta.loadingPromise;
+            }
+            try {
+                const p = this._persister.getItem(META_KEY);
+                this._meta.loadingPromise = p;
+                const v = yield p;
+                this._meta.isLoading = false;
+                this._meta.error = null;
+                this._meta.loadingPromise = null;
+                this._meta.attempts = 0;
+                const existingObjects = (_b = (_a = this._meta.value) === null || _a === void 0 ? void 0 : _a.objects) !== null && _b !== void 0 ? _b : {};
+                const value = v !== null && v !== void 0 ? v : {};
+                const objects = (_c = value.objects) !== null && _c !== void 0 ? _c : {};
+                // Merge the values from storage with in-memory values
+                this._meta.value = Object.assign(Object.assign({}, value), { objects: Object.assign(Object.assign({}, existingObjects), objects) });
+            }
+            catch (e) {
+                this._meta.error = e;
+                this._meta.attempts++;
+                this._meta.loadingPromise = null;
+            }
+        });
     }
-    async _getMeta() {
-        if (this._meta.value) {
-            return this._meta.value;
-        }
-        if (this._meta.loadingPromise) {
-            await this._meta.loadingPromise;
+    _getMeta() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._meta.value) {
+                return this._meta.value;
+            }
+            if (this._meta.loadingPromise) {
+                yield this._meta.loadingPromise;
+                return this._meta.value;
+            }
+            this._initMeta();
+            yield this._meta.loadingPromise;
             return this._meta.value;
-        }
-        this._initMeta();
-        await this._meta.loadingPromise;
-        return this._meta.value;
+        });
     }
-    async _refreshMeta() {
-        await this._initMeta();
-        return this._meta.value;
+    _refreshMeta() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._initMeta();
+            return this._meta.value;
+        });
     }
-    async _preloadEntries(n) {
-        const meta = await this.waitForMetaToLoad();
-        if (!meta)
-            return;
-        const entries = Object.entries(meta.objects);
-        entries.sort(([_k_a, a_meta], [_k_b, b_meta]) => {
-            return b_meta.updatedAt - a_meta.updatedAt;
+    _preloadEntries(n) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const meta = yield this.waitForMetaToLoad();
+            if (!meta)
+                return;
+            const entries = Object.entries(meta.objects);
+            entries.sort(([_k_a, a_meta], [_k_b, b_meta]) => {
+                return b_meta.updatedAt - a_meta.updatedAt;
+            });
+            for (const [k] of entries.slice(0, n)) {
+                this._loadKey(k);
+            }
         });
-        for (const [k] of entries.slice(0, n)) {
-            this._loadKey(k);
-        }
     }
-    async _getFromStorage(key) {
-        try {
-            const data = await this._persister.getItem(key);
-            if (!data) {
-                return data;
+    _getFromStorage(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield this._persister.getItem(key);
+                if (!data) {
+                    return data;
+                }
+                const parsed = this.parse(key, data);
+                return parsed;
             }
-            const parsed = this.parse(key, data);
-            return parsed;
-        }
-        catch (e) {
-            console.error(`Unable to read from storage for key=${key}`, e);
-            return null;
-        }
+            catch (e) {
+                console.error(`Unable to read from storage for key=${key}`, e);
+                return null;
+            }
+        });
     }
-    async waitForKeyToLoad(k) {
-        if (this._loadedKeys.has(k)) {
+    waitForKeyToLoad(k) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._loadedKeys.has(k)) {
+                return this.currentValue[k];
+            }
+            yield (this._loadingKeys[k] || this._loadKey(k));
             return this.currentValue[k];
-        }
-        await (this._loadingKeys[k] || this._loadKey(k));
-        return this.currentValue[k];
+        });
     }
     // Used for tests
-    async waitForMetaToLoad() {
-        return this._getMeta();
+    waitForMetaToLoad() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._getMeta();
+        });
     }
     // Unloads the key so that it can be garbage collected, but does not
     // delete it. Removes the key from currentValue.
@@ -158,38 +168,41 @@ export class PersistedObject {
         delete this._loadingKeys[k];
         delete this.currentValue[k];
     }
-    async _loadKey(k) {
-        if (this._loadedKeys.has(k) || k in this._loadingKeys)
-            return;
-        const p = this._getFromStorage(k);
-        this._loadingKeys[k] = p;
-        const value = await p;
-        delete this._loadingKeys[k];
-        this._loadedKeys.add(k);
-        if (value) {
-            const merged = this._merge(k, value, this.currentValue[k]);
-            if (merged) {
-                this.currentValue[k] = merged;
+    _loadKey(k) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._loadedKeys.has(k) || k in this._loadingKeys)
+                return;
+            const p = this._getFromStorage(k);
+            this._loadingKeys[k] = p;
+            const value = yield p;
+            delete this._loadingKeys[k];
+            this._loadedKeys.add(k);
+            if (value) {
+                const merged = this._merge(k, value, this.currentValue[k]);
+                if (merged) {
+                    this.currentValue[k] = merged;
+                }
             }
-        }
-        this.onKeyLoaded && this.onKeyLoaded(k);
+            this.onKeyLoaded && this.onKeyLoaded(k);
+        });
     }
     // Returns a promise with a number so that we can wait for flush
     // to finish in the tests. The number is the number of operations
     // it performed, but it's mostly there so that typescript will warn
     // us if we forget to retun the promise from the function.
     _writeToStorage(opts) {
+        var _a, _b;
         const promises = [];
-        const skipGc = opts?.skipGc;
+        const skipGc = opts === null || opts === void 0 ? void 0 : opts.skipGc;
         if (this._meta.isLoading) {
             // Wait for meta to load and try again, give it a delay so that
             // we don't spend too much time retrying
             const p = new Promise((resolve, reject) => {
+                var _a;
                 setTimeout(() => this._enqueuePersist(opts
-                    ? { ...opts, attempts: (opts.attempts || 0) + 1 }
-                    : { attempts: 1 })
+                    ? Object.assign(Object.assign({}, opts), { attempts: (opts.attempts || 0) + 1 }) : { attempts: 1 })
                     .then(resolve)
-                    .catch(reject), 10 + (opts?.attempts ?? 0) * 1000);
+                    .catch(reject), 10 + ((_a = opts === null || opts === void 0 ? void 0 : opts.attempts) !== null && _a !== void 0 ? _a : 0) * 1000);
             });
             promises.push(p);
             return Promise.all(promises).then((vs) => vs.reduce((acc, x) => acc + x, 0));
@@ -220,14 +233,14 @@ export class PersistedObject {
         }
         const keysToLoad = [];
         const kvPairs = [[META_KEY, metaValue]];
-        const metaObjects = metaValue.objects ?? {};
+        const metaObjects = (_a = metaValue.objects) !== null && _a !== void 0 ? _a : {};
         metaValue.objects = metaObjects;
         for (const k of keysToUpdate) {
             if (this._loadedKeys.has(k)) {
                 const serializedV = this.serialize(k, this.currentValue[k]);
                 kvPairs.push([k, serializedV]);
                 const size = this._objectSize(serializedV);
-                const m = metaObjects[k] ?? {
+                const m = (_b = metaObjects[k]) !== null && _b !== void 0 ? _b : {
                     createdAt: Date.now(),
                     updatedAt: Date.now(),
                     size,
@@ -258,115 +271,119 @@ export class PersistedObject {
             return vs.reduce((acc, x) => acc + x, 0);
         });
     }
-    async flush() {
-        if (!this._nextSave) {
-            return;
-        }
-        clearTimeout(this._nextSave);
-        this._nextSave = null;
-        const p = this._writeToStorage();
-        return p;
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._nextSave) {
+                return;
+            }
+            clearTimeout(this._nextSave);
+            this._nextSave = null;
+            const p = this._writeToStorage();
+            return p;
+        });
     }
-    async _gc() {
-        if (!this._gcOpts) {
-            return;
-        }
-        const keys = new Set(await this._persister.getAllKeys());
-        keys.delete(META_KEY);
-        // Keys we can't delete
-        const sacredKeys = new Set(Object.keys(this.currentValue));
-        for (const k of Object.keys(this._loadingKeys)) {
-            sacredKeys.add(k);
-        }
-        for (const k of this._loadedKeys) {
-            sacredKeys.add(k);
-        }
-        // Refresh meta from the store so that we're less likely to
-        // clobber data from other tabs
-        const meta = await this._refreshMeta();
-        if (!meta) {
-            this._log.info('Could not gc because we were not able to load meta');
-            return;
-        }
-        const promises = [];
-        const deets = {
-            gcOpts: this._gcOpts,
-            keys,
-            sacredKeys,
-            removed: [],
-            metaRemoved: [],
-            removedMissingCount: 0,
-            removedOldCount: 0,
-            removedThresholdCount: 0,
-            removedSizeCount: 0,
-        };
-        // First, remove all keys we don't know about
-        for (const key of keys) {
-            if (sacredKeys.has(key) || key in meta.objects) {
-                continue;
+    _gc() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._gcOpts) {
+                return;
             }
-            this._log.info('Lost track of key in meta', key);
-            promises.push(this._persister.removeItem(key));
-            deets.removed.push(key);
-            deets.removedMissingCount++;
-        }
-        // Remove anything over the max age
-        const now = Date.now();
-        for (const [k, m] of Object.entries(meta.objects)) {
-            if (!sacredKeys.has(k) &&
-                m.updatedAt < now - this._gcOpts.maxAgeMs) {
-                promises.push(this._persister.removeItem(k));
-                delete meta.objects[k];
-                deets.removed.push(k);
-                deets.removedOldCount++;
+            const keys = new Set(yield this._persister.getAllKeys());
+            keys.delete(META_KEY);
+            // Keys we can't delete
+            const sacredKeys = new Set(Object.keys(this.currentValue));
+            for (const k of Object.keys(this._loadingKeys)) {
+                sacredKeys.add(k);
             }
-        }
-        // Keep queries under max queries
-        const maxEntries = Object.entries(meta.objects);
-        maxEntries.sort(([_k_a, a_meta], [_k_b, b_meta]) => {
-            return a_meta.updatedAt - b_meta.updatedAt;
-        });
-        const deletableMaxEntries = maxEntries.filter(([x]) => !sacredKeys.has(x));
-        if (maxEntries.length > this._gcOpts.maxEntries) {
-            for (const [k] of deletableMaxEntries.slice(0, maxEntries.length - this._gcOpts.maxEntries)) {
+            for (const k of this._loadedKeys) {
+                sacredKeys.add(k);
+            }
+            // Refresh meta from the store so that we're less likely to
+            // clobber data from other tabs
+            const meta = yield this._refreshMeta();
+            if (!meta) {
+                this._log.info('Could not gc because we were not able to load meta');
+                return;
+            }
+            const promises = [];
+            const deets = {
+                gcOpts: this._gcOpts,
+                keys,
+                sacredKeys,
+                removed: [],
+                metaRemoved: [],
+                removedMissingCount: 0,
+                removedOldCount: 0,
+                removedThresholdCount: 0,
+                removedSizeCount: 0,
+            };
+            // First, remove all keys we don't know about
+            for (const key of keys) {
+                if (sacredKeys.has(key) || key in meta.objects) {
+                    continue;
+                }
+                this._log.info('Lost track of key in meta', key);
+                promises.push(this._persister.removeItem(key));
+                deets.removed.push(key);
+                deets.removedMissingCount++;
+            }
+            // Remove anything over the max age
+            const now = Date.now();
+            for (const [k, m] of Object.entries(meta.objects)) {
+                if (!sacredKeys.has(k) &&
+                    m.updatedAt < now - this._gcOpts.maxAgeMs) {
+                    promises.push(this._persister.removeItem(k));
+                    delete meta.objects[k];
+                    deets.removed.push(k);
+                    deets.removedOldCount++;
+                }
+            }
+            // Keep queries under max queries
+            const maxEntries = Object.entries(meta.objects);
+            maxEntries.sort(([_k_a, a_meta], [_k_b, b_meta]) => {
+                return a_meta.updatedAt - b_meta.updatedAt;
+            });
+            const deletableMaxEntries = maxEntries.filter(([x]) => !sacredKeys.has(x));
+            if (maxEntries.length > this._gcOpts.maxEntries) {
+                for (const [k] of deletableMaxEntries.slice(0, maxEntries.length - this._gcOpts.maxEntries)) {
+                    promises.push(this._persister.removeItem(k));
+                    delete meta.objects[k];
+                    deets.removed.push(k);
+                    deets.removedThresholdCount++;
+                }
+            }
+            // Remove oldest entries until we are under max size
+            const delEntries = Object.entries(meta.objects);
+            delEntries.sort(([_k_a, a_meta], [_k_b, b_meta]) => {
+                return a_meta.updatedAt - b_meta.updatedAt;
+            });
+            const deletableDelEntries = delEntries.filter(([x]) => !sacredKeys.has(x));
+            let currentSize = delEntries.reduce((acc, [_k, m]) => {
+                return acc + m.size;
+            }, 0);
+            while (currentSize > 0 &&
+                currentSize > this._gcOpts.maxSize &&
+                deletableDelEntries.length) {
+                const [[k, m]] = deletableDelEntries.splice(0, 1);
+                currentSize -= m.size;
                 promises.push(this._persister.removeItem(k));
                 delete meta.objects[k];
                 deets.removed.push(k);
-                deets.removedThresholdCount++;
+                deets.removedSizeCount++;
             }
-        }
-        // Remove oldest entries until we are under max size
-        const delEntries = Object.entries(meta.objects);
-        delEntries.sort(([_k_a, a_meta], [_k_b, b_meta]) => {
-            return a_meta.updatedAt - b_meta.updatedAt;
-        });
-        const deletableDelEntries = delEntries.filter(([x]) => !sacredKeys.has(x));
-        let currentSize = delEntries.reduce((acc, [_k, m]) => {
-            return acc + m.size;
-        }, 0);
-        while (currentSize > 0 &&
-            currentSize > this._gcOpts.maxSize &&
-            deletableDelEntries.length) {
-            const [[k, m]] = deletableDelEntries.splice(0, 1);
-            currentSize -= m.size;
-            promises.push(this._persister.removeItem(k));
-            delete meta.objects[k];
-            deets.removed.push(k);
-            deets.removedSizeCount++;
-        }
-        // Update meta to remove keys that are no longer in the store
-        for (const k of Object.keys(meta.objects)) {
-            if (!keys.has(k) && !sacredKeys.has(k)) {
-                delete meta.objects[k];
+            // Update meta to remove keys that are no longer in the store
+            for (const k of Object.keys(meta.objects)) {
+                if (!keys.has(k) && !sacredKeys.has(k)) {
+                    delete meta.objects[k];
+                }
             }
-        }
-        if (deets.removed.length || deets.metaRemoved.length) {
-            // Trigger a flush of the meta
-            promises.push(this._enqueuePersist({ skipGc: true }));
-        }
-        this._log.info('Completed GC', deets);
-        await Promise.all(promises);
-        return deets;
+            if (deets.removed.length || deets.metaRemoved.length) {
+                // Trigger a flush of the meta
+                promises.push(this._enqueuePersist({ skipGc: true }));
+            }
+            this._log.info('Completed GC', deets);
+            yield Promise.all(promises);
+            return deets;
+        });
     }
     // Schedules a GC to run in one minute (unless it is already scheduled)
     gc() {