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

package/dist/index24.cjs.js

@@ -0,0 +1,342 @@
+const require_isEqual = require("./index2.cjs.js");
+const require_EventEmitter = require("./index6.cjs.js");
+const require_serializeValue = require("./index12.cjs.js");
+const require_createIndex = require("./index14.cjs.js");
+const require_getIndexInfo = require("./index16.cjs.js");
+const require_deepClone = require("./index17.cjs.js");
+const require_match = require("./index18.cjs.js");
+const require_modify = require("./index19.cjs.js");
+const require_project = require("./index21.cjs.js");
+const require_queryId = require("./index22.cjs.js");
+const require_sortItems = require("./index23.cjs.js");
+//#region src/DefaultDataAdapter.ts
+/**
+* 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;
+}
+var DefaultDataAdapter = class {
+	items = /* @__PURE__ */ new Map();
+	options;
+	storageAdapters = /* @__PURE__ */ new Map();
+	collections = /* @__PURE__ */ new Set();
+	indices = /* @__PURE__ */ new Map();
+	activeQueries = /* @__PURE__ */ new Map();
+	queryEmitters = /* @__PURE__ */ new Map();
+	queuedQueryUpdates = /* @__PURE__ */ new Map();
+	cachedQueryResults = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options || {};
+	}
+	ensureStorageAdapter(name) {
+		if (this.storageAdapters.get(name)) return;
+		if (!this.options.storage) return;
+		const adapter = this.options.storage(name);
+		if (!adapter) return;
+		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;
+		return storageAdapter.setup().then(async () => {
+			await this.fetchItemsFromStorage(collection);
+		}).catch((error) => {
+			if (!this.options.onError) {
+				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: [require_serializeValue.default(selector.id)],
+			optimizedSelector: {}
+		};
+		if (selector == null) return {
+			matched: false,
+			ids: [],
+			optimizedSelector: {}
+		};
+		return require_getIndexInfo.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) ?? /* @__PURE__ */ new Map();
+		const indexInfo = this.getIndexInfo(collection, selector);
+		return (indexInfo.matched ? indexInfo.ids.map((id) => memory.get(require_serializeValue.default(id))).filter((i) => i != null) : [...memory.values()]).find((document) => require_match.default(document, selector));
+	}
+	queryItems(collection, selector) {
+		const indexInfo = this.getIndexInfo(collection, selector);
+		const matchItems = (item) => {
+			if (indexInfo.optimizedSelector == null) return true;
+			if (Object.keys(indexInfo.optimizedSelector).length <= 0) return true;
+			return require_match.default(item, indexInfo.optimizedSelector);
+		};
+		const items = this.items.get(collection.name);
+		if (!indexInfo.matched) {
+			if (require_isEqual.default(selector, {})) return [...items.values()];
+			return [...items.values()].filter(matchItems);
+		}
+		const foundItems = indexInfo.ids.map((ids) => items.get(require_serializeValue.default(ids))).filter((i) => i != null);
+		if (require_isEqual.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 ? require_sortItems.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 },
+				...require_project.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));
+		[...this.activeQueries.get(collection.name)?.values() ?? []].filter(({ selector, options }) => {
+			if ((this.cachedQueryResults.get(collection.name)?.get(require_queryId.default(selector, options))?.map((i) => i.id) ?? []).some((id) => itemIds.has(id))) return true;
+			return flatItems.some((item) => require_match.default(item, selector));
+		}).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) || /* @__PURE__ */ new Map());
+		this.cachedQueryResults.get(collection.name)?.set(require_queryId.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) ?? /* @__PURE__ */ new Map());
+		this.queryEmitters.set(collection.name, this.queryEmitters.get(collection.name) ?? new require_EventEmitter.default());
+		this.queryEmitters.get(collection.name)?.setMaxListeners(Infinity);
+		this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
+		this.indices.set(collection.name, indices.map((field) => require_createIndex.default(field)));
+		this.rebuildIndices(collection);
+		const persistenceReadyPromise = this.setupStorageAdapter(collection);
+		const backend = {
+			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(require_serializeValue.default(newItem.id))) throw new Error(`Item with id '${newItem.id}' already exists`);
+				this.items.get(collection.name)?.set(require_serializeValue.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 [];
+				const modifiedItem = require_modify.default(require_deepClone.default(item), restModifier);
+				if (item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null) throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+				this.items.get(collection.name)?.set(require_serializeValue.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 = require_modify.default(require_deepClone.default(item), restModifier);
+					if (item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null) throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+					return modifiedItem;
+				});
+				changedItems.forEach((item) => {
+					this.items.get(collection.name)?.set(require_serializeValue.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 [];
+				if (item.id !== replacement.id && replacement.id != null && this.getItem(collection, { id: replacement.id }) != null) throw new Error(`Item with id '${replacement.id}' already exists`);
+				const modifiedItem = {
+					id: item.id,
+					...replacement
+				};
+				this.items.get(collection.name)?.set(require_serializeValue.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 [];
+				this.items.get(collection.name)?.delete(require_serializeValue.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(require_serializeValue.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;
+			},
+			registerQuery: (selector, options) => {
+				this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
+				this.activeQueries.get(collection.name)?.set(require_queryId.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(require_queryId.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 (require_queryId.default(querySelector, queryOptions) !== require_queryId.default(selector, options)) return;
+					callback(state);
+				};
+				emitter.on("change", handler);
+				return () => {
+					emitter.off("change", handler);
+				};
+			},
+			getQueryError: () => null,
+			getQueryResult: (selector, options) => {
+				if (this.activeQueries.get(collection.name)?.has(require_queryId.default(selector, options))) {
+					const results = this.cachedQueryResults.get(collection.name)?.get(require_queryId.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)),
+			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;
+		const items = await storageAdapter.readAll();
+		this.items.set(collection.name, items.reduce((map, item) => {
+			map.set(require_serializeValue.default(item.id), item);
+			return map;
+		}, /* @__PURE__ */ new Map()));
+		this.rebuildIndices(collection);
+	}
+};
+//#endregion
+exports.default = DefaultDataAdapter;

package/dist/index24.mjs

@@ -1,8 +1,342 @@
-import { Query } from "mingo";
-function match(item, selector) {
-  const query = new Query(selector);
-  return query.test(item);
+import isEqual from "./index2.mjs";
+import EventEmitter from "./index6.mjs";
+import serializeValue from "./index12.mjs";
+import createIndex from "./index14.mjs";
+import getIndexInfo from "./index16.mjs";
+import deepClone from "./index17.mjs";
+import match from "./index18.mjs";
+import modify from "./index19.mjs";
+import project from "./index21.mjs";
+import queryId from "./index22.mjs";
+import sortItems from "./index23.mjs";
+//#region src/DefaultDataAdapter.ts
+/**
+* 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;
 }
-export {
-  match as default
+var DefaultDataAdapter = class {
+	items = /* @__PURE__ */ new Map();
+	options;
+	storageAdapters = /* @__PURE__ */ new Map();
+	collections = /* @__PURE__ */ new Set();
+	indices = /* @__PURE__ */ new Map();
+	activeQueries = /* @__PURE__ */ new Map();
+	queryEmitters = /* @__PURE__ */ new Map();
+	queuedQueryUpdates = /* @__PURE__ */ new Map();
+	cachedQueryResults = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options || {};
+	}
+	ensureStorageAdapter(name) {
+		if (this.storageAdapters.get(name)) return;
+		if (!this.options.storage) return;
+		const adapter = this.options.storage(name);
+		if (!adapter) return;
+		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;
+		return storageAdapter.setup().then(async () => {
+			await this.fetchItemsFromStorage(collection);
+		}).catch((error) => {
+			if (!this.options.onError) {
+				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: [serializeValue(selector.id)],
+			optimizedSelector: {}
+		};
+		if (selector == null) return {
+			matched: false,
+			ids: [],
+			optimizedSelector: {}
+		};
+		return getIndexInfo((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) ?? /* @__PURE__ */ new Map();
+		const indexInfo = this.getIndexInfo(collection, selector);
+		return (indexInfo.matched ? indexInfo.ids.map((id) => memory.get(serializeValue(id))).filter((i) => i != null) : [...memory.values()]).find((document) => match(document, selector));
+	}
+	queryItems(collection, selector) {
+		const indexInfo = this.getIndexInfo(collection, selector);
+		const matchItems = (item) => {
+			if (indexInfo.optimizedSelector == null) return true;
+			if (Object.keys(indexInfo.optimizedSelector).length <= 0) return true;
+			return match(item, indexInfo.optimizedSelector);
+		};
+		const items = this.items.get(collection.name);
+		if (!indexInfo.matched) {
+			if (isEqual(selector, {})) return [...items.values()];
+			return [...items.values()].filter(matchItems);
+		}
+		const foundItems = indexInfo.ids.map((ids) => items.get(serializeValue(ids))).filter((i) => i != null);
+		if (isEqual(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 ? sortItems(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 },
+				...project(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));
+		[...this.activeQueries.get(collection.name)?.values() ?? []].filter(({ selector, options }) => {
+			if ((this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options))?.map((i) => i.id) ?? []).some((id) => itemIds.has(id))) return true;
+			return flatItems.some((item) => match(item, selector));
+		}).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) || /* @__PURE__ */ new Map());
+		this.cachedQueryResults.get(collection.name)?.set(queryId(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) ?? /* @__PURE__ */ new Map());
+		this.queryEmitters.set(collection.name, this.queryEmitters.get(collection.name) ?? new EventEmitter());
+		this.queryEmitters.get(collection.name)?.setMaxListeners(Infinity);
+		this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
+		this.indices.set(collection.name, indices.map((field) => createIndex(field)));
+		this.rebuildIndices(collection);
+		const persistenceReadyPromise = this.setupStorageAdapter(collection);
+		const backend = {
+			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(serializeValue(newItem.id))) throw new Error(`Item with id '${newItem.id}' already exists`);
+				this.items.get(collection.name)?.set(serializeValue(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 [];
+				const modifiedItem = modify(deepClone(item), restModifier);
+				if (item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null) throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+				this.items.get(collection.name)?.set(serializeValue(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 = modify(deepClone(item), restModifier);
+					if (item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null) throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+					return modifiedItem;
+				});
+				changedItems.forEach((item) => {
+					this.items.get(collection.name)?.set(serializeValue(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 [];
+				if (item.id !== replacement.id && replacement.id != null && this.getItem(collection, { id: replacement.id }) != null) throw new Error(`Item with id '${replacement.id}' already exists`);
+				const modifiedItem = {
+					id: item.id,
+					...replacement
+				};
+				this.items.get(collection.name)?.set(serializeValue(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 [];
+				this.items.get(collection.name)?.delete(serializeValue(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(serializeValue(item.id));
+				});
+				await this.storageAdapters.get(collection.name)?.remove(items);
+				this.applyIndexDeltas(collection, { removed: items });
+				this.updateQueries(collection, {
+					added: [],
+					modified: [],
+					removed: items
+				});
+				return items;
+			},
+			registerQuery: (selector, options) => {
+				this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
+				this.activeQueries.get(collection.name)?.set(queryId(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(queryId(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 (queryId(querySelector, queryOptions) !== queryId(selector, options)) return;
+					callback(state);
+				};
+				emitter.on("change", handler);
+				return () => {
+					emitter.off("change", handler);
+				};
+			},
+			getQueryError: () => null,
+			getQueryResult: (selector, options) => {
+				if (this.activeQueries.get(collection.name)?.has(queryId(selector, options))) {
+					const results = this.cachedQueryResults.get(collection.name)?.get(queryId(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)),
+			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;
+		const items = await storageAdapter.readAll();
+		this.items.set(collection.name, items.reduce((map, item) => {
+			map.set(serializeValue(item.id), item);
+			return map;
+		}, /* @__PURE__ */ new Map()));
+		this.rebuildIndices(collection);
+	}
 };
+//#endregion
+export { DefaultDataAdapter as default };