@signaldb/svelte 1.1.1 → 2.0.0-beta.10

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

@@ -0,0 +1,103 @@
+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;
+    /**
+     * How often a failing query is retried before it is published as `'error'`.
+     * A query that fails is otherwise a dead end for the rest of the session —
+     * cursors only requery on `'complete'`, so they keep serving their neutral
+     * empty value, which consumers cannot tell apart from "there is no data".
+     */
+    retry?: {
+        /** Total attempts including the first one. Default 3. */
+        attempts?: number;
+        /** Delay in ms before attempt N+1. Default 100 * 4 ** (attempt - 1). */
+        delay?: (attempt: number) => number;
+    };
+}
+/**
+ * Carries the context needed to act on a failed query. The bare storage error
+ * on its own does not say which collection or selector produced it, which made
+ * the default `console.error` hook close to useless.
+ */
+export declare class QueryError extends Error {
+    readonly collectionName: string;
+    readonly selector: unknown;
+    readonly options: unknown;
+    readonly attempts: number;
+    constructor(collectionName: string, selector: unknown, options: unknown, attempts: number, cause: unknown);
+}
+/**
+ * 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 retryAttempts;
+    private retryDelay;
+    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;
+    /**
+     * Executes a query, retrying transient failures before giving up. The state
+     * stays `'active'` across retries — consumers should see "still loading",
+     * not "failed", until we actually stop trying. Only the final failure is
+     * published as `'error'` and reported through `onError`; previously that
+     * error was swallowed entirely (`fulfillQuery` caught it internally, so the
+     * `.catch(this.onError)` on its call site was unreachable) and the query
+     * stayed dead for the rest of the session.
+     * @param collectionName - name of the collection
+     * @param selector - query selector
+     * @param options - query options
+     */
+    private runQuery;
+    /**
+     * 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,518 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryError = void 0;
+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"));
+/**
+ * Carries the context needed to act on a failed query. The bare storage error
+ * on its own does not say which collection or selector produced it, which made
+ * the default `console.error` hook close to useless.
+ */
+class QueryError extends Error {
+    collectionName;
+    selector;
+    options;
+    attempts;
+    constructor(collectionName, selector, options, attempts, cause) {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        super(`Query on "${collectionName}" failed after ${attempts} attempt(s): ${reason}`);
+        this.name = 'QueryError';
+        this.collectionName = collectionName;
+        this.selector = selector;
+        this.options = options;
+        this.attempts = attempts;
+        this.cause = cause;
+    }
+}
+exports.QueryError = QueryError;
+const DEFAULT_RETRY_ATTEMPTS = 3;
+const defaultRetryDelay = (attempt) => 100 * (4 ** (attempt - 1));
+const wait = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+/**
+ * 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;
+    retryAttempts;
+    retryDelay;
+    // 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);
+        });
+        this.retryAttempts = Math.max(1, options.retry?.attempts ?? DEFAULT_RETRY_ATTEMPTS);
+        this.retryDelay = options.retry?.delay ?? defaultRetryDelay;
+    }
+    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 retryQuery = (selector, options) => {
+            const qid = (0, queryId_1.default)(selector, options);
+            const rec = this.queries.get(collection.name)?.get(qid);
+            if (!rec)
+                return;
+            this.publishState(collection.name, qid, 'active', null);
+            void this.runQuery(collection.name, selector, options);
+        };
+        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);
+            // A query that has already failed would otherwise stay failed forever:
+            // `registerQuery` only runs for the *first* cursor on a selector, so
+            // every later observer inherited the dead state without anything ever
+            // retrying it. A new observer is a natural moment to try again.
+            if (registry.get(qid)?.state === 'error')
+                retryQuery(selector, options);
+            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,
+            retryQuery,
+            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);
+        await this.runQuery(collectionName, selector, options);
+    }
+    /**
+     * Executes a query, retrying transient failures before giving up. The state
+     * stays `'active'` across retries — consumers should see "still loading",
+     * not "failed", until we actually stop trying. Only the final failure is
+     * published as `'error'` and reported through `onError`; previously that
+     * error was swallowed entirely (`fulfillQuery` caught it internally, so the
+     * `.catch(this.onError)` on its call site was unreachable) and the query
+     * stayed dead for the rest of the session.
+     * @param collectionName - name of the collection
+     * @param selector - query selector
+     * @param options - query options
+     */
+    async runQuery(collectionName, selector, options) {
+        const qid = (0, queryId_1.default)(selector, options);
+        let lastError;
+        for (let attempt = 1; attempt <= this.retryAttempts; attempt += 1) {
+            // The query can be unregistered while a retry is waiting — dropping out
+            // here keeps a disposed cursor from resurrecting its record.
+            if (!this.queries.get(collectionName)?.has(qid))
+                return;
+            try {
+                const items = await this.executeQuery(collectionName, selector, options);
+                this.publishResult(collectionName, qid, items);
+                this.publishState(collectionName, qid, 'complete', null);
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < this.retryAttempts)
+                    await wait(this.retryDelay(attempt));
+            }
+        }
+        const queryError = new QueryError(collectionName, selector, options, this.retryAttempts, lastError);
+        this.publishState(collectionName, qid, 'error', queryError);
+        this.onError(queryError);
+    }
+    /**
+     * 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, with the same retry/report behaviour a
+        // freshly registered query gets — a mutation-triggered refresh that fails
+        // silently leaves exactly the same dead cursor.
+        await Promise.all(affected.map(({ selector, options }) => this.runQuery(collectionName, selector, options)));
+    }
+    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;