@signaldb/core 2.0.0-beta.13 → 2.0.0-beta.14

package/dist/index26.cjs.js

@@ -1,11 +1,38 @@
-//#region src/createStorageAdapter.ts
+//#region src/utils/queryId.ts
 /**
-* Creates an StorageAdapter based on the given definition.
-* @param definition - The definition of the StorageAdapter.
-* @returns The created StorageAdapter.
+* Returns true when `options` is effectively "empty" for the purpose of queryId generation.
+* Treats `undefined`/`null` as empty, and only considers plain objects with zero own enumerable keys as empty.
+* Arrays and non-object values are not considered empty.
+* @param options - Query options to test.
+* @returns `true` if `options` is `null`/`undefined` or a plain object with no own keys; otherwise `false`.
 */
-function createStorageAdapter(definition) {
-	return definition;
+function isEmptyOptions(options) {
+	if (options == null) return true;
+	if (typeof options !== "object") return false;
+	if (Array.isArray(options)) return false;
+	return Object.keys(options).length === 0;
+}
+var noOptions = {};
+var cache = /* @__PURE__ */ new WeakMap();
+/**
+* Generates a unique identifier for a query based on its selector and options.
+* @param selector - The selector object.
+* @param options - The query options object (optional).
+* @returns A unique identifier string for the query.
+*/
+function queryId(selector, options) {
+	if (!(selector != null && typeof selector === "object" && (options == null || typeof options === "object"))) {
+		const optionsId = isEmptyOptions(options) ? -1 : JSON.stringify(options);
+		return `${JSON.stringify(selector)}:${optionsId}`;
+	}
+	const optionsKey = options ?? noOptions;
+	const cachedForSelector = cache.get(selector);
+	const cached = cachedForSelector?.get(optionsKey);
+	if (cached != null) return cached;
+	const id = `${JSON.stringify(selector)}:${isEmptyOptions(options) ? -1 : JSON.stringify(options)}`;
+	if (cachedForSelector) cachedForSelector.set(optionsKey, id);
+	else cache.set(selector, new WeakMap([[optionsKey, id]]));
+	return id;
 }
 //#endregion
-exports.default = createStorageAdapter;
+exports.default = queryId;

package/dist/index26.mjs

@@ -1,11 +1,38 @@
-//#region src/createStorageAdapter.ts
+//#region src/utils/queryId.ts
 /**
-* Creates an StorageAdapter based on the given definition.
-* @param definition - The definition of the StorageAdapter.
-* @returns The created StorageAdapter.
+* Returns true when `options` is effectively "empty" for the purpose of queryId generation.
+* Treats `undefined`/`null` as empty, and only considers plain objects with zero own enumerable keys as empty.
+* Arrays and non-object values are not considered empty.
+* @param options - Query options to test.
+* @returns `true` if `options` is `null`/`undefined` or a plain object with no own keys; otherwise `false`.
 */
-function createStorageAdapter(definition) {
-	return definition;
+function isEmptyOptions(options) {
+	if (options == null) return true;
+	if (typeof options !== "object") return false;
+	if (Array.isArray(options)) return false;
+	return Object.keys(options).length === 0;
+}
+var noOptions = {};
+var cache = /* @__PURE__ */ new WeakMap();
+/**
+* Generates a unique identifier for a query based on its selector and options.
+* @param selector - The selector object.
+* @param options - The query options object (optional).
+* @returns A unique identifier string for the query.
+*/
+function queryId(selector, options) {
+	if (!(selector != null && typeof selector === "object" && (options == null || typeof options === "object"))) {
+		const optionsId = isEmptyOptions(options) ? -1 : JSON.stringify(options);
+		return `${JSON.stringify(selector)}:${optionsId}`;
+	}
+	const optionsKey = options ?? noOptions;
+	const cachedForSelector = cache.get(selector);
+	const cached = cachedForSelector?.get(optionsKey);
+	if (cached != null) return cached;
+	const id = `${JSON.stringify(selector)}:${isEmptyOptions(options) ? -1 : JSON.stringify(options)}`;
+	if (cachedForSelector) cachedForSelector.set(optionsKey, id);
+	else cache.set(selector, new WeakMap([[optionsKey, id]]));
+	return id;
 }
 //#endregion
-export { createStorageAdapter as default };
+export { queryId as default };

package/dist/index27.cjs.js

@@ -1,11 +1,343 @@
-//#region src/createReactivityAdapter.ts
+const require_isEqual = require("./index2.cjs.js");
+const require_queryDelta = require("./index4.cjs.js");
+const require_EventEmitter = require("./index7.cjs.js");
+const require_serializeValue = require("./index13.cjs.js");
+const require_createIndex = require("./index15.cjs.js");
+const require_getIndexInfo = require("./index17.cjs.js");
+const require_deepClone = require("./index18.cjs.js");
+const require_match = require("./index19.cjs.js");
+const require_modify = require("./index20.cjs.js");
+const require_projectItems = require("./index23.cjs.js");
+const require_sortItems = require("./index24.cjs.js");
+const require_incrementalQueryUpdate = require("./index25.cjs.js");
+const require_queryId = require("./index26.cjs.js");
+//#region src/DefaultDataAdapter.ts
 /**
-* Creates an ReactivityAdapter based on the given definition.
-* @param definition - The definition of the ReactivityAdapter.
-* @returns The created ReactivityAdapter.
+* 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 createReactivityAdapter(definition) {
-	return definition;
+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;
+		return require_projectItems.default(limit ? skipped.slice(0, limit) : skipped, 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 changeset = {
+			upserts: [...changes.added, ...changes.modified],
+			deletes: changes.removed.map((item) => item.id)
+		};
+		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, changeset);
+		});
+	}
+	executeAndCacheQuery(collection, selector, options, changes) {
+		const cached = this.cachedQueryResults.get(collection.name)?.get(require_queryId.default(selector, options));
+		const result = (changes && cached ? require_incrementalQueryUpdate.default(cached, selector, options, changes) : null) ?? this.executeQuery(collection, selector, options);
+		const delta = cached ? require_queryDelta.diffQueryResults(cached, result) : void 0;
+		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;
+		if (delta && require_queryDelta.isEmptyQueryDelta(delta)) return;
+		emitter.emit("change", selector, options, "complete", delta);
+	}
+	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, delta) => {
+					if (require_queryId.default(querySelector, queryOptions) !== require_queryId.default(selector, options)) return;
+					require_queryDelta.callWithDelta(callback, state, delta);
+				};
+				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 = createReactivityAdapter;
+exports.default = DefaultDataAdapter;