@instantdb/core 0.22.97 → 0.22.98

package/dist/esm/utils/PersistedObject.js

@@ -12,15 +12,6 @@
 // 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';
@@ -37,29 +28,40 @@ 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 = (_a = opts.saveThrottleMs) !== null && _a !== void 0 ? _a : 100;
-        this._idleCallbackMaxWaitMs = (_b = opts.idleCallbackMaxWaitMs) !== null && _b !== void 0 ? _b : 1000;
+        this._saveThrottleMs = opts.saveThrottleMs ?? 100;
+        this._idleCallbackMaxWaitMs = opts.idleCallbackMaxWaitMs ?? 1000;
         this._gcOpts = opts.gc;
         this.currentValue = {};
         this._loadedKeys = new Set();
@@ -69,97 +71,85 @@ export class PersistedObject {
             this._preloadEntries(opts.preloadEntryCount);
         }
     }
-    _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 _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;
+        }
     }
-    _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;
+    async _getMeta() {
+        if (this._meta.value) {
             return this._meta.value;
-        });
-    }
-    _refreshMeta() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._initMeta();
+        }
+        if (this._meta.loadingPromise) {
+            await this._meta.loadingPromise;
             return this._meta.value;
-        });
+        }
+        this._initMeta();
+        await this._meta.loadingPromise;
+        return this._meta.value;
     }
-    _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);
-            }
-        });
+    async _refreshMeta() {
+        await this._initMeta();
+        return this._meta.value;
     }
-    _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;
-            }
-            catch (e) {
-                console.error(`Unable to read from storage for key=${key}`, e);
-                return null;
-            }
+    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;
         });
+        for (const [k] of entries.slice(0, n)) {
+            this._loadKey(k);
+        }
     }
-    waitForKeyToLoad(k) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._loadedKeys.has(k)) {
-                return this.currentValue[k];
+    async _getFromStorage(key) {
+        try {
+            const data = await this._persister.getItem(key);
+            if (!data) {
+                return data;
             }
-            yield (this._loadingKeys[k] || this._loadKey(k));
+            const parsed = this.parse(key, data);
+            return parsed;
+        }
+        catch (e) {
+            console.error(`Unable to read from storage for key=${key}`, e);
+            return null;
+        }
+    }
+    async waitForKeyToLoad(k) {
+        if (this._loadedKeys.has(k)) {
             return this.currentValue[k];
-        });
+        }
+        await (this._loadingKeys[k] || this._loadKey(k));
+        return this.currentValue[k];
     }
     // Used for tests
-    waitForMetaToLoad() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._getMeta();
-        });
+    async waitForMetaToLoad() {
+        return this._getMeta();
     }
     // Unloads the key so that it can be garbage collected, but does not
     // delete it. Removes the key from currentValue.
@@ -168,41 +158,38 @@ export class PersistedObject {
         delete this._loadingKeys[k];
         delete this.currentValue[k];
     }
-    _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;
-                }
+    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;
             }
-            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 === null || opts === void 0 ? void 0 : opts.skipGc;
+        const skipGc = 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
-                    ? Object.assign(Object.assign({}, opts), { attempts: (opts.attempts || 0) + 1 }) : { attempts: 1 })
+                    ? { ...opts, attempts: (opts.attempts || 0) + 1 }
+                    : { attempts: 1 })
                     .then(resolve)
-                    .catch(reject), 10 + ((_a = opts === null || opts === void 0 ? void 0 : opts.attempts) !== null && _a !== void 0 ? _a : 0) * 1000);
+                    .catch(reject), 10 + (opts?.attempts ?? 0) * 1000);
             });
             promises.push(p);
             return Promise.all(promises).then((vs) => vs.reduce((acc, x) => acc + x, 0));
@@ -233,14 +220,14 @@ export class PersistedObject {
         }
         const keysToLoad = [];
         const kvPairs = [[META_KEY, metaValue]];
-        const metaObjects = (_a = metaValue.objects) !== null && _a !== void 0 ? _a : {};
+        const metaObjects = metaValue.objects ?? {};
         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 = (_b = metaObjects[k]) !== null && _b !== void 0 ? _b : {
+                const m = metaObjects[k] ?? {
                     createdAt: Date.now(),
                     updatedAt: Date.now(),
                     size,
@@ -271,119 +258,115 @@ export class PersistedObject {
             return vs.reduce((acc, x) => acc + x, 0);
         });
     }
-    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 flush() {
+        if (!this._nextSave) {
+            return;
+        }
+        clearTimeout(this._nextSave);
+        this._nextSave = null;
+        const p = this._writeToStorage();
+        return p;
     }
-    _gc() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._gcOpts) {
-                return;
-            }
-            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);
-            }
-            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++;
-                }
+    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;
             }
-            // 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;
+            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.removedSizeCount++;
+                deets.removedOldCount++;
             }
-            // 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 }));
+        }
+        // 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++;
             }
-            this._log.info('Completed GC', deets);
-            yield Promise.all(promises);
-            return deets;
+        }
+        // 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];
+            }
+        }
+        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;
     }
     // Schedules a GC to run in one minute (unless it is already scheduled)
     gc() {