@signaldb/svelte 2.0.0-beta.1 → 2.0.0-beta.11

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

@@ -0,0 +1,41 @@
+import type { BaseItem, FieldSpecifier, SortSpecifier } from './Collection';
+import type Collection from './Collection';
+import type Modifier from './types/Modifier';
+import type Selector from './types/Selector';
+export interface QueryOptions<T extends BaseItem> {
+    /** Sort order (default: natural order) */
+    sort?: SortSpecifier<T> | undefined;
+    /** Number of results to skip at the beginning */
+    skip?: number | undefined;
+    /** Maximum number of results to return */
+    limit?: number | undefined;
+    /** Dictionary of fields to return or exclude. */
+    fields?: FieldSpecifier<T> | undefined;
+}
+export type StateChangeCallback = (state: 'active' | 'complete' | 'error') => void;
+export interface CollectionBackend<T extends BaseItem<I>, I> {
+    insert(item: T): Promise<T>;
+    updateOne(selector: Selector<T>, modifier: Modifier<T>): Promise<T[]>;
+    updateMany(selector: Selector<T>, modifier: Modifier<T>): Promise<T[]>;
+    replaceOne(selector: Selector<T>, replacement: Omit<T, 'id'> & Partial<Pick<T, 'id'>>): Promise<T[]>;
+    removeOne(selector: Selector<T>): Promise<T[]>;
+    removeMany(selector: Selector<T>): Promise<T[]>;
+    registerQuery<O extends QueryOptions<T>>(selector: Selector<T>, options: O): void;
+    unregisterQuery<O extends QueryOptions<T>>(selector: Selector<T>, options: O): void;
+    /**
+     * Re-runs a query that is currently in the `'error'` state. Optional so
+     * existing custom adapters keep compiling — an adapter that never surfaces
+     * an error state has nothing to implement.
+     */
+    retryQuery?<O extends QueryOptions<T>>(selector: Selector<T>, options: O): void;
+    getQueryState<O extends QueryOptions<T>>(selector: Selector<T>, options: O): 'active' | 'complete' | 'error';
+    getQueryError<O extends QueryOptions<T>>(selector: Selector<T>, options: O): Error | null;
+    getQueryResult<O extends QueryOptions<T>>(selector: Selector<T>, options: O): T[];
+    executeQuery<O extends QueryOptions<T>>(selector: Selector<T>, options: O): Promise<T[]>;
+    onQueryStateChange<O extends QueryOptions<T>>(selector: Selector<T>, options: O, callback: StateChangeCallback): () => void;
+    dispose(): Promise<void>;
+    isReady(): Promise<void>;
+}
+export default interface DataAdapter {
+    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,35 @@
+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';
+interface DefaultDataAdapterOptions {
+    storage?: (name: string) => StorageAdapter<any, any> | undefined;
+    onError?: (name: string, error: Error) => void;
+}
+export default class DefaultDataAdapter implements DataAdapter {
+    private items;
+    private options;
+    private storageAdapters;
+    private collections;
+    private indices;
+    private activeQueries;
+    private queryEmitters;
+    private queuedQueryUpdates;
+    private cachedQueryResults;
+    constructor(options?: DefaultDataAdapterOptions);
+    private ensureStorageAdapter;
+    private rebuildIndices;
+    private setupStorageAdapter;
+    private getIndexInfo;
+    private applyIndexDeltas;
+    private getItem;
+    private queryItems;
+    private executeQuery;
+    private flushQueuedQueryUpdates;
+    private executeAndCacheQuery;
+    private updateQueries;
+    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
+    fetchItemsFromStorage<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection?: Collection<T, I, E, U>): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,398 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createIndex_1 = __importDefault(require("./createIndex"));
+const getIndexInfo_1 = __importDefault(require("./getIndexInfo"));
+const deepClone_1 = __importDefault(require("./utils/deepClone"));
+const EventEmitter_1 = __importDefault(require("./utils/EventEmitter"));
+const isEqual_1 = __importDefault(require("./utils/isEqual"));
+const match_1 = __importDefault(require("./utils/match"));
+const modify_1 = __importDefault(require("./utils/modify"));
+const project_1 = __importDefault(require("./utils/project"));
+const queryId_1 = __importDefault(require("./utils/queryId"));
+const serializeValue_1 = __importDefault(require("./utils/serializeValue"));
+const sortItems_1 = __importDefault(require("./utils/sortItems"));
+/**
+ * Checks if there are any pending updates in the given changeset.
+ * @template T - The type of the items in the changeset.
+ * @param pendingUpdates - The changeset to check for pending updates.
+ * @returns `true` if there are pending updates, otherwise `false`.
+ */
+function hasPendingUpdates(pendingUpdates) {
+    return pendingUpdates.added.length > 0
+        || pendingUpdates.modified.length > 0
+        || pendingUpdates.removed.length > 0;
+}
+class DefaultDataAdapter {
+    items = new Map();
+    options;
+    storageAdapters = new Map();
+    collections = new Set();
+    indices = new Map();
+    activeQueries = new Map();
+    queryEmitters = new Map();
+    queuedQueryUpdates = new Map();
+    cachedQueryResults = new Map();
+    constructor(options) {
+        this.options = options || {};
+    }
+    ensureStorageAdapter(name) {
+        if (this.storageAdapters.get(name))
+            return; // already created
+        if (!this.options.storage)
+            return; // no storage function provided
+        const adapter = this.options.storage(name);
+        if (!adapter)
+            return; // no adapter returned
+        this.storageAdapters.set(name, adapter);
+    }
+    rebuildIndices(collection) {
+        const items = this.items.get(collection.name);
+        if (!items)
+            throw new Error(`Items not found for collection ${collection.name}`);
+        const indices = this.indices.get(collection.name);
+        if (!indices)
+            throw new Error(`Indices not found for collection ${collection.name}`);
+        indices.forEach(index => index.rebuild([...items.values()]));
+    }
+    async setupStorageAdapter(collection) {
+        const storageAdapter = this.storageAdapters.get(collection.name);
+        if (!storageAdapter)
+            return; // no persistence adapter available
+        return storageAdapter.setup()
+            .then(async () => {
+            await this.fetchItemsFromStorage(collection);
+        })
+            .catch((error) => {
+            if (!this.options.onError) {
+                // eslint-disable-next-line no-console
+                console.error(`Error during data persistence operation in collection ${collection.name}`, error);
+                return;
+            }
+            this.options.onError(collection.name, error instanceof Error ? error : new Error(error));
+        });
+    }
+    getIndexInfo(collection, selector) {
+        if (selector != null
+            && Object.keys(selector).length === 1
+            && 'id' in selector
+            && typeof selector.id !== 'object') {
+            return {
+                matched: true,
+                ids: [(0, serializeValue_1.default)(selector.id)],
+                optimizedSelector: {},
+            };
+        }
+        if (selector == null) {
+            return {
+                matched: false,
+                ids: [],
+                optimizedSelector: {},
+            };
+        }
+        return (0, getIndexInfo_1.default)((this.indices.get(collection.name) ?? []).map(i => i.query.bind(i)), selector);
+    }
+    applyIndexDeltas(collection, changes) {
+        const indices = this.indices.get(collection.name) ?? [];
+        for (const index of indices) {
+            if (changes.modified)
+                index.update(changes.modified);
+            if (changes.added && changes.added.length > 0)
+                index.insert(changes.added);
+            if (changes.removed && changes.removed.length > 0)
+                index.remove(changes.removed);
+        }
+    }
+    getItem(collection, selector) {
+        const memory = this.items.get(collection.name) ?? new Map();
+        const indexInfo = this.getIndexInfo(collection, selector);
+        const items = indexInfo.matched
+            ? indexInfo.ids.map(id => memory.get((0, serializeValue_1.default)(id))).filter(i => i != null)
+            : [...memory.values()];
+        const item = items.find(document => (0, match_1.default)(document, selector));
+        return item;
+    }
+    queryItems(collection, selector) {
+        const indexInfo = this.getIndexInfo(collection, selector);
+        const matchItems = (item) => {
+            if (indexInfo.optimizedSelector == null)
+                return true; // if no selector is given, return all items
+            if (Object.keys(indexInfo.optimizedSelector).length <= 0)
+                return true; // if selector is empty, return all items
+            const matches = (0, match_1.default)(item, indexInfo.optimizedSelector);
+            return matches;
+        };
+        const items = this.items.get(collection.name);
+        // no index available, use complete memory
+        if (!indexInfo.matched) {
+            if ((0, isEqual_1.default)(selector, {}))
+                return [...items.values()];
+            return [...items.values()].filter(matchItems);
+        }
+        const foundItems = indexInfo.ids.map(ids => items.get((0, serializeValue_1.default)(ids))).filter(i => i != null);
+        if ((0, isEqual_1.default)(indexInfo.optimizedSelector, {}))
+            return foundItems;
+        return foundItems.filter(matchItems);
+    }
+    executeQuery(collection, selector, options) {
+        const items = this.queryItems(collection, 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),
+            };
+        });
+    }
+    flushQueuedQueryUpdates(collection) {
+        if (!this.queuedQueryUpdates.get(collection.name))
+            return;
+        const changes = this.queuedQueryUpdates.get(collection.name);
+        if (!changes || !hasPendingUpdates(changes))
+            return;
+        this.queuedQueryUpdates.set(collection.name, { added: [], modified: [], removed: [] });
+        const flatItems = [...changes.added, ...changes.modified, ...changes.removed];
+        const itemIds = new Set(flatItems.map(i => i.id));
+        const queries = [
+            ...this.activeQueries.get(collection.name)?.values() ?? [],
+        ].filter(({ selector, options }) => {
+            const idsInQuery = this.cachedQueryResults.get(collection.name)
+                ?.get((0, queryId_1.default)(selector, options))
+                ?.map(i => i.id) ?? [];
+            // update queries that contained changed items previously
+            if (idsInQuery.some(id => itemIds.has(id)))
+                return true;
+            return flatItems.some(item => (0, match_1.default)(item, selector));
+        });
+        queries.forEach(({ selector, options }) => {
+            this.executeAndCacheQuery(collection, selector, options);
+        });
+    }
+    executeAndCacheQuery(collection, selector, options) {
+        const result = this.executeQuery(collection, selector, options);
+        this.cachedQueryResults.set(collection.name, this.cachedQueryResults.get(collection.name) || new Map());
+        this.cachedQueryResults.get(collection.name)?.set((0, queryId_1.default)(selector, options), result);
+        const emitter = this.queryEmitters.get(collection.name);
+        if (!emitter)
+            return;
+        emitter.emit('change', selector, options, 'complete');
+    }
+    updateQueries(collection, changes) {
+        this.queuedQueryUpdates.set(collection.name, this.queuedQueryUpdates.get(collection.name) || { added: [], modified: [], removed: [] });
+        this.queuedQueryUpdates.get(collection.name)?.added.push(...changes.added);
+        this.queuedQueryUpdates.get(collection.name)?.modified.push(...changes.modified);
+        this.queuedQueryUpdates.get(collection.name)?.removed.push(...changes.removed);
+        this.flushQueuedQueryUpdates(collection);
+    }
+    createCollectionBackend(collection, indices) {
+        this.collections.add(collection);
+        this.ensureStorageAdapter(collection.name);
+        this.items.set(collection.name, this.items.get(collection.name) ?? new Map());
+        this.queryEmitters.set(collection.name, this.queryEmitters.get(collection.name) ?? new EventEmitter_1.default());
+        // we might have many active queries
+        this.queryEmitters.get(collection.name)?.setMaxListeners(Infinity);
+        this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || new Map());
+        this.indices.set(collection.name, indices.map(field => (0, createIndex_1.default)(field)));
+        this.rebuildIndices(collection);
+        const persistenceReadyPromise = this.setupStorageAdapter(collection);
+        const backend = {
+            // CRUD operations
+            insert: async (newItem) => {
+                const items = this.items.get(collection.name);
+                if (!items)
+                    throw new Error(`Items not found for collection ${collection.name}`);
+                if (items.has((0, serializeValue_1.default)(newItem.id))) {
+                    throw new Error(`Item with id '${newItem.id}' already exists`);
+                }
+                this.items.get(collection.name)?.set((0, serializeValue_1.default)(newItem.id), newItem);
+                await this.storageAdapters.get(collection.name)?.insert([newItem]);
+                this.applyIndexDeltas(collection, { added: [newItem] });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: [newItem],
+                    removed: [],
+                });
+                return newItem;
+            },
+            updateOne: async (selector, modifier) => {
+                const { $setOnInsert, ...restModifier } = modifier;
+                const item = this.getItem(collection, selector);
+                if (item == null)
+                    return []; // no item found
+                const modifiedItem = (0, modify_1.default)((0, deepClone_1.default)(item), restModifier);
+                const hasItemWithSameId = item.id !== modifiedItem.id
+                    && this.getItem(collection, { id: modifiedItem.id }) != null;
+                if (hasItemWithSameId) {
+                    throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+                }
+                this.items.get(collection.name)?.set((0, serializeValue_1.default)(modifiedItem.id), modifiedItem);
+                await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
+                this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: [modifiedItem],
+                    removed: [],
+                });
+                return [modifiedItem];
+            },
+            updateMany: async (selector, modifier) => {
+                const { $setOnInsert, ...restModifier } = modifier;
+                const items = this.executeQuery(collection, selector, {});
+                const changedItems = items.map((item) => {
+                    const modifiedItem = (0, modify_1.default)((0, deepClone_1.default)(item), restModifier);
+                    const hasItemWithSameId = item.id !== modifiedItem.id
+                        && this.getItem(collection, { id: modifiedItem.id }) != null;
+                    if (hasItemWithSameId) {
+                        throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+                    }
+                    return modifiedItem;
+                });
+                changedItems.forEach((item) => {
+                    this.items.get(collection.name)?.set((0, serializeValue_1.default)(item.id), item);
+                });
+                await this.storageAdapters.get(collection.name)?.replace(changedItems);
+                const pairs = items.map((oldItem, index) => ({ oldItem, newItem: changedItems[index] }));
+                this.applyIndexDeltas(collection, { modified: pairs });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: changedItems,
+                    removed: [],
+                });
+                return changedItems;
+            },
+            replaceOne: async (selector, replacement) => {
+                const item = this.getItem(collection, selector);
+                if (item == null)
+                    return []; // no item found
+                const hasItemWithSameId = item.id !== replacement.id
+                    && replacement.id != null
+                    && this.getItem(collection, { id: replacement.id }) != null;
+                if (hasItemWithSameId) {
+                    throw new Error(`Item with id '${replacement.id}' already exists`);
+                }
+                const modifiedItem = { id: item.id, ...replacement };
+                this.items.get(collection.name)?.set((0, serializeValue_1.default)(modifiedItem.id), modifiedItem);
+                await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
+                this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: [modifiedItem],
+                    removed: [],
+                });
+                return [modifiedItem];
+            },
+            removeOne: async (selector) => {
+                const item = this.getItem(collection, selector);
+                if (item == null)
+                    return []; // no item found
+                this.items.get(collection.name)?.delete((0, serializeValue_1.default)(item.id));
+                await this.storageAdapters.get(collection.name)?.remove([item]);
+                this.applyIndexDeltas(collection, { removed: [item] });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: [],
+                    removed: [item],
+                });
+                return [item];
+            },
+            removeMany: async (selector) => {
+                const items = backend.getQueryResult(selector, {});
+                items.forEach((item) => {
+                    this.items.get(collection.name)?.delete((0, serializeValue_1.default)(item.id));
+                });
+                await this.storageAdapters.get(collection.name)?.remove(items);
+                this.applyIndexDeltas(collection, { removed: items });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: [],
+                    removed: items,
+                });
+                return items;
+            },
+            // methods for registering and unregistering queries that will be called from the collection during find/findOne
+            registerQuery: (selector, options) => {
+                this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || new Map());
+                this.activeQueries.get(collection.name)?.set((0, queryId_1.default)(selector, options), {
+                    selector,
+                    options,
+                });
+                this.executeAndCacheQuery(collection, selector, options);
+            },
+            unregisterQuery: (selector, options) => {
+                if (!this.activeQueries.get(collection.name))
+                    return;
+                this.activeQueries.get(collection.name)?.delete((0, queryId_1.default)(selector, options));
+            },
+            getQueryState: () => 'complete',
+            onQueryStateChange: (selector, options, callback) => {
+                const emitter = this.queryEmitters.get(collection.name);
+                if (!emitter)
+                    throw new Error(`Query emitter not found for collection ${collection.name}`);
+                const handler = (querySelector, queryOptions, state) => {
+                    if ((0, queryId_1.default)(querySelector, queryOptions) !== (0, queryId_1.default)(selector, options))
+                        return;
+                    callback(state);
+                };
+                emitter.on('change', handler);
+                return () => {
+                    emitter.off('change', handler);
+                };
+            },
+            getQueryError: () => null,
+            getQueryResult: (selector, options) => {
+                const isQueryActive = this.activeQueries.get(collection.name)
+                    ?.has((0, queryId_1.default)(selector, options));
+                if (isQueryActive) {
+                    const results = this.cachedQueryResults
+                        .get(collection.name)
+                        ?.get((0, queryId_1.default)(selector, options));
+                    if (!results)
+                        throw new Error('Cached query results are not defined!');
+                    return results;
+                }
+                return this.executeQuery(collection, selector, options);
+            },
+            executeQuery: (selector, options) => Promise.resolve(this.executeQuery(collection, selector, options)),
+            // lifecycle methods
+            dispose: async () => {
+                const adapter = this.storageAdapters.get(collection.name);
+                if (adapter?.teardown)
+                    await adapter.teardown();
+                this.storageAdapters.delete(collection.name);
+                this.items.delete(collection.name);
+                this.indices.delete(collection.name);
+                this.activeQueries.delete(collection.name);
+                this.queryEmitters.delete(collection.name);
+                this.queuedQueryUpdates.delete(collection.name);
+                this.cachedQueryResults.delete(collection.name);
+            },
+            isReady: () => persistenceReadyPromise,
+        };
+        return backend;
+    }
+    async fetchItemsFromStorage(collection) {
+        if (!collection) {
+            await Promise.all([...this.collections]
+                .map(currentCollection => this.fetchItemsFromStorage(currentCollection)));
+            return;
+        }
+        const storageAdapter = this.storageAdapters.get(collection.name);
+        if (!storageAdapter)
+            return; // no persistence adapter available
+        const items = await storageAdapter.readAll();
+        this.items.set(collection.name, items.reduce((map, item) => {
+            map.set((0, serializeValue_1.default)(item.id), item);
+            return map;
+        }, new Map()));
+        this.rebuildIndices(collection);
+    }
+}
+exports.default = DefaultDataAdapter;

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

@@ -0,0 +1,31 @@
+import type { BaseItem } from './Collection';
+import type Collection from './Collection';
+import type DataAdapter from './DataAdapter';
+import type { CollectionBackend } from './DataAdapter';
+interface WorkerDataAdapterOptions {
+    id?: string;
+    log?: (message: string, ...args: any[]) => void;
+}
+export interface WorkerDataAdapterEndpoint {
+    addEventListener: (type: 'message', listener: (event: MessageEvent) => void) => void;
+    removeEventListener: (type: 'message', listener: (event: MessageEvent) => void) => void;
+    postMessage: (message: unknown) => void;
+    terminate?: () => void;
+}
+export default class WorkerDataAdapter implements DataAdapter {
+    private worker;
+    private options;
+    private id;
+    private isDisposed;
+    private workerReady;
+    private log;
+    private collectionReady;
+    private batchExecutionHelpers;
+    private queries;
+    constructor(worker: WorkerDataAdapterEndpoint, options: WorkerDataAdapterOptions);
+    private exec;
+    private enqueueBatched;
+    private updateQuery;
+    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
+}
+export {};