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

package/dist/index24.mjs

@@ -1,342 +1,19 @@
-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
+import get from "./index11.mjs";
+import { sort } from "fast-sort";
+//#region src/utils/sortItems.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`.
+* 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 hasPendingUpdates(pendingUpdates) {
-	return pendingUpdates.added.length > 0 || pendingUpdates.modified.length > 0 || pendingUpdates.removed.length > 0;
+function sortItems(items, sortFields) {
+	return sort(items).by(Object.entries(sortFields).map(([key, value]) => {
+		return { [value === 1 ? "asc" : "desc"]: (i) => get(i, key) };
+	}));
 }
-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 };
+export { sortItems as default };