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

package/dist/index30.mjs

@@ -1,43 +1,72 @@
-const expressionKeys = /* @__PURE__ */ new Set([
-  "$eq",
-  "$gt",
-  "$gte",
-  "$lt",
-  "$lte",
-  "$in",
-  "$nin",
-  "$ne",
-  "$exists",
-  "$not",
-  "$expr",
-  "$jsonSchema",
-  "$mod",
-  "$regex",
-  "$options",
-  "$text",
-  "$where",
-  "$all",
-  "$elemMatch",
-  "$size",
-  "$bitsAllClear",
-  "$bitsAllSet",
-  "$bitsAnyClear",
-  "$bitsAnySet"
-]);
-function isFieldExpression(expression) {
-  if (typeof expression !== "object" || expression == null) {
-    return false;
-  }
-  const keys = Object.keys(expression);
-  if (keys.length === 0) {
-    return false;
-  }
-  const hasInvalidKeys = keys.some((key) => !expressionKeys.has(key));
-  if (hasInvalidKeys)
-    return false;
-  const hasValidKeys = keys.every((key) => expressionKeys.has(key));
-  return hasValidKeys;
+//#region src/utils/batchOnNextTick.ts
+/**
+* Groups multiple calls by key and flushes them on the next tick (macrotask).
+* @param onFlush - Function that will be called with the key and all queued items when flushing.
+* @returns An object with `enqueue` and `flush` methods.
+* @example
+*   const batcher = batchOnNextTick<string>(async (key, items) => {
+*     // items is an array of { args, resolve, reject }
+*     // do something once with all args...
+*   })
+*
+*   batcher.enqueue("my-key", [arg1, arg2])
+*/
+function batchOnNextTick(onFlush) {
+	const queues = /* @__PURE__ */ new Map();
+	/**
+	* Enqueue a call with the given key and arguments.
+	* @param key key to group calls
+	* @param args arguments for the call
+	* @returns A promise that resolves or rejects when the call is flushed.
+	*/
+	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;
+				q.flush();
+			}, 0);
+		});
+	}
+	/**
+	* Flush the queue for the given key immediately.
+	* @param key key to flush
+	* @returns A promise that resolves when the flush is complete.
+	*/
+	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
+	};
 }
-export {
-  isFieldExpression as default
-};
+//#endregion
+export { batchOnNextTick as default };

package/dist/index31.cjs.js

@@ -0,0 +1,191 @@
+const require_randomId = require("./index8.cjs.js");
+const require_queryId = require("./index22.cjs.js");
+const require_batchOnNextTick = require("./index30.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 = {};
+	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]
+			});
+		});
+	}
+	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 = {
+			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.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 (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) => {
+				return (this.queries[collection.name]?.get(require_queryId.default(selector, options)))?.items || [];
+			},
+			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) throw new Error("State change callbacks are not defined!");
+					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 = WorkerDataAdapter;

package/dist/index31.mjs

@@ -1,10 +1,191 @@
-function uniqueBy(array, fn) {
-  const set = /* @__PURE__ */ new Set();
-  return array.filter((element) => {
-    const value = typeof fn === "function" ? fn(element) : element[fn];
-    return !set.has(value) && set.add(value);
-  });
-}
-export {
-  uniqueBy as default
+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)));
+		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) throw new Error("State change callbacks are not defined!");
+					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
+export { WorkerDataAdapter as default };

package/dist/index32.cjs.js

@@ -0,0 +1,21 @@
+//#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);
+}
+//#endregion
+exports.default = compact;

package/dist/index32.mjs

@@ -0,0 +1,21 @@
+//#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);
+}
+//#endregion
+export { compact as default };