@signaldb/core 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/index22.cjs.js

@@ -0,0 +1,25 @@
+//#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;
+}
+/**
+* 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) {
+	return `${JSON.stringify(selector)}:${isEmptyOptions(options) ? -1 : JSON.stringify(options)}`;
+}
+//#endregion
+exports.default = queryId;

package/dist/index22.mjs

@@ -1,8 +1,25 @@
-import { Query } from "mingo";
-function match(item, selector) {
-  const query = new Query(selector);
-  return query.test(item);
+//#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 {
-  match as default
-};
+/**
+* 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) {
+	return `${JSON.stringify(selector)}:${isEmptyOptions(options) ? -1 : JSON.stringify(options)}`;
+}
+//#endregion
+export { queryId as default };

package/dist/index23.cjs.js

@@ -0,0 +1,19 @@
+const require_get = require("./index10.cjs.js");
+let fast_sort = require("fast-sort");
+//#region src/utils/sortItems.ts
+/**
+* Sorts an array of items based on multiple fields and their specified sort order.
+* Uses the `fast-sort` library for efficient sorting.
+* @template T - The type of the items in the array.
+* @param items - The array of items to be sorted.
+* @param sortFields - An object defining the sort order for each field.
+*   - Keys are the field names, and values are either `1` (ascending) or `-1` (descending).
+* @returns A new array of items sorted based on the specified fields and their order.
+*/
+function sortItems(items, sortFields) {
+	return (0, fast_sort.sort)(items).by(Object.entries(sortFields).map(([key, value]) => {
+		return { [value === 1 ? "asc" : "desc"]: (i) => require_get.default(i, key) };
+	}));
+}
+//#endregion
+exports.default = sortItems;

package/dist/index23.mjs

@@ -1,28 +1,19 @@
 import get from "./index10.mjs";
-import set from "./index29.mjs";
-function project(item, fields) {
-  const allFieldsDeactivated = Object.values(fields).every((value) => value === 0);
-  if (allFieldsDeactivated) {
-    const result2 = { ...item };
-    Object.keys(fields).forEach((key) => {
-      const fieldValue = get(item, key);
-      if (fieldValue === void 0)
-        return;
-      set(result2, key, void 0, true);
-    });
-    return result2;
-  }
-  const result = {};
-  Object.entries(fields).forEach(([key, value]) => {
-    const fieldValue = get(item, key);
-    if (fieldValue === void 0)
-      return;
-    if (fieldValue == null && value !== 1)
-      return;
-    set(result, key, value === 1 ? fieldValue : void 0);
-  });
-  return result;
+import { sort } from "fast-sort";
+//#region src/utils/sortItems.ts
+/**
+* Sorts an array of items based on multiple fields and their specified sort order.
+* Uses the `fast-sort` library for efficient sorting.
+* @template T - The type of the items in the array.
+* @param items - The array of items to be sorted.
+* @param sortFields - An object defining the sort order for each field.
+*   - Keys are the field names, and values are either `1` (ascending) or `-1` (descending).
+* @returns A new array of items sorted based on the specified fields and their order.
+*/
+function sortItems(items, sortFields) {
+	return sort(items).by(Object.entries(sortFields).map(([key, value]) => {
+		return { [value === 1 ? "asc" : "desc"]: (i) => get(i, key) };
+	}));
 }
-export {
-  project as default
-};
+//#endregion
+export { sortItems as default };

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;