@signaldb/svelte 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/base/core/src/AutoFetchDataAdapter.js

@@ -0,0 +1,612 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const deepClone_1 = __importDefault(require("./utils/deepClone"));
+const match_1 = __importDefault(require("./utils/match"));
+const modify_1 = __importDefault(require("./utils/modify"));
+const queryId_1 = __importDefault(require("./utils/queryId"));
+const isEqual_1 = __importDefault(require("./utils/isEqual"));
+const getIndexInfo_1 = __importDefault(require("./getIndexInfo"));
+const storageIndexQuery_1 = __importDefault(require("./utils/storageIndexQuery"));
+const idIndexQuery_1 = __importDefault(require("./utils/idIndexQuery"));
+const sortItems_1 = __importDefault(require("./utils/sortItems"));
+const project_1 = __importDefault(require("./utils/project"));
+/**
+ * Default merge strategy: shallow spread (right wins)
+ * @param a first item
+ * @param b second item
+ * @returns merged item
+ */
+function defaultMergeItems(a, b) {
+    return { ...a, ...b };
+}
+/**
+ * Generates a stable key for a selector
+ * @param selector - the selector
+ * @returns the key
+ */
+function selectorId(selector) {
+    return JSON.stringify(selector ?? {});
+}
+/**
+ * AutoFetchDataAdapter
+ *
+ * A DataAdapter that:
+ * - Mirrors the CollectionBackend surface (CRUD + query registry + lifecycle)
+ * - Executes queries against a provided StorageAdapter (local cache)
+ * - On first registration of a selector, auto-fetches from a remote source and
+ *   ingests the result into storage (upsert), then pushes query result updates
+ * - Optionally purges auto-fetched items for a selector once no observers remain
+ * - Can subscribe to remote change notifications to re-fetch active selectors
+ *
+ * IMPORTANT: Purging only ever deletes items that were introduced via the
+ * auto-fetch path and are no longer referenced by any active selector. Items
+ * inserted through CRUD calls are never purged.
+ */
+class AutoFetchDataAdapter {
+    options;
+    id;
+    onError;
+    fetchQueryItems;
+    mergeItems;
+    purgeDelay;
+    // Per-collection resources
+    storageAdapters = new Map();
+    storageAdapterReady = new Map();
+    collectionIndices = new Map();
+    // Per-collection query registries and auto-fetch bookkeeping
+    queries = new Map();
+    activeObservers = new Map(); // per-collection: key->record
+    observerTimeouts = new Map(); // per-collection
+    selectorIds = new Map(); // per-collection: selectorKey -> Set<id>
+    idRefCounts = new Map(); // per-collection: id -> refcount (for auto-fetched items)
+    autoloadIds = new Map(); // per-collection: ids that were introduced via auto-fetch
+    constructor(options) {
+        this.options = options;
+        this.id = options.id || 'autofetch-data-adapter';
+        this.onError = options.onError ?? ((error) => {
+            /* eslint-disable no-console */ console.error(error);
+        });
+        this.fetchQueryItems = options.fetchQueryItems;
+        this.mergeItems = options.mergeItems ?? defaultMergeItems;
+        this.purgeDelay = options.purgeDelay ?? 10_000;
+        if (options.registerRemoteChange) {
+            void options.registerRemoteChange(async () => {
+                await this.forceRefetchAll();
+            });
+        }
+    }
+    createCollectionBackend(collection, indices) {
+        // init per-collection state
+        this.collectionIndices.set(collection.name, indices);
+        this.queries.set(collection.name, new Map());
+        this.ensureStorageAdapter(collection.name);
+        this.activeObservers.set(collection.name, new Map());
+        this.observerTimeouts.set(collection.name, new Map());
+        this.selectorIds.set(collection.name, new Map());
+        this.idRefCounts.set(collection.name, new Map());
+        this.autoloadIds.set(collection.name, new Set());
+        const ready = this.setupStorage(collection.name, indices);
+        this.storageAdapterReady.set(collection.name, ready);
+        const registerQuery = (selector, options) => {
+            const qid = (0, queryId_1.default)(selector, options);
+            const registry = this.queries.get(collection.name);
+            if (!registry)
+                throw new Error(`Collection ${collection.name} not initialized!`);
+            registry.set(qid, {
+                selector,
+                options,
+                items: [],
+                listeners: new Set(),
+                ...registry.get(qid),
+                state: 'active',
+                error: null,
+            });
+            // auto-fetch lifecycle
+            const key = selectorId(selector);
+            const perColObservers = this.activeObservers.get(collection.name);
+            const current = perColObservers?.get(key)?.count ?? 0;
+            perColObservers?.set(key, { selector, count: current + 1 });
+            // cancel scheduled purge if any
+            const timeouts = this.observerTimeouts.get(collection.name);
+            const t = timeouts?.get(key);
+            if (t)
+                clearTimeout(t);
+            // Kick async fetch on first observer
+            if (current === 0) {
+                void this.fetchAndIngest(collection.name, selector).catch(this.onError);
+            }
+            // Also compute the current local result for immediate availability
+            void this.fulfillQuery(collection.name, selector, options).catch(this.onError);
+        };
+        const unregisterQuery = (selector, options) => {
+            const qid = (0, queryId_1.default)(selector, options);
+            const registry = this.queries.get(collection.name);
+            registry?.delete(qid);
+            const key = selectorId(selector);
+            const perColObservers = this.activeObservers.get(collection.name);
+            const current = perColObservers?.get(key)?.count ?? 0;
+            const remaining = Math.max(0, current - 1);
+            if (remaining > 0) {
+                perColObservers?.set(key, { selector, count: remaining });
+                return;
+            }
+            // schedule purge of auto-fetched items for this selector
+            const doPurge = () => {
+                perColObservers?.delete(key);
+                void this.purgeSelector(collection.name, selector).catch(this.onError);
+            };
+            if (this.purgeDelay === 0) {
+                doPurge();
+            }
+            else {
+                const timeouts = this.observerTimeouts.get(collection.name);
+                const t = timeouts?.get(key);
+                if (t)
+                    clearTimeout(t);
+                timeouts?.set(key, setTimeout(doPurge, this.purgeDelay));
+            }
+        };
+        const getQueryState = (selector, options) => {
+            const q = this.queries.get(collection.name)?.get((0, queryId_1.default)(selector, options));
+            return q?.state ?? 'active';
+        };
+        const getQueryError = (selector, options) => {
+            const q = this.queries.get(collection.name)?.get((0, queryId_1.default)(selector, options));
+            return q?.error ?? null;
+        };
+        const getQueryResult = (selector, options) => {
+            const q = this.queries.get(collection.name)?.get((0, queryId_1.default)(selector, options));
+            return q?.items ?? [];
+        };
+        const onQueryStateChange = (selector, options, callback) => {
+            const qid = (0, queryId_1.default)(selector, options);
+            const registry = this.queries.get(collection.name);
+            if (!registry)
+                throw new Error(`Collection ${collection.name} not initialized!`);
+            if (!registry.has(qid)) {
+                registry.set(qid, {
+                    selector,
+                    options,
+                    state: 'active',
+                    error: null,
+                    items: [],
+                    listeners: new Set(),
+                });
+            }
+            registry.get(qid)?.listeners.add(callback);
+            return () => {
+                registry.get(qid)?.listeners.delete(callback);
+            };
+        };
+        return {
+            insert: async (item) => {
+                await ready;
+                const inserted = await this.insert(collection.name, item);
+                return inserted;
+            },
+            updateOne: async (selector, modifier) => {
+                await ready;
+                return this.updateOne(collection.name, selector, modifier);
+            },
+            updateMany: async (selector, modifier) => {
+                await ready;
+                return this.updateMany(collection.name, selector, modifier);
+            },
+            replaceOne: async (selector, replacement) => {
+                await ready;
+                return this.replaceOne(collection.name, selector, replacement);
+            },
+            removeOne: async (selector) => {
+                await ready;
+                return this.removeOne(collection.name, selector);
+            },
+            removeMany: async (selector) => {
+                await ready;
+                return this.removeMany(collection.name, selector);
+            },
+            registerQuery,
+            unregisterQuery,
+            getQueryState,
+            getQueryError,
+            getQueryResult,
+            onQueryStateChange,
+            executeQuery: async (selector, options) => {
+                await ready;
+                registerQuery(selector, options);
+                await new Promise((resolve) => {
+                    let stop = () => { };
+                    stop = onQueryStateChange(selector, options, (state) => {
+                        if (state === 'active')
+                            return;
+                        resolve();
+                        stop();
+                    });
+                });
+                const result = getQueryResult(selector, options);
+                unregisterQuery(selector, options);
+                return result;
+            },
+            dispose: async () => {
+                this.storageAdapters.delete(collection.name);
+                this.queries.delete(collection.name);
+                this.collectionIndices.delete(collection.name);
+                this.storageAdapterReady.delete(collection.name);
+                this.activeObservers.delete(collection.name);
+                this.observerTimeouts.delete(collection.name);
+                this.selectorIds.delete(collection.name);
+                this.idRefCounts.delete(collection.name);
+                this.autoloadIds.delete(collection.name);
+            },
+            isReady: async () => {
+                await ready;
+            },
+        };
+    }
+    // ===== Auto-fetch mechanics =====
+    async forceRefetchAll() {
+        const tasks = [];
+        for (const [collectionName, observers] of this.activeObservers.entries()) {
+            for (const { selector, count } of observers.values()) {
+                if (count > 0)
+                    tasks.push(this.fetchAndIngest(collectionName, selector));
+            }
+        }
+        await Promise.all(tasks);
+    }
+    async fetchAndIngest(collectionName, selector) {
+        // mark queries covering this selector as active (for UX spinners)
+        this.publishForSelector(collectionName, selector, 'active', null);
+        try {
+            const items = await this.fetchQueryItems(collectionName, selector);
+            if (!items || !Array.isArray(items)) {
+                throw new Error('AutoFetchDataAdapter: fetchQueryItems must resolve to { items: T[] }');
+            }
+            const ids = items.map(i => i.id);
+            // Track selector->ids for purge calculations
+            const selectorKey = selectorId(selector);
+            const selMap = this.selectorIds.get(collectionName);
+            const previous = selMap?.get(selectorKey) ?? new Set();
+            ids.forEach(id => previous.add(id));
+            selMap?.set(selectorKey, previous);
+            // Ingest via upsert (merge when existing)
+            await this.upsertMerged(collectionName, items);
+            // push updates to any queries that might be affected
+            await this.checkQueryUpdates(collectionName, items);
+        }
+        catch (error) {
+            this.publishForSelector(collectionName, selector, 'error', error);
+            this.onError(error);
+        }
+    }
+    async purgeSelector(collectionName, selector) {
+        const selectorKey = selectorId(selector);
+        const selMap = this.selectorIds.get(collectionName);
+        const ids = selMap?.get(selectorKey);
+        selMap?.delete(selectorKey);
+        if (!ids || ids.size === 0)
+            return;
+        const referenceMap = this.idRefCounts.get(collectionName);
+        const autoload = this.autoloadIds.get(collectionName);
+        const toRemove = [];
+        // Decrement reference counts and collect safe-to-remove ids
+        for (const id of ids) {
+            const current = referenceMap?.get(id) ?? 0;
+            const next = Math.max(0, current - 1);
+            if (next === 0) {
+                referenceMap?.delete(id);
+                if (autoload?.has(id))
+                    toRemove.push(id);
+            }
+            else {
+                referenceMap?.set(id, next);
+            }
+        }
+        if (toRemove.length === 0)
+            return;
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        // Read and remove only those ids that still exist in storage
+        const items = await storage.readIds(toRemove);
+        if (items.length > 0) {
+            await storage.remove(items);
+            await this.checkQueryUpdates(collectionName, items);
+        }
+        // finally, clear autoload marks
+        toRemove.forEach(id => autoload?.delete(id));
+    }
+    // ===== Core query + CRUD plumbing (index-aware, same semantics as AsyncDataAdapter) =====
+    async setupStorage(collectionName, indices) {
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        await storage.setup();
+        await Promise.all(indices.map(field => storage.createIndex(field)));
+    }
+    ensureStorageAdapter(name) {
+        if (this.storageAdapters.has(name))
+            return;
+        const adapter = this.options.storage && this.options.storage(name);
+        if (!adapter)
+            return;
+        this.storageAdapters.set(name, adapter);
+    }
+    publishForSelector(collectionName, selector, state, error) {
+        const registry = this.queries.get(collectionName);
+        if (!registry)
+            return;
+        for (const query of registry.values()) {
+            // We only toggle state for records with an equal selector
+            if (!(0, isEqual_1.default)(query.selector, selector))
+                continue;
+            this.publishState(collectionName, (0, queryId_1.default)(query.selector, query.options), state, error);
+        }
+    }
+    publishState(collectionName, qid, state, error) {
+        const query = this.queries.get(collectionName)?.get(qid);
+        if (!query)
+            return;
+        query.state = state;
+        query.error = error;
+        for (const callback of query.listeners) {
+            try {
+                callback(state);
+            }
+            catch (error_) {
+                this.onError(error_);
+            }
+        }
+    }
+    publishResult(collectionName, qid, items) {
+        const query = this.queries.get(collectionName)?.get(qid);
+        if (!query)
+            return;
+        query.items = items;
+        this.queries.get(collectionName)?.set(qid, query);
+    }
+    async fulfillQuery(collectionName, selector, options) {
+        const qid = (0, queryId_1.default)(selector, options);
+        const registry = this.queries.get(collectionName);
+        if (!registry)
+            throw new Error(`Collection ${collectionName} not initialized!`);
+        const rec = registry.get(qid);
+        if (!rec)
+            return;
+        this.publishState(collectionName, qid, 'active', null);
+        try {
+            const items = await this.executeQuery(collectionName, selector, options);
+            this.publishResult(collectionName, qid, items);
+            this.publishState(collectionName, qid, 'complete', null);
+        }
+        catch (error) {
+            this.publishState(collectionName, qid, 'error', error);
+        }
+    }
+    async getIndexInfo(collectionName, selector) {
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        // `id` needs no declared index — `readIds` is exactly that lookup.
+        if (selector != null && Object.keys(selector).length === 1 && 'id' in selector) {
+            const idResult = (0, idIndexQuery_1.default)(selector);
+            if (idResult.matched)
+                return { matched: true, ids: idResult.ids, optimizedSelector: {} };
+        }
+        if (selector == null) {
+            return { matched: false, ids: [], optimizedSelector: {} };
+        }
+        const indices = this.collectionIndices.get(collectionName) ?? [];
+        return (0, getIndexInfo_1.default)(indices.map(field => (0, storageIndexQuery_1.default)(storage, field)), selector);
+    }
+    async queryItems(collectionName, selector) {
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const index = await this.getIndexInfo(collectionName, selector);
+        const matchItems = (item) => {
+            if (index.optimizedSelector == null)
+                return true;
+            if (Object.keys(index.optimizedSelector).length <= 0)
+                return true;
+            return (0, match_1.default)(item, index.optimizedSelector);
+        };
+        if (index.matched) {
+            const items = await storage.readIds(index.ids);
+            if ((0, isEqual_1.default)(index.optimizedSelector, {}))
+                return items;
+            return items.filter(matchItems);
+        }
+        else {
+            const allItems = await storage.readAll();
+            if ((0, isEqual_1.default)(selector, {}))
+                return allItems;
+            return allItems.filter(matchItems);
+        }
+    }
+    async executeQuery(collectionName, selector, options) {
+        const items = await this.queryItems(collectionName, selector || {});
+        const { sort, skip, limit, fields } = options || {};
+        const sorted = sort ? (0, sortItems_1.default)(items, sort) : items;
+        const skipped = skip ? sorted.slice(skip) : sorted;
+        const limited = limit ? skipped.slice(0, limit) : skipped;
+        const idExcluded = fields && fields.id === 0;
+        return limited.map((item) => {
+            if (!fields)
+                return item;
+            return { ...(idExcluded ? {} : { id: item.id }), ...(0, project_1.default)(item, fields) };
+        });
+    }
+    async checkQueryUpdates(collectionName, changedItems) {
+        const registry = this.queries.get(collectionName);
+        if (!registry)
+            throw new Error(`Collection ${collectionName} not initialized!`);
+        if (registry.size === 0)
+            return;
+        // Find active queries whose selector matches at least one changed item
+        const affected = [...registry.values()].filter(({ selector }) => changedItems.some(item => (0, match_1.default)(item, selector)));
+        if (affected.length === 0)
+            return;
+        // Mark active and notify…
+        for (const { selector, options } of affected) {
+            const qid = (0, queryId_1.default)(selector, options);
+            this.publishState(collectionName, qid, 'active', null);
+        }
+        // …then recompute and complete
+        await Promise.all(affected.map(async ({ selector, options }) => {
+            const qid = (0, queryId_1.default)(selector, options);
+            try {
+                const items = await this.executeQuery(collectionName, selector, options);
+                this.publishResult(collectionName, qid, items);
+                this.publishState(collectionName, qid, 'complete', null);
+            }
+            catch (error) {
+                this.publishState(collectionName, qid, 'error', error);
+            }
+        }));
+    }
+    // ===== CRUD with push-style query updates =====
+    async insert(collectionName, newItem) {
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const existing = await this.executeQuery(collectionName, { id: newItem.id }, { limit: 1 });
+        if (existing.length > 0)
+            throw new Error(`Item with id ${String(newItem.id)} already exists`);
+        await storage.insert([newItem]);
+        await this.checkQueryUpdates(collectionName, [newItem]);
+        return newItem;
+    }
+    async updateOne(collectionName, selector, modifier) {
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const items = await this.executeQuery(collectionName, selector, { limit: 1 });
+        const [item] = items;
+        const { $setOnInsert, ...rest } = modifier;
+        if (item == null)
+            return [];
+        const modified = (0, modify_1.default)((0, deepClone_1.default)(item), rest);
+        if (item.id !== modified.id) {
+            const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
+            if (existing.length > 0)
+                throw new Error(`Item with id ${String(modified.id)} already exists`);
+        }
+        await storage.replace([modified]);
+        await this.checkQueryUpdates(collectionName, [item, modified]);
+        return [modified];
+    }
+    async updateMany(collectionName, selector, modifier) {
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const items = await this.executeQuery(collectionName, selector);
+        if (items.length === 0)
+            return [];
+        const { $setOnInsert, ...rest } = modifier;
+        const changed = await Promise.all(items.map(async (item) => {
+            const modified = (0, modify_1.default)((0, deepClone_1.default)(item), rest);
+            if (item.id !== modified.id) {
+                const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
+                if (existing.length > 0)
+                    throw new Error(`Item with id ${String(modified.id)} already exists`);
+            }
+            return modified;
+        }));
+        await storage.replace(changed);
+        await this.checkQueryUpdates(collectionName, [...items, ...changed]);
+        return changed;
+    }
+    async replaceOne(collectionName, selector, replacement) {
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const items = await this.executeQuery(collectionName, selector, { limit: 1 });
+        const [item] = items;
+        if (item == null)
+            return [];
+        const modified = { ...replacement, id: replacement.id ?? item.id };
+        if (item.id !== modified.id) {
+            const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
+            if (existing.length > 0)
+                throw new Error(`Item with id ${String(modified.id)} already exists`);
+        }
+        await storage.replace([modified]);
+        await this.checkQueryUpdates(collectionName, [item, modified]);
+        return [modified];
+    }
+    async removeOne(collectionName, selector) {
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const items = await this.executeQuery(collectionName, selector, { limit: 1 });
+        const [item] = items;
+        if (item == null)
+            return [];
+        await storage.remove([item]);
+        await this.checkQueryUpdates(collectionName, [item]);
+        return [item];
+    }
+    async removeMany(collectionName, selector) {
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const items = await this.executeQuery(collectionName, selector);
+        if (items.length === 0)
+            return [];
+        await storage.remove(items);
+        await this.checkQueryUpdates(collectionName, items);
+        return items;
+    }
+    // ===== Upsert/merge helper for ingesting fetched items =====
+    async upsertMerged(collectionName, incoming) {
+        if (incoming.length === 0)
+            return;
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const ids = incoming.map(i => i.id);
+        const existing = await storage.readIds(ids);
+        const existingById = new Map(existing.map((it) => [it.id, it]));
+        const toInsert = [];
+        const toReplace = [];
+        const referenceMap = this.idRefCounts.get(collectionName);
+        const autoload = this.autoloadIds.get(collectionName);
+        for (const item of incoming) {
+            const previous = existingById.get(item.id);
+            if (previous) {
+                toReplace.push(this.mergeItems(previous, item));
+            }
+            else {
+                toInsert.push(item);
+            }
+            // mark as auto-fetched and bump refcount
+            autoload?.add(item.id);
+            referenceMap?.set(item.id, (referenceMap?.get(item.id) ?? 0) + 1);
+        }
+        if (toInsert.length > 0)
+            await storage.insert(toInsert);
+        if (toReplace.length > 0)
+            await storage.replace(toReplace);
+    }
+}
+exports.default = AutoFetchDataAdapter;
+/**
+ * Usage (example):
+ *
+ * const adapter = new AutoFetchDataAdapter({
+ *   storage: (name) => new IndexedDBStorage(name),
+ *   fetchQueryItems: async (collectionName, selector) => {
+ *     const res = await fetch(`/api/${collectionName}?q=${encodeURIComponent(JSON.stringify(selector||{}))}`)
+ *     const items = await res.json()
+ *     return { items }
+ *   },
+ *   registerRemoteChange: (onChange) => subscribeToWS(onChange),
+ *   mergeItems: (a, b) => ({ ...a, ...b }),
+ *   purgeDelay: 10_000,
+ * })
+ *
+ * const backend = adapter.createCollectionBackend(myCollection, ['status', 'projectId'])
+ */