@signaldb/svelte 2.0.0-beta.6 → 2.0.0-beta.8

package/dist/base/core/src/AsyncDataAdapter.d.ts

@@ -0,0 +1,64 @@
+import type { BaseItem } from './Collection';
+import type Collection from './Collection';
+import type DataAdapter from './DataAdapter';
+import type { CollectionBackend } from './DataAdapter';
+import type StorageAdapter from './types/StorageAdapter';
+export interface AsyncDataAdapterOptions {
+    /** Factory to obtain a StorageAdapter per collection name */
+    storage: (name: string) => StorageAdapter<any, any>;
+    /** Optional logical id (handy if you run multiple adapters side-by-side) */
+    id?: string;
+    /** Optional error hook (mirrors WorkerDataAdapterHost) */
+    onError?: (error: Error) => void;
+}
+/**
+ * AsyncDataAdapter
+ * Combines WorkerDataAdapter + WorkerDataAdapterHost into a single, transport-free adapter.
+ * - Keeps the DataAdapter/CollectionBackend surface identical to the Worker version.
+ * - Executes queries and mutations directly against the provided StorageAdapter.
+ * - Preserves index-aware query optimization and push-style query updates to listeners.
+ */
+export default class AsyncDataAdapter implements DataAdapter {
+    private options;
+    private id;
+    private onError;
+    private storageAdapters;
+    private storageAdapterReady;
+    private collectionIndices;
+    private queries;
+    constructor(options: AsyncDataAdapterOptions);
+    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
+    private setupStorage;
+    private ensureStorageAdapter;
+    /**
+     * Compute and publish the result for a specific query
+     * @param collectionName - name of the collection
+     * @param selector - query selector
+     * @param options - query options
+     */
+    private fulfillQuery;
+    /**
+     * Notify listeners about state changes and keep the cache updated
+     * @param collectionName - name of the collection
+     * @param qid - query id
+     * @param state - new state
+     * @param error - error if state is 'error', null otherwise
+     */
+    private publishState;
+    private publishResult;
+    private getIndexInfo;
+    private queryItems;
+    private executeQuery;
+    /**
+     * After mutations, recompute and push updates for affected active queries
+     * @param collectionName - name of the collection
+     * @param affectedItems - item states before and/or after the mutation
+     */
+    private checkQueryUpdates;
+    private insert;
+    private updateOne;
+    private updateMany;
+    private replaceOne;
+    private removeOne;
+    private removeMany;
+}

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

@@ -0,0 +1,450 @@
+"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 getMatchingKeys_1 = __importDefault(require("./utils/getMatchingKeys"));
+const sortItems_1 = __importDefault(require("./utils/sortItems"));
+const project_1 = __importDefault(require("./utils/project"));
+/**
+ * AsyncDataAdapter
+ * Combines WorkerDataAdapter + WorkerDataAdapterHost into a single, transport-free adapter.
+ * - Keeps the DataAdapter/CollectionBackend surface identical to the Worker version.
+ * - Executes queries and mutations directly against the provided StorageAdapter.
+ * - Preserves index-aware query optimization and push-style query updates to listeners.
+ */
+class AsyncDataAdapter {
+    options;
+    id;
+    onError;
+    // Per-collection resources
+    storageAdapters = new Map();
+    storageAdapterReady = new Map();
+    collectionIndices = new Map();
+    // Per-collection query registries
+    queries = new Map();
+    constructor(options) {
+        this.options = options;
+        this.id = options.id || 'async-data-adapter';
+        this.onError = options.onError ?? ((error) => {
+            /* eslint-disable no-console */ console.error(error);
+        });
+    }
+    createCollectionBackend(collection, indices) {
+        // init per-collection state
+        this.collectionIndices.set(collection.name, indices);
+        this.queries.set(collection.name, new Map());
+        this.ensureStorageAdapter(collection.name);
+        const ready = (async () => {
+            try {
+                await this.setupStorage(collection.name, indices);
+            }
+            catch (error) {
+                // Handle inside the same async task to avoid unhandled rejections
+                this.onError(error);
+                throw error;
+            }
+        })();
+        this.storageAdapterReady.set(collection.name, ready);
+        // don't block createCollectionBackend; callers can await isReady()
+        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,
+            });
+            // kick async execution
+            void this.fulfillQuery(collection.name, selector, options).catch(this.onError);
+        };
+        const unregisterQuery = (selector, options) => {
+            const qid = (0, queryId_1.default)(selector, options);
+            this.queries.get(collection.name)?.delete(qid);
+        };
+        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!`);
+            // ensure the record exists so we have a listener bucket
+            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;
+                return this.executeQuery(collection.name, selector, options);
+            },
+            dispose: async () => {
+                // mirror host.unregisterCollection semantics
+                this.storageAdapters.delete(collection.name);
+                this.queries.delete(collection.name);
+                this.collectionIndices.delete(collection.name);
+                this.storageAdapterReady.delete(collection.name);
+            },
+            isReady: async () => {
+                await ready;
+            },
+        };
+    }
+    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(index => storage.createIndex(index)));
+    }
+    ensureStorageAdapter(name) {
+        if (this.storageAdapters.has(name))
+            return;
+        const adapter = this.options.storage(name);
+        if (!adapter)
+            return;
+        this.storageAdapters.set(name, adapter);
+    }
+    /**
+     * Compute and publish the result for a specific query
+     * @param collectionName - name of the collection
+     * @param selector - query selector
+     * @param options - query options
+     */
+    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);
+        }
+    }
+    /**
+     * Notify listeners about state changes and keep the cache updated
+     * @param collectionName - name of the collection
+     * @param qid - query id
+     * @param state - new state
+     * @param error - error if state is 'error', null otherwise
+     */
+    publishState(collectionName, qid, state, error) {
+        const rec = this.queries.get(collectionName)?.get(qid);
+        if (!rec)
+            return;
+        rec.state = state;
+        rec.error = error;
+        // notify subscribers
+        for (const callback of rec.listeners) {
+            try {
+                callback(state);
+            }
+            catch (error_) {
+                this.onError(error_);
+            }
+        }
+    }
+    publishResult(collectionName, qid, items) {
+        const rec = this.queries.get(collectionName)?.get(qid);
+        if (!rec)
+            return;
+        rec.items = items;
+    }
+    async getIndexInfo(collectionName, selector) {
+        const storageAdapter = this.storageAdapters.get(collectionName);
+        if (!storageAdapter)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        if (selector != null
+            && Object.keys(selector).length === 1
+            && 'id' in selector
+            && typeof selector.id !== 'object') {
+            return {
+                matched: true,
+                ids: [selector.id].filter(Boolean),
+                optimizedSelector: {},
+            };
+        }
+        if (selector == null) {
+            return {
+                matched: false,
+                ids: [],
+                optimizedSelector: {},
+            };
+        }
+        const indices = this.collectionIndices.get(collectionName) ?? [];
+        return (0, getIndexInfo_1.default)(indices.map(field => async (flatSelector) => {
+            if (!Object.hasOwnProperty.call(flatSelector, field))
+                return { matched: false };
+            const index = await storageAdapter.readIndex(field);
+            const fieldSelector = flatSelector[field];
+            const filtersForNull = fieldSelector == null || fieldSelector.$exists === false;
+            const keys = filtersForNull
+                ? { include: null, exclude: [...index.keys()].filter(key => key != null) }
+                : (0, getMatchingKeys_1.default)(field, flatSelector);
+            if (keys.include == null && keys.exclude == null)
+                return { matched: false };
+            // Build included ids
+            let includedIds = [];
+            if (keys.include == null) {
+                for (const set of index.values())
+                    for (const pos of set)
+                        includedIds.push(pos);
+            }
+            else {
+                for (const key of keys.include) {
+                    const idSet = index.get(key);
+                    if (idSet)
+                        for (const id of idSet)
+                            includedIds.push(id);
+                }
+            }
+            // Apply exclusions
+            if (keys.exclude != null) {
+                const excludeIds = new Set();
+                for (const key of keys.exclude) {
+                    const idSet = index.get(key);
+                    if (idSet)
+                        for (const id of idSet)
+                            excludeIds.add(id);
+                }
+                includedIds = includedIds.filter(pos => !excludeIds.has(pos));
+            }
+            return { matched: true, ids: includedIds, fields: [field], keepSelector: filtersForNull };
+        }), 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) };
+        });
+    }
+    /**
+     * After mutations, recompute and push updates for affected active queries
+     * @param collectionName - name of the collection
+     * @param affectedItems - item states before and/or after the mutation
+     */
+    async checkQueryUpdates(collectionName, affectedItems) {
+        const registry = this.queries.get(collectionName);
+        if (!registry)
+            throw new Error(`Collection ${collectionName} not initialized!`);
+        if (registry.size === 0)
+            return;
+        // Find active queries matching an item state before or after the mutation
+        const affected = [...registry.values()].filter(({ selector }) => affectedItems.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);
+            }
+        }));
+    }
+    async insert(collectionName, newItem) {
+        const storage = this.storageAdapters.get(collectionName);
+        if (!storage)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const existingItems = await storage.readIds([newItem.id]);
+        if (existingItems.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 storage.readIds([modified.id]);
+            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 storage.readIds([modified.id]);
+                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 storage.readIds([modified.id]);
+            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;
+    }
+}
+exports.default = AsyncDataAdapter;

package/dist/base/core/src/AutoFetchDataAdapter.d.ts

@@ -0,0 +1,112 @@
+import type { BaseItem } from './Collection';
+import type Collection from './Collection';
+import type DataAdapter from './DataAdapter';
+import type { CollectionBackend } from './DataAdapter';
+import type StorageAdapter from './types/StorageAdapter';
+import type Selector from './types/Selector';
+/**
+ * AutoFetchDataAdapterOptions
+ *
+ * Merges the core options required to talk to a per-collection StorageAdapter with
+ * the auto-fetch behavior inspired by AutoFetchCollection.
+ */
+export interface AutoFetchDataAdapterOptions {
+    /** Factory to obtain a StorageAdapter per collection name */
+    storage?: (name: string) => StorageAdapter<any, any>;
+    /** Optional logical id (handy if you run multiple adapters side-by-side) */
+    id?: string;
+    /** Optional error hook */
+    onError?: (error: Error) => void;
+    /**
+     * Fetch hook: given a selector, retrieve items from a remote source.
+     * Must resolve to an object with an `items` array. Items MUST include an `id`.
+     */
+    fetchQueryItems: (collectionName: string, selector: Selector<BaseItem>) => Promise<BaseItem[] | undefined>;
+    /**
+     * Optional: called once at adapter construction to subscribe to remote changes.
+     * When invoked, call the provided callback whenever the remote source changed
+     * and all active queries should be re-fetched.
+     */
+    registerRemoteChange?: (onChange: () => Promise<void>) => Promise<void>;
+    /**
+     * Merge strategy for ingesting freshly fetched items with existing ones.
+     * Default is shallow spread (right wins).
+     */
+    mergeItems?: <T extends BaseItem<any>>(a: T, b: T) => T;
+    /**
+     * Delay (ms) before purging auto-fetched items for a query after the query
+     * becomes inactive. Set to 0 to purge immediately. Default: 10s.
+     */
+    purgeDelay?: number;
+}
+/**
+ * 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.
+ */
+export default class AutoFetchDataAdapter implements DataAdapter {
+    private options;
+    private id;
+    private onError;
+    private fetchQueryItems;
+    private mergeItems;
+    private purgeDelay;
+    private storageAdapters;
+    private storageAdapterReady;
+    private collectionIndices;
+    private queries;
+    private activeObservers;
+    private observerTimeouts;
+    private selectorIds;
+    private idRefCounts;
+    private autoloadIds;
+    constructor(options: AutoFetchDataAdapterOptions);
+    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
+    private forceRefetchAll;
+    private fetchAndIngest;
+    private purgeSelector;
+    private setupStorage;
+    private ensureStorageAdapter;
+    private publishForSelector;
+    private publishState;
+    private publishResult;
+    private fulfillQuery;
+    private getIndexInfo;
+    private queryItems;
+    private executeQuery;
+    private checkQueryUpdates;
+    private insert;
+    private updateOne;
+    private updateMany;
+    private replaceOne;
+    private removeOne;
+    private removeMany;
+    private upsertMerged;
+}
+/**
+ * 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'])
+ */