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

package/dist/index31.mjs

@@ -1,191 +1,32 @@
-import randomId from "./index8.mjs";
-import queryId from "./index22.mjs";
-import batchOnNextTick from "./index30.mjs";
-//#region src/WorkerDataAdapter.ts
-var WorkerDataAdapter = class {
-	worker;
-	options;
-	id;
-	isDisposed = false;
-	workerReady;
-	log = () => {};
-	collectionReady = /* @__PURE__ */ new Map();
-	batchExecutionHelpers = /* @__PURE__ */ new Map();
-	queries = {};
-	constructor(worker, options) {
-		this.worker = worker;
-		this.options = options;
-		this.id = this.options.id || "default-worker-data-adapter";
-		if (this.options.log) this.log = this.options.log;
-		this.workerReady = new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
-				reject(/* @__PURE__ */ new Error("WorkerDataAdapter initialization timed out"));
-			}, 5e3);
-			const handleMessage = (event) => {
-				const { type, workerId } = event.data;
-				if (workerId !== this.id) return;
-				if (type === "ready") {
-					resolve();
-					clearTimeout(timeoutId);
-					this.worker.removeEventListener("message", handleMessage);
-				}
-			};
-			this.worker.addEventListener("message", handleMessage);
-		});
-	}
-	async exec(method, collectionName, ...args) {
-		await this.workerReady;
-		if (method !== "isReady") {
-			const collectionReady = this.collectionReady.get(collectionName);
-			if (!collectionReady) throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
-			await collectionReady;
-		}
-		if (this.isDisposed) throw new Error("WorkerDataAdapter is disposed");
-		return new Promise((resolve, reject) => {
-			const messageId = randomId();
-			const handleMessage = (event) => {
-				const { id, workerId, type, data, error } = event.data;
-				if (workerId !== this.id) return;
-				if (type !== "response") return;
-				if (id !== messageId) return;
-				this.log(method, "result", data ?? error);
-				if (error) reject(error);
-				else resolve(data);
-				this.worker.removeEventListener("message", handleMessage);
-			};
-			this.worker.addEventListener("message", handleMessage);
-			this.worker.postMessage({
-				id: messageId,
-				workerId: this.id,
-				method,
-				args: [collectionName, ...args]
-			});
-		});
-	}
-	enqueueBatched(collectionName, method, args) {
-		const helper = this.batchExecutionHelpers.get(collectionName);
-		if (!helper) throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
-		return helper.enqueue(method, args);
-	}
-	updateQuery(collectionName, query, update) {
-		const id = queryId(query.selector, query.options);
-		const collectionQueries = this.queries[collectionName];
-		if (!collectionQueries) return;
-		const existing = collectionQueries.get(id);
-		const newState = {
-			state: "active",
-			error: null,
-			items: [],
-			stateChangeCallbacks: [],
-			eventHandler: existing?.eventHandler,
-			...existing,
-			...update
-		};
-		collectionQueries.set(id, newState);
-		this.queries[collectionName] = collectionQueries;
-	}
-	createCollectionBackend(collection, indices) {
-		this.queries[collection.name] = /* @__PURE__ */ new Map();
-		this.exec("registerCollection", collection.name, indices);
-		this.collectionReady.set(collection.name, this.exec("isReady", collection.name));
-		this.batchExecutionHelpers.set(collection.name, batchOnNextTick(async (method, args) => this.exec(method, collection.name, args)));
+import match from "./index18.mjs";
+import project from "./index21.mjs";
+import sortItems from "./index23.mjs";
+//#region src/utils/applyQueryOptions.ts
+/**
+* Filters, sorts, paginates and projects a plain in-memory array the same way
+* DefaultDataAdapter and WorkerDataAdapterHost apply a selector/QueryOptions
+* pair to their stored items. Used to re-derive a query's result locally after
+* a write, without asking the backing store again.
+* @template T - The type of the items.
+* @param items - The items to filter, sort, paginate and project.
+* @param selector - The selector to match items against.
+* @param options - Sort, skip, limit and field projection options.
+* @returns The resulting items.
+*/
+function applyQueryOptions(items, selector, options) {
+	const matched = selector == null ? [] : items.filter((item) => match(item, selector));
+	const { sort, skip, limit, fields } = options || {};
+	const sorted = sort ? sortItems(matched, sort) : matched;
+	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 {
-			insert: async (item) => {
-				return this.enqueueBatched(collection.name, "insert", [item]);
-			},
-			updateOne: async (selector, modifier) => {
-				return this.enqueueBatched(collection.name, "updateOne", [selector, modifier]);
-			},
-			updateMany: async (selector, modifier) => {
-				return this.enqueueBatched(collection.name, "updateMany", [selector, modifier]);
-			},
-			replaceOne: async (selector, replacement) => {
-				return this.enqueueBatched(collection.name, "replaceOne", [selector, replacement]);
-			},
-			removeOne: async (selector) => {
-				return this.enqueueBatched(collection.name, "removeOne", [selector]);
-			},
-			removeMany: async (selector) => {
-				return this.enqueueBatched(collection.name, "removeMany", [selector]);
-			},
-			registerQuery: (selector, options) => {
-				this.updateQuery(collection.name, {
-					selector,
-					options
-				}, {
-					state: "active",
-					error: null,
-					items: []
-				});
-				this.exec("registerQuery", collection.name, selector, options);
-				const handler = (event) => {
-					const { type, data, workerId, error } = event.data;
-					if (type !== "queryUpdate") return;
-					if (data == null) return;
-					const { collectionName, selector: responseSelector, options: responseOptions, state, items } = data;
-					if (workerId !== this.id) return;
-					if (collectionName !== collection.name) return;
-					if (queryId(responseSelector, responseOptions) !== queryId(selector, options)) return;
-					this.log("queryUpdate", responseSelector, responseOptions, state, data ?? error);
-					this.updateQuery(collection.name, {
-						selector: responseSelector,
-						options: responseOptions
-					}, {
-						state,
-						error,
-						items
-					});
-					const query = this.queries[collection.name]?.get(queryId(selector, options));
-					if (!query) return;
-					query.stateChangeCallbacks.forEach((callback) => callback(state));
-				};
-				this.worker.addEventListener("message", handler);
-				this.updateQuery(collection.name, {
-					selector,
-					options
-				}, { eventHandler: handler });
-			},
-			unregisterQuery: (selector, options) => {
-				const qid = queryId(selector, options);
-				const query = this.queries[collection.name]?.get(qid);
-				if (query?.eventHandler) this.worker.removeEventListener("message", query.eventHandler);
-				this.queries[collection.name]?.delete(qid);
-				this.exec("unregisterQuery", collection.name, selector, options);
-			},
-			getQueryState: (selector, options) => {
-				return (this.queries[collection.name]?.get(queryId(selector, options)))?.state || "active";
-			},
-			getQueryError: (selector, options) => {
-				return (this.queries[collection.name]?.get(queryId(selector, options)))?.error || null;
-			},
-			getQueryResult: (selector, options) => {
-				return (this.queries[collection.name]?.get(queryId(selector, options)))?.items || [];
-			},
-			onQueryStateChange: (selector, options, callback) => {
-				this.updateQuery(collection.name, {
-					selector,
-					options
-				}, { stateChangeCallbacks: [...this.queries[collection.name]?.get(queryId(selector, options))?.stateChangeCallbacks || [], callback] });
-				return () => {
-					const currentCallbacks = this.queries[collection.name]?.get(queryId(selector, options))?.stateChangeCallbacks;
-					if (!currentCallbacks) return;
-					this.updateQuery(collection.name, {
-						selector,
-						options
-					}, { stateChangeCallbacks: currentCallbacks.filter((existingCallback) => existingCallback !== callback) });
-				};
-			},
-			executeQuery: (selector, options) => this.exec("executeQuery", collection.name, selector, options),
-			dispose: async () => {
-				await this.exec("unregisterCollection", collection.name);
-				this.isDisposed = true;
-				this.worker.terminate?.();
-			},
-			isReady: async () => {
-				await this.exec("isReady", collection.name);
-			}
+			...idExcluded ? {} : { id: item.id },
+			...project(item, fields)
 		};
-	}
-};
+	});
+}
 //#endregion
-export { WorkerDataAdapter as default };
+export { applyQueryOptions as default };

package/dist/index32.cjs.js

@@ -1,21 +1,311 @@
-//#region src/utils/compact.ts
-/**
-* Checks if a value is truthy.
-* @template T - The type of the value.
-* @param value - The value to check.
-* @returns A boolean indicating if the value is truthy.
-*/
-function truthy(value) {
-	return !!value;
-}
-/**
-* Filters out falsy values (`false`, `''`, `0`, `null`, `undefined`) from an array.
-* @template T - The type of the elements in the array.
-* @param array - The array to filter.
-* @returns A new array containing only the truthy values from the input array.
-*/
-function compact(array) {
-	return array.filter(truthy);
-}
+const require_randomId = require("./index8.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_queryId = require("./index22.cjs.js");
+const require_batchOnNextTick = require("./index30.cjs.js");
+const require_applyQueryOptions = require("./index31.cjs.js");
+//#region src/WorkerDataAdapter.ts
+var WorkerDataAdapter = class {
+	worker;
+	options;
+	id;
+	isDisposed = false;
+	workerReady;
+	log = () => {};
+	collectionReady = /* @__PURE__ */ new Map();
+	batchExecutionHelpers = /* @__PURE__ */ new Map();
+	queries = {};
+	pendingWrites = /* @__PURE__ */ new Map();
+	pendingWriteSeq = 0;
+	constructor(worker, options) {
+		this.worker = worker;
+		this.options = options;
+		this.id = this.options.id || "default-worker-data-adapter";
+		if (this.options.log) this.log = this.options.log;
+		this.workerReady = new Promise((resolve, reject) => {
+			const timeoutId = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("WorkerDataAdapter initialization timed out"));
+			}, 5e3);
+			const handleMessage = (event) => {
+				const { type, workerId } = event.data;
+				if (workerId !== this.id) return;
+				if (type === "ready") {
+					resolve();
+					clearTimeout(timeoutId);
+					this.worker.removeEventListener("message", handleMessage);
+				}
+			};
+			this.worker.addEventListener("message", handleMessage);
+		});
+	}
+	async exec(method, collectionName, ...args) {
+		await this.workerReady;
+		if (method !== "isReady") {
+			const collectionReady = this.collectionReady.get(collectionName);
+			if (!collectionReady) throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
+			await collectionReady;
+		}
+		if (this.isDisposed) throw new Error("WorkerDataAdapter is disposed");
+		return new Promise((resolve, reject) => {
+			const messageId = require_randomId.default();
+			const handleMessage = (event) => {
+				const { id, workerId, type, data, error } = event.data;
+				if (workerId !== this.id) return;
+				if (type !== "response") return;
+				if (id !== messageId) return;
+				this.log(method, "result", data ?? error);
+				if (error) reject(error);
+				else resolve(data);
+				this.worker.removeEventListener("message", handleMessage);
+			};
+			this.worker.addEventListener("message", handleMessage);
+			this.worker.postMessage({
+				id: messageId,
+				workerId: this.id,
+				method,
+				args: [collectionName, ...args]
+			});
+		});
+	}
+	observableItems(collectionName) {
+		const byId = /* @__PURE__ */ new Map();
+		this.queries[collectionName]?.forEach((query) => {
+			this.mergePendingWrites(collectionName, query.items).forEach((item) => {
+				byId.set(item.id, item);
+			});
+		});
+		return [...byId.values()];
+	}
+	mergePendingWrites(collectionName, items) {
+		const pending = this.pendingWrites.get(collectionName);
+		if (!pending || pending.size === 0) return items;
+		const merged = new Map(items.map((item) => [item.id, item]));
+		[...pending.entries()].sort(([a], [b]) => a - b).forEach(([, write]) => {
+			write.upserts.forEach((item, id) => merged.set(id, item));
+			write.deletes.forEach((id) => merged.delete(id));
+		});
+		return [...merged.values()];
+	}
+	/**
+	* Registers a write's effect locally and notifies every active query it
+	* touches, then returns a function that drops it again once the write
+	* settles.
+	* @param collectionName - The collection the write targets.
+	* @param upserts - Items inserted or updated by the write.
+	* @param deletes - Ids removed by the write.
+	* @returns A function that drops the pending write and re-notifies.
+	*/
+	applyPendingWrite(collectionName, upserts, deletes) {
+		if (upserts.length === 0 && deletes.length === 0) return () => {};
+		const seq = this.pendingWriteSeq += 1;
+		const pending = this.pendingWrites.get(collectionName) ?? /* @__PURE__ */ new Map();
+		pending.set(seq, {
+			upserts: new Map(upserts.map((item) => [item.id, item])),
+			deletes: new Set(deletes)
+		});
+		this.pendingWrites.set(collectionName, pending);
+		const affectedIds = new Set([...upserts.map((item) => item.id), ...deletes]);
+		this.notifyAffectedQueries(collectionName, upserts, affectedIds);
+		return () => {
+			const current = this.pendingWrites.get(collectionName);
+			if (!current) return;
+			current.delete(seq);
+			if (current.size === 0) this.pendingWrites.delete(collectionName);
+			this.notifyAffectedQueries(collectionName, upserts, affectedIds);
+		};
+	}
+	notifyAffectedQueries(collectionName, upserts, affectedIds) {
+		this.queries[collectionName]?.forEach((query) => {
+			const wasHolding = query.items.some((item) => affectedIds.has(item.id));
+			const nowMatches = upserts.some((item) => query.selector != null && require_match.default(item, query.selector));
+			if (!wasHolding && !nowMatches) return;
+			query.stateChangeCallbacks.forEach((callback) => callback(query.state));
+		});
+	}
+	matchObservableItems(collectionName, selector, onlyFirst) {
+		if (selector == null) return [];
+		const matches = this.observableItems(collectionName).filter((item) => require_match.default(item, selector));
+		return onlyFirst ? matches.slice(0, 1) : matches;
+	}
+	resolveUpdate(collectionName, selector, modifier, onlyFirst) {
+		const { $setOnInsert, ...restModifier } = modifier;
+		const upserts = [];
+		const deletes = [];
+		this.matchObservableItems(collectionName, selector, onlyFirst).forEach((item) => {
+			const modifiedItem = require_modify.default(require_deepClone.default(item), restModifier);
+			upserts.push(modifiedItem);
+			if (modifiedItem.id !== item.id) deletes.push(item.id);
+		});
+		return {
+			upserts,
+			deletes
+		};
+	}
+	resolveRemoval(collectionName, selector, onlyFirst) {
+		return this.matchObservableItems(collectionName, selector, onlyFirst).map((item) => item.id);
+	}
+	resolveReplacement(item, replacement) {
+		const modifiedItem = {
+			...replacement,
+			id: replacement.id ?? item.id
+		};
+		return {
+			upserts: [modifiedItem],
+			deletes: modifiedItem.id === item.id ? [] : [item.id]
+		};
+	}
+	async withPendingWrite(collectionName, delta, run) {
+		const dropPendingWrite = this.applyPendingWrite(collectionName, delta.upserts, delta.deletes);
+		try {
+			return await run();
+		} finally {
+			dropPendingWrite();
+		}
+	}
+	enqueueBatched(collectionName, method, args) {
+		const helper = this.batchExecutionHelpers.get(collectionName);
+		if (!helper) throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
+		return helper.enqueue(method, args);
+	}
+	updateQuery(collectionName, query, update) {
+		const id = require_queryId.default(query.selector, query.options);
+		const collectionQueries = this.queries[collectionName];
+		if (!collectionQueries) return;
+		const existing = collectionQueries.get(id);
+		const newState = {
+			selector: query.selector,
+			options: query.options,
+			state: "active",
+			error: null,
+			items: [],
+			stateChangeCallbacks: [],
+			eventHandler: existing?.eventHandler,
+			...existing,
+			...update
+		};
+		collectionQueries.set(id, newState);
+		this.queries[collectionName] = collectionQueries;
+	}
+	createCollectionBackend(collection, indices) {
+		this.queries[collection.name] = /* @__PURE__ */ new Map();
+		this.exec("registerCollection", collection.name, indices);
+		this.collectionReady.set(collection.name, this.exec("isReady", collection.name));
+		this.batchExecutionHelpers.set(collection.name, require_batchOnNextTick.default(async (method, args) => this.exec(method, collection.name, args)));
+		return {
+			insert: async (item) => {
+				return this.withPendingWrite(collection.name, {
+					upserts: [item],
+					deletes: []
+				}, () => this.enqueueBatched(collection.name, "insert", [item]));
+			},
+			updateOne: async (selector, modifier) => {
+				return this.withPendingWrite(collection.name, this.resolveUpdate(collection.name, selector, modifier, true), () => this.enqueueBatched(collection.name, "updateOne", [selector, modifier]));
+			},
+			updateMany: async (selector, modifier) => {
+				return this.withPendingWrite(collection.name, this.resolveUpdate(collection.name, selector, modifier, false), () => this.enqueueBatched(collection.name, "updateMany", [selector, modifier]));
+			},
+			replaceOne: async (selector, replacement) => {
+				const [item] = this.matchObservableItems(collection.name, selector, true);
+				return this.withPendingWrite(collection.name, item == null ? {
+					upserts: [],
+					deletes: []
+				} : this.resolveReplacement(item, replacement), () => this.enqueueBatched(collection.name, "replaceOne", [selector, replacement]));
+			},
+			removeOne: async (selector) => {
+				return this.withPendingWrite(collection.name, {
+					upserts: [],
+					deletes: this.resolveRemoval(collection.name, selector, true)
+				}, () => this.enqueueBatched(collection.name, "removeOne", [selector]));
+			},
+			removeMany: async (selector) => {
+				return this.withPendingWrite(collection.name, {
+					upserts: [],
+					deletes: this.resolveRemoval(collection.name, selector, false)
+				}, () => this.enqueueBatched(collection.name, "removeMany", [selector]));
+			},
+			registerQuery: (selector, options) => {
+				this.updateQuery(collection.name, {
+					selector,
+					options
+				}, {
+					state: "active",
+					error: null,
+					items: []
+				});
+				this.exec("registerQuery", collection.name, selector, options);
+				const handler = (event) => {
+					const { type, data, workerId, error } = event.data;
+					if (type !== "queryUpdate") return;
+					if (data == null) return;
+					const { collectionName, selector: responseSelector, options: responseOptions, state, items } = data;
+					if (workerId !== this.id) return;
+					if (collectionName !== collection.name) return;
+					if (require_queryId.default(responseSelector, responseOptions) !== require_queryId.default(selector, options)) return;
+					this.log("queryUpdate", responseSelector, responseOptions, state, data ?? error);
+					this.updateQuery(collection.name, {
+						selector: responseSelector,
+						options: responseOptions
+					}, {
+						state,
+						error,
+						items
+					});
+					const query = this.queries[collection.name]?.get(require_queryId.default(selector, options));
+					if (!query) return;
+					query.stateChangeCallbacks.forEach((callback) => callback(state));
+				};
+				this.worker.addEventListener("message", handler);
+				this.updateQuery(collection.name, {
+					selector,
+					options
+				}, { eventHandler: handler });
+			},
+			unregisterQuery: (selector, options) => {
+				const qid = require_queryId.default(selector, options);
+				const query = this.queries[collection.name]?.get(qid);
+				if (query?.eventHandler) this.worker.removeEventListener("message", query.eventHandler);
+				this.queries[collection.name]?.delete(qid);
+				this.exec("unregisterQuery", collection.name, selector, options);
+			},
+			getQueryState: (selector, options) => {
+				return (this.queries[collection.name]?.get(require_queryId.default(selector, options)))?.state || "active";
+			},
+			getQueryError: (selector, options) => {
+				return (this.queries[collection.name]?.get(require_queryId.default(selector, options)))?.error || null;
+			},
+			getQueryResult: (selector, options) => {
+				const query = this.queries[collection.name]?.get(require_queryId.default(selector, options));
+				if (!query) return [];
+				const pending = this.pendingWrites.get(collection.name);
+				if (!pending || pending.size === 0) return query.items;
+				return require_applyQueryOptions.default(this.mergePendingWrites(collection.name, query.items), selector, options);
+			},
+			onQueryStateChange: (selector, options, callback) => {
+				this.updateQuery(collection.name, {
+					selector,
+					options
+				}, { stateChangeCallbacks: [...this.queries[collection.name]?.get(require_queryId.default(selector, options))?.stateChangeCallbacks || [], callback] });
+				return () => {
+					const currentCallbacks = this.queries[collection.name]?.get(require_queryId.default(selector, options))?.stateChangeCallbacks;
+					if (!currentCallbacks) return;
+					this.updateQuery(collection.name, {
+						selector,
+						options
+					}, { stateChangeCallbacks: currentCallbacks.filter((existingCallback) => existingCallback !== callback) });
+				};
+			},
+			executeQuery: (selector, options) => this.exec("executeQuery", collection.name, selector, options),
+			dispose: async () => {
+				await this.exec("unregisterCollection", collection.name);
+				this.isDisposed = true;
+				this.worker.terminate?.();
+			},
+			isReady: async () => {
+				await this.exec("isReady", collection.name);
+			}
+		};
+	}
+};
 //#endregion
-exports.default = compact;
+exports.default = WorkerDataAdapter;