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

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

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const queryId_1 = __importDefault(require("./utils/queryId"));
+const randomId_1 = __importDefault(require("./utils/randomId"));
+const batchOnNextTick_1 = __importDefault(require("./utils/batchOnNextTick"));
+class WorkerDataAdapter {
+    worker;
+    options;
+    id;
+    isDisposed = false;
+    workerReady;
+    log = () => { };
+    collectionReady = new Map();
+    batchExecutionHelpers = new Map();
+    queries = {};
+    constructor(worker, options) {
+        this.worker = worker;
+        this.options = options;
+        this.id = this.options.id || 'default-worker-data-adapter';
+        if (this.options.log)
+            this.log = this.options.log;
+        this.workerReady = new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error('WorkerDataAdapter initialization timed out'));
+            }, 5000);
+            const handleMessage = (event) => {
+                const { type, workerId } = event.data;
+                if (workerId !== this.id)
+                    return;
+                if (type === 'ready') {
+                    resolve();
+                    clearTimeout(timeoutId);
+                    this.worker.removeEventListener('message', handleMessage);
+                }
+            };
+            this.worker.addEventListener('message', handleMessage);
+        });
+    }
+    async exec(method, collectionName, ...args) {
+        await this.workerReady;
+        if (method !== 'isReady') {
+            const collectionReady = this.collectionReady.get(collectionName);
+            if (!collectionReady)
+                throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
+            await collectionReady;
+        }
+        if (this.isDisposed) {
+            throw new Error('WorkerDataAdapter is disposed');
+        }
+        return new Promise((resolve, reject) => {
+            const messageId = (0, randomId_1.default)();
+            const handleMessage = (event) => {
+                const { id, workerId, type, data, error } = event.data;
+                if (workerId !== this.id)
+                    return;
+                if (type !== 'response')
+                    return;
+                if (id !== messageId)
+                    return;
+                this.log(method, 'result', data ?? error);
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(data);
+                }
+                this.worker.removeEventListener('message', handleMessage);
+            };
+            this.worker.addEventListener('message', handleMessage);
+            this.worker.postMessage({
+                id: messageId,
+                workerId: this.id,
+                method,
+                args: [collectionName, ...args],
+            });
+        });
+    }
+    enqueueBatched(collectionName, method, args) {
+        const helper = this.batchExecutionHelpers.get(collectionName);
+        if (!helper)
+            throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
+        return helper.enqueue(method, args);
+    }
+    // ---------- end batching integration ----------
+    updateQuery(collectionName, query, update) {
+        const id = (0, queryId_1.default)(query.selector, query.options);
+        const collectionQueries = this.queries[collectionName];
+        if (!collectionQueries)
+            return;
+        const existing = collectionQueries.get(id);
+        const newState = {
+            state: 'active',
+            error: null,
+            items: [],
+            stateChangeCallbacks: [],
+            eventHandler: existing?.eventHandler,
+            ...existing,
+            ...update,
+        };
+        collectionQueries.set(id, newState);
+        this.queries[collectionName] = collectionQueries;
+    }
+    createCollectionBackend(collection, indices) {
+        this.queries[collection.name] = new Map();
+        void this.exec('registerCollection', collection.name, indices);
+        this.collectionReady.set(collection.name, this.exec('isReady', collection.name));
+        this.batchExecutionHelpers.set(collection.name, (0, batchOnNextTick_1.default)(async (method, args) => this.exec(method, collection.name, args)));
+        return {
+            insert: async (item) => {
+                return this.enqueueBatched(collection.name, 'insert', [item]);
+            },
+            updateOne: async (selector, modifier) => {
+                return this.enqueueBatched(collection.name, 'updateOne', [selector, modifier]);
+            },
+            updateMany: async (selector, modifier) => {
+                return this.enqueueBatched(collection.name, 'updateMany', [selector, modifier]);
+            },
+            replaceOne: async (selector, replacement) => {
+                return this.enqueueBatched(collection.name, 'replaceOne', [selector, replacement]);
+            },
+            removeOne: async (selector) => {
+                return this.enqueueBatched(collection.name, 'removeOne', [selector]);
+            },
+            removeMany: async (selector) => {
+                return this.enqueueBatched(collection.name, 'removeMany', [selector]);
+            },
+            // methods for registering and unregistering queries that will be called from the collection during find/findOne
+            registerQuery: (selector, options) => {
+                this.updateQuery(collection.name, { selector, options }, { state: 'active', error: null, items: [] });
+                void this.exec('registerQuery', collection.name, selector, options);
+                const handler = (event) => {
+                    const { type, data, workerId, error } = event.data;
+                    if (type !== 'queryUpdate')
+                        return;
+                    if (data == null)
+                        return;
+                    const { collectionName, selector: responseSelector, options: responseOptions, state, items, } = data;
+                    if (workerId !== this.id)
+                        return;
+                    if (collectionName !== collection.name)
+                        return;
+                    if ((0, queryId_1.default)(responseSelector, responseOptions) !== (0, queryId_1.default)(selector, options))
+                        return;
+                    this.log('queryUpdate', responseSelector, responseOptions, state, data ?? error);
+                    this.updateQuery(collection.name, {
+                        selector: responseSelector,
+                        options: responseOptions,
+                    }, { state, error, items });
+                    const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
+                    if (!query)
+                        return;
+                    query.stateChangeCallbacks.forEach(callback => callback(state));
+                };
+                this.worker.addEventListener('message', handler);
+                this.updateQuery(collection.name, { selector, options }, { eventHandler: handler });
+            },
+            unregisterQuery: (selector, options) => {
+                const qid = (0, queryId_1.default)(selector, options);
+                const query = this.queries[collection.name]?.get(qid);
+                if (query?.eventHandler) {
+                    this.worker.removeEventListener('message', query.eventHandler);
+                }
+                this.queries[collection.name]?.delete(qid);
+                void this.exec('unregisterQuery', collection.name, selector, options);
+            },
+            getQueryState: (selector, options) => {
+                const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
+                return query?.state || 'active';
+            },
+            getQueryError: (selector, options) => {
+                const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
+                return query?.error || null;
+            },
+            getQueryResult: (selector, options) => {
+                const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
+                return query?.items || [];
+            },
+            onQueryStateChange: (selector, options, callback) => {
+                this.updateQuery(collection.name, { selector, options }, {
+                    stateChangeCallbacks: [
+                        ...this.queries[collection.name]?.get((0, queryId_1.default)(selector, options))?.stateChangeCallbacks || [],
+                        callback,
+                    ],
+                });
+                return () => {
+                    const currentCallbacks = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options))?.stateChangeCallbacks;
+                    if (!currentCallbacks)
+                        throw new Error('State change callbacks are not defined!');
+                    this.updateQuery(collection.name, { selector, options }, {
+                        stateChangeCallbacks: currentCallbacks
+                            .filter(existingCallback => existingCallback !== callback),
+                    });
+                };
+            },
+            executeQuery: (selector, options) => this.exec('executeQuery', collection.name, selector, options),
+            // lifecycle methods
+            dispose: async () => {
+                await this.exec('unregisterCollection', collection.name);
+                this.isDisposed = true;
+                this.worker.terminate();
+            },
+            isReady: async () => {
+                await this.exec('isReady', collection.name);
+            },
+        };
+    }
+}
+exports.default = WorkerDataAdapter;

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

@@ -0,0 +1,62 @@
+import type { BaseItem } from './Collection';
+import type { QueryOptions } from './DataAdapter';
+import type Modifier from './types/Modifier';
+import type StorageAdapter from './types/StorageAdapter';
+import type Selector from './types/Selector';
+interface WorkerContext {
+    addEventListener: (type: 'message', listener: (event: MessageEvent) => any) => void;
+    postMessage: (message: any) => void;
+}
+interface WorkerDataAdapterHostOptions {
+    id?: string;
+    storage: (name: string) => StorageAdapter<any, any>;
+    onError?: (error: Error) => void;
+    log?: (message: string, ...args: any[]) => void;
+}
+type CollectionMethods<T extends BaseItem<I>, I = any> = {
+    registerCollection: (collectionName: string, indices: string[]) => Promise<void>;
+    unregisterCollection: (collectionName: string) => Promise<void>;
+    registerQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<void>;
+    unregisterQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<void>;
+    executeQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<T[]>;
+    insert: (collectionName: string, items: [T][]) => Promise<(T | Error)[]>;
+    updateOne: (collectionName: string, args: [Selector<T>, Modifier<T>][]) => Promise<(T[] | Error)[]>;
+    updateMany: (collectionName: string, args: [Selector<T>, Modifier<T>][]) => Promise<(T[] | Error)[]>;
+    replaceOne: (collectionName: string, args: [Selector<T>, Omit<T, 'id'> & Partial<Pick<T, 'id'>>][]) => Promise<(T[] | Error)[]>;
+    removeOne: (collectionName: string, selectors: [Selector<T>][]) => Promise<(T[] | Error)[]>;
+    removeMany: (collectionName: string, selectors: [Selector<T>][]) => Promise<(T[] | Error)[]>;
+    isReady: (collectionName: string) => Promise<void>;
+};
+export default class WorkerDataAdapterHost<T extends BaseItem<I>, I = any> {
+    private workerContext;
+    private options;
+    private id;
+    private log;
+    private storageAdapters;
+    private storageAdapterReady;
+    private collectionIndices;
+    private queries;
+    private onError;
+    constructor(workerContext: WorkerContext, options: WorkerDataAdapterHostOptions);
+    private respond;
+    private handleMessage;
+    private getIndexInfo;
+    private queryItems;
+    private executeQuery;
+    private ensureQuery;
+    private emitQueryUpdate;
+    private ensureStorageAdapter;
+    private checkQueryUpdates;
+    protected registerCollection: CollectionMethods<T, I>['registerCollection'];
+    protected unregisterCollection: CollectionMethods<T, I>['unregisterCollection'];
+    protected registerQuery: CollectionMethods<T, I>['registerQuery'];
+    protected unregisterQuery: CollectionMethods<T, I>['unregisterQuery'];
+    protected insert: CollectionMethods<T, I>['insert'];
+    protected updateOne: CollectionMethods<T, I>['updateOne'];
+    protected updateMany: CollectionMethods<T, I>['updateMany'];
+    protected replaceOne: CollectionMethods<T, I>['replaceOne'];
+    protected removeOne: CollectionMethods<T, I>['removeOne'];
+    protected removeMany: CollectionMethods<T, I>['removeMany'];
+    protected isReady: CollectionMethods<T, I>['isReady'];
+}
+export {};

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

@@ -0,0 +1,409 @@
+"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"));
+const compact_1 = __importDefault(require("./utils/compact"));
+class WorkerDataAdapterHost {
+    workerContext;
+    options;
+    id;
+    log = () => { };
+    storageAdapters = new Map();
+    storageAdapterReady = new Map();
+    collectionIndices = new Map();
+    queries = new Map();
+    onError = (error) => {
+        // eslint-disable-next-line no-console
+        console.error(error);
+    };
+    constructor(workerContext, options) {
+        this.workerContext = workerContext;
+        this.options = options;
+        this.id = this.options.id || 'default-worker-data-adapter';
+        if (this.options.onError) {
+            this.onError = this.options.onError;
+        }
+        if (this.options.log)
+            this.log = this.options.log;
+        if (typeof addEventListener === 'undefined' || typeof postMessage === 'undefined') {
+            throw new TypeError('WorkerDataAdapterHost can only be used in a Web Worker context');
+        }
+        this.workerContext.addEventListener('message', async (event) => {
+            try {
+                const { workerId, id, method, args } = event.data;
+                await this.handleMessage(workerId, id, method, args);
+            }
+            catch (error) {
+                this.onError(error);
+            }
+        });
+        this.respond('ready', null, null, 'ready');
+    }
+    respond(id, data, error = null, type = 'response') {
+        this.workerContext.postMessage({ id, workerId: this.id, type, data, error });
+    }
+    async handleMessage(workerId, id, method, args) {
+        if (workerId !== this.id)
+            return;
+        const fn = this[method];
+        if (typeof fn !== 'function') {
+            this.respond(id, null, new Error(`Method ${method} not found`));
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        this.log(method, ...args);
+        // wait for the storage adapter to be ready
+        await this.isReady(args[0]);
+        try {
+            const result = await fn.apply(this, args);
+            this.respond(id, result);
+        }
+        catch (error) {
+            this.respond(id, null, error);
+        }
+    }
+    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: (0, compact_1.default)([selector.id]),
+                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)) {
+                // If the field is not present in the selector, we can't optimize
+                return { matched: false };
+            }
+            const index = await storageAdapter.readIndex(field);
+            const fieldSelector = flatSelector[field];
+            const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
+            const keys = filteresForNull
+                ? { 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 };
+            // Accumulate included positions
+            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);
+                        }
+                    }
+                }
+            }
+            // If exclusion is specified, build a single set of all positions to exclude.
+            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);
+                        }
+                    }
+                }
+                // Filter out any position that exists in the exclude set.
+                includedIds = includedIds.filter(pos => !excludeIds.has(pos));
+            }
+            return {
+                matched: true,
+                ids: includedIds,
+                fields: [field],
+                keepSelector: filteresForNull,
+            };
+        }), selector);
+    }
+    async queryItems(collectionName, selector) {
+        const storageAdapter = this.storageAdapters.get(collectionName);
+        if (!storageAdapter)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const indexInfo = await this.getIndexInfo(collectionName, 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;
+        };
+        if (indexInfo.matched) {
+            const items = await storageAdapter.readIds(indexInfo.ids);
+            if ((0, isEqual_1.default)(indexInfo.optimizedSelector, {}))
+                return items;
+            return items.filter(matchItems);
+        }
+        else {
+            const allItems = await storageAdapter.readAll();
+            if ((0, isEqual_1.default)(selector, {}))
+                return allItems;
+            return allItems.filter(matchItems);
+        }
+    }
+    async executeQuery(collectionName, selector, options) {
+        // null selector means no matches
+        if (selector === null)
+            return [];
+        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),
+            };
+        });
+    }
+    ensureQuery(collectionName, selector, options) {
+        const id = (0, queryId_1.default)(selector, options);
+        if (!this.queries.get(collectionName)) {
+            throw new Error(`Collection ${collectionName} not initialized!`);
+        }
+        let query = this.queries.get(collectionName)?.get(id);
+        if (!query) {
+            query = { selector, options };
+            this.queries.get(collectionName)?.set(id, query);
+        }
+        return query;
+    }
+    emitQueryUpdate(collectionName, selector, options, state, error, items) {
+        const id = (0, queryId_1.default)(selector, options);
+        const collectionQueries = this.queries.get(collectionName);
+        if (!collectionQueries)
+            throw new Error(`Collection ${collectionName} not initialized!`);
+        this.respond(id, { collectionName, selector, options, state, error, items }, null, 'queryUpdate');
+    }
+    ensureStorageAdapter(name) {
+        if (this.storageAdapters.has(name))
+            return; // already created
+        const adapter = this.options.storage(name);
+        if (!adapter)
+            return; // no adapter returned
+        this.storageAdapters.set(name, adapter);
+    }
+    async checkQueryUpdates(collectionName, items) {
+        const queries = this.queries.get(collectionName);
+        if (!queries)
+            throw new Error(`Collection ${collectionName} not initialized!`);
+        const affectedQueries = [...queries.values()].filter(({ selector }) => items.some(item => (0, match_1.default)(item, selector))) ?? [];
+        if (affectedQueries.length === 0)
+            return; // no active queries affected
+        affectedQueries.forEach(({ selector, options }) => {
+            this.emitQueryUpdate(collectionName, selector, options, 'active', null);
+        });
+        await Promise.all(affectedQueries.map(async ({ selector, options }) => {
+            const queryItems = await this.executeQuery(collectionName, selector, options);
+            this.emitQueryUpdate(collectionName, selector, options, 'complete', null, queryItems);
+        }));
+    }
+    registerCollection = async (collectionName, indices) => {
+        this.collectionIndices.set(collectionName, indices);
+        this.queries.set(collectionName, new Map());
+        this.ensureStorageAdapter(collectionName);
+        const storageAdapter = this.storageAdapters.get(collectionName);
+        if (!storageAdapter)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const setupPromise = (async () => {
+            await storageAdapter.setup();
+            await Promise.all(indices.map(index => storageAdapter.createIndex(index)));
+        })();
+        this.storageAdapterReady.set(collectionName, setupPromise);
+        await setupPromise;
+    };
+    unregisterCollection = async (collectionName) => {
+        this.storageAdapters.delete(collectionName);
+        this.queries.delete(collectionName);
+    };
+    registerQuery = async (collectionName, selector, options) => {
+        this.ensureQuery(collectionName, selector, options);
+        const queryItems = await this.executeQuery(collectionName, selector, options);
+        this.emitQueryUpdate(collectionName, selector, options, 'complete', null, queryItems);
+    };
+    unregisterQuery = async (collectionName, selector, options) => {
+        const id = (0, queryId_1.default)(selector, options);
+        if (!this.queries.get(collectionName))
+            throw new Error(`Collection ${collectionName} not initialized!`);
+        this.queries.get(collectionName)?.delete(id);
+    };
+    insert = async (collectionName, input) => {
+        const storageAdapter = this.storageAdapters.get(collectionName);
+        if (!storageAdapter)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const existingItems = await this.executeQuery(collectionName, { id: { $in: input.map(i => i[0].id) } });
+        const result = input.map(([item]) => {
+            if (item.id == null)
+                return new Error('Item must have an id');
+            if (existingItems.some(existing => existing.id === item.id)) {
+                return new Error(`Item with id ${item.id} already exists`);
+            }
+            return item;
+        });
+        const newItems = result.filter(item => !(item instanceof Error));
+        await storageAdapter.insert(newItems);
+        await this.checkQueryUpdates(collectionName, newItems);
+        return result;
+    };
+    updateOne = async (collectionName, parameters) => {
+        const storageAdapter = this.storageAdapters.get(collectionName);
+        if (!storageAdapter)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const previousItems = [];
+        const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
+            const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then(items => items[0] ?? null);
+            const { $setOnInsert, ...restModifier } = modifier;
+            if (item == null)
+                return [];
+            previousItems.push(item);
+            const modifiedItem = (0, modify_1.default)((0, deepClone_1.default)(item), restModifier);
+            if (item.id !== modifiedItem.id) {
+                const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
+                if (existingItems.length > 0) {
+                    return new Error(`Item with id ${modifiedItem.id} already exists`);
+                }
+            }
+            return [modifiedItem];
+        }));
+        const modifiedItems = (0, compact_1.default)(result.filter(item => !(item instanceof Error)).flat());
+        if (modifiedItems.length > 0) {
+            await storageAdapter.replace(modifiedItems);
+            await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+        }
+        return result;
+    };
+    updateMany = async (collectionName, parameters) => {
+        const storageAdapter = this.storageAdapters.get(collectionName);
+        if (!storageAdapter)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const previousItems = [];
+        const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
+            const items = await this.executeQuery(collectionName, selector);
+            if (items.length === 0)
+                return []; // no items found, nothing to update
+            const { $setOnInsert, ...restModifier } = modifier;
+            try {
+                const changedItems = await Promise.all(items.map(async (item) => {
+                    const modifiedItem = (0, modify_1.default)((0, deepClone_1.default)(item), restModifier);
+                    if (item.id !== modifiedItem.id) {
+                        const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
+                        if (existingItems.length > 0) {
+                            throw new Error(`Item with id ${modifiedItem.id} already exists`);
+                        }
+                    }
+                    previousItems.push(item);
+                    return modifiedItem;
+                }));
+                return changedItems;
+            }
+            catch (error) {
+                return error;
+            }
+        }));
+        const modifiedItems = (0, compact_1.default)(result.filter(item => !(item instanceof Error)).flat());
+        if (modifiedItems.length > 0) {
+            await storageAdapter.replace(modifiedItems);
+            await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+        }
+        return result;
+    };
+    replaceOne = async (collectionName, parameters) => {
+        const storageAdapter = this.storageAdapters.get(collectionName);
+        if (!storageAdapter)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const previousItems = [];
+        const result = await Promise.all(parameters.map(async ([selector, replacement,]) => {
+            const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then(items => items[0] ?? null);
+            if (item == null)
+                return []; // no item found, nothing to update
+            previousItems.push(item);
+            const modifiedItem = {
+                ...replacement,
+                id: replacement.id ?? item.id,
+            };
+            if (item.id !== modifiedItem.id) {
+                const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
+                if (existingItems.length > 0) {
+                    return new Error(`Item with id ${modifiedItem.id} already exists`);
+                }
+            }
+            return [modifiedItem];
+        }));
+        const modifiedItems = (0, compact_1.default)(result.filter(item => !(item instanceof Error)).flat());
+        if (modifiedItems.length > 0) {
+            await storageAdapter.replace(modifiedItems);
+            await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+        }
+        return result;
+    };
+    removeOne = async (collectionName, selectors) => {
+        const storageAdapter = this.storageAdapters.get(collectionName);
+        if (!storageAdapter)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const result = await Promise.all(selectors.map(async ([selector]) => {
+            const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then(items => items[0] ?? null);
+            if (item == null)
+                return []; // no item found, nothing to remove
+            return [item];
+        }));
+        const items = result.flat();
+        if (items.length > 0) {
+            await storageAdapter.remove(items);
+            await this.checkQueryUpdates(collectionName, items);
+        }
+        return result;
+    };
+    removeMany = async (collectionName, selectors) => {
+        const storageAdapter = this.storageAdapters.get(collectionName);
+        if (!storageAdapter)
+            throw new Error(`No persistence adapter for collection ${collectionName}`);
+        const result = await Promise.all(selectors.map(async ([selector]) => this.executeQuery(collectionName, selector)));
+        const items = result.flat();
+        if (items.length > 0) {
+            await storageAdapter.remove(items);
+            await this.checkQueryUpdates(collectionName, items);
+        }
+        return result;
+    };
+    isReady = async (collectionName) => {
+        return this.storageAdapterReady.get(collectionName);
+    };
+}
+exports.default = WorkerDataAdapterHost;