@signaldb/core 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/index26.mjs

@@ -1,30 +1,38 @@
-import isFieldExpression from "./index30.mjs";
-import serializeValue from "./index11.mjs";
-function getMatchingKeys(field, selector) {
-  const result = { include: null, exclude: null };
-  const fieldSelector = selector[field];
-  if (fieldSelector instanceof RegExp)
-    return result;
-  if (fieldSelector == null)
-    return result;
-  if (isFieldExpression(fieldSelector)) {
-    if (fieldSelector.$ne != null) {
-      result.exclude = [serializeValue(fieldSelector.$ne)];
-      return result;
-    }
-    if (Array.isArray(fieldSelector.$in) && fieldSelector.$in.length > 0) {
-      result.include = fieldSelector.$in.map(serializeValue);
-      return result;
-    }
-    if (Array.isArray(fieldSelector.$nin) && fieldSelector.$nin.length > 0) {
-      result.exclude = fieldSelector.$nin.map(serializeValue);
-      return result;
-    }
-    return { include: null, exclude: null };
-  }
-  result.include = [serializeValue(fieldSelector)];
-  return result;
+//#region src/utils/queryId.ts
+/**
+* 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 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;
 }
-export {
-  getMatchingKeys as default
-};
+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 { queryId as default };

package/dist/index27.cjs.js

@@ -0,0 +1,42 @@
+const require_isFieldExpression = require("./index12.cjs.js");
+//#region src/utils/idIndexQuery.ts
+/**
+* Resolves a selector on `id` into the ids it names, without consulting an index.
+*
+* `id` is the one field every storage adapter can look up directly — that is what
+* `readIds` is — so a query on it never needs an index to be declared and never
+* needs the whole collection to be read. This behaves like an index provider that
+* happens to need no stored index, because the ids are already in the selector.
+*
+* Only inclusive forms can be answered this way. `$ne`/`$nin` describe everything
+* except* something, which cannot be enumerated without knowing every id, so they
+* report no match and take the ordinary path.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param selector - The flat selector to resolve.
+* @returns An index result naming the matched ids, or `{ matched: false }`.
+*/
+function idIndexQuery(selector) {
+	if (selector == null || !Object.hasOwnProperty.call(selector, "id")) return { matched: false };
+	const fieldSelector = selector.id;
+	if (fieldSelector == null || fieldSelector instanceof RegExp) return { matched: false };
+	if (require_isFieldExpression.default(fieldSelector)) {
+		const values = fieldSelector.$in;
+		if (!Array.isArray(values) || values.length <= 0) return { matched: false };
+		return {
+			matched: true,
+			ids: values,
+			fields: ["id"],
+			keepSelector: false
+		};
+	}
+	if (typeof fieldSelector === "object") return { matched: false };
+	return {
+		matched: true,
+		ids: [fieldSelector],
+		fields: ["id"],
+		keepSelector: false
+	};
+}
+//#endregion
+exports.default = idIndexQuery;

package/dist/index27.mjs

@@ -1,47 +1,42 @@
-function batchOnNextTick(onFlush) {
-  const queues = /* @__PURE__ */ new Map();
-  function enqueue(key, args) {
-    return new Promise((resolve, reject) => {
-      let q = queues.get(key);
-      if (!q) {
-        q = {
-          timer: null,
-          items: [],
-          flush: () => flush(key)
-        };
-        queues.set(key, q);
-      }
-      q.items.push({ args, resolve, reject });
-      if (q.timer == null) {
-        q.timer = setTimeout(() => {
-          q.timer = null;
-          void q.flush();
-        }, 0);
-      }
-    });
-  }
-  async function flush(key) {
-    const q = queues.get(key);
-    if (!q || q.items.length === 0)
-      return;
-    if (q.timer != null) {
-      clearTimeout(q.timer);
-      q.timer = null;
-    }
-    const items = q.items.splice(0);
-    onFlush(key, items.map((i) => i.args)).then((results) => {
-      for (const [index, result] of results.entries()) {
-        const { resolve } = items[index];
-        resolve(result);
-      }
-    }).catch((error) => {
-      for (const { reject } of items) {
-        reject(error);
-      }
-    });
-  }
-  return { enqueue, flush };
+import isFieldExpression from "./index12.mjs";
+//#region src/utils/idIndexQuery.ts
+/**
+* Resolves a selector on `id` into the ids it names, without consulting an index.
+*
+* `id` is the one field every storage adapter can look up directly — that is what
+* `readIds` is — so a query on it never needs an index to be declared and never
+* needs the whole collection to be read. This behaves like an index provider that
+* happens to need no stored index, because the ids are already in the selector.
+*
+* Only inclusive forms can be answered this way. `$ne`/`$nin` describe everything
+* except* something, which cannot be enumerated without knowing every id, so they
+* report no match and take the ordinary path.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param selector - The flat selector to resolve.
+* @returns An index result naming the matched ids, or `{ matched: false }`.
+*/
+function idIndexQuery(selector) {
+	if (selector == null || !Object.hasOwnProperty.call(selector, "id")) return { matched: false };
+	const fieldSelector = selector.id;
+	if (fieldSelector == null || fieldSelector instanceof RegExp) return { matched: false };
+	if (isFieldExpression(fieldSelector)) {
+		const values = fieldSelector.$in;
+		if (!Array.isArray(values) || values.length <= 0) return { matched: false };
+		return {
+			matched: true,
+			ids: values,
+			fields: ["id"],
+			keepSelector: false
+		};
+	}
+	if (typeof fieldSelector === "object") return { matched: false };
+	return {
+		matched: true,
+		ids: [fieldSelector],
+		fields: ["id"],
+		keepSelector: false
+	};
 }
-export {
-  batchOnNextTick as default
-};
+//#endregion
+export { idIndexQuery as default };

package/dist/index28.cjs.js

@@ -0,0 +1,347 @@
+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");
+const require_idIndexQuery = require("./index27.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) {
+			const idResult = require_idIndexQuery.default(selector);
+			if (idResult.matched) return {
+				matched: true,
+				ids: idResult.ids.map((id) => require_serializeValue.default(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 = DefaultDataAdapter;