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

package/dist/index28.cjs.js

@@ -0,0 +1,90 @@
+//#region src/utils/reactiveOrAsync.ts
+/**
+* A generator helper that makes TypeScript infer the “synchronous value type” for maybe-async expressions.
+*
+* Usage:
+*   const doc = yield* unwrap(Collection.findOne(...))
+*   const list = yield* unwrap(Collection.find(...).fetch())
+*
+* Runtime note:
+*   This does not “unwrap” Promises by itself. It yields the value/Promise to the runner and returns the
+*   value that the runner feeds back via `.next(...)`.
+* @param value The value (or Promise of a value) to yield to the runner.
+* @returns A generator that yields `value` and resolves to the runner-supplied unwrapped `T`.
+*/
+function unwrap(value) {
+	return (function* () {
+		return yield value;
+	})();
+}
+/**
+* Internal: checks for thenables (Promise-like).
+* @param value The value to test.
+* @returns `true` if `value` looks like a Promise/thenable.
+*/
+function isThenable(value) {
+	return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+/**
+* Internal runner: executes a generator either synchronously (reactive) or asynchronously (imperative).
+*
+* - In sync mode, yielding a Promise is a programming error and throws.
+* - In async mode, yielded Promises are awaited.
+* @param thisArgument The `this` value to bind when invoking `gen`.
+* @param mode Execution mode options.
+* @param gen The generator workflow to run.
+* @returns The workflow result (a plain value in sync mode, or a Promise in async mode).
+*/
+function runReactiveOrAsync(thisArgument, mode, gen) {
+	const a = !!mode?.async;
+	const it = gen.call(thisArgument, a);
+	if (!a) {
+		let step = it.next();
+		while (!step.done) {
+			const y = step.value;
+			if (isThenable(y)) throw new Error("Promise yielded in sync flow");
+			step = it.next(y);
+		}
+		return step.value;
+	}
+	return (async function() {
+		let step = it.next();
+		while (!step.done) {
+			const y = step.value;
+			const v = isThenable(y) ? await y : y;
+			step = it.next(v);
+		}
+		return step.value;
+	})();
+}
+/**
+* Factory that turns a generator workflow into a callable method that can run in sync (reactive) or async mode.
+*
+* Call style:
+*   fn(a, b)                        -> sync/reactive return
+*   await fn(a, b, { async: true }) -> async return
+* @param gen Generator workflow. Receives `(a)` which indicates async mode and should `yield`/`yield* unwrap(...)`
+*   any values that may be Promises.
+* @returns A callable method with overloads plus a `.generator` property for composition.
+*/
+function reactiveOrAsync(gen) {
+	/**
+	* The generated method wrapper.
+	* @param allArguments Method arguments, optionally ending with a `ModeOptions` object.
+	* @returns The workflow result (sync) or a Promise of the result (async).
+	*/
+	function method(...allArguments) {
+		const last = allArguments.length > 0 ? allArguments.at(-1) : void 0;
+		const hasMode = typeof last === "object" && last !== null && "async" in last;
+		const mode = hasMode ? last : void 0;
+		const parameters = hasMode ? allArguments.slice(0, -1) : allArguments;
+		return runReactiveOrAsync(this, mode, function* (a) {
+			return yield* gen.call(this, a, ...parameters);
+		});
+	}
+	method.generator = gen;
+	return method;
+}
+//#endregion
+exports.default = reactiveOrAsync;
+exports.unwrap = unwrap;

package/dist/index28.mjs

@@ -1,8 +1,89 @@
-function intersection(...arrays) {
-  if (arrays.length === 0)
-    return [];
-  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
-}
-export {
-  intersection as default
-};
+//#region src/utils/reactiveOrAsync.ts
+/**
+* A generator helper that makes TypeScript infer the “synchronous value type” for maybe-async expressions.
+*
+* Usage:
+*   const doc = yield* unwrap(Collection.findOne(...))
+*   const list = yield* unwrap(Collection.find(...).fetch())
+*
+* Runtime note:
+*   This does not “unwrap” Promises by itself. It yields the value/Promise to the runner and returns the
+*   value that the runner feeds back via `.next(...)`.
+* @param value The value (or Promise of a value) to yield to the runner.
+* @returns A generator that yields `value` and resolves to the runner-supplied unwrapped `T`.
+*/
+function unwrap(value) {
+	return (function* () {
+		return yield value;
+	})();
+}
+/**
+* Internal: checks for thenables (Promise-like).
+* @param value The value to test.
+* @returns `true` if `value` looks like a Promise/thenable.
+*/
+function isThenable(value) {
+	return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+/**
+* Internal runner: executes a generator either synchronously (reactive) or asynchronously (imperative).
+*
+* - In sync mode, yielding a Promise is a programming error and throws.
+* - In async mode, yielded Promises are awaited.
+* @param thisArgument The `this` value to bind when invoking `gen`.
+* @param mode Execution mode options.
+* @param gen The generator workflow to run.
+* @returns The workflow result (a plain value in sync mode, or a Promise in async mode).
+*/
+function runReactiveOrAsync(thisArgument, mode, gen) {
+	const a = !!mode?.async;
+	const it = gen.call(thisArgument, a);
+	if (!a) {
+		let step = it.next();
+		while (!step.done) {
+			const y = step.value;
+			if (isThenable(y)) throw new Error("Promise yielded in sync flow");
+			step = it.next(y);
+		}
+		return step.value;
+	}
+	return (async function() {
+		let step = it.next();
+		while (!step.done) {
+			const y = step.value;
+			const v = isThenable(y) ? await y : y;
+			step = it.next(v);
+		}
+		return step.value;
+	})();
+}
+/**
+* Factory that turns a generator workflow into a callable method that can run in sync (reactive) or async mode.
+*
+* Call style:
+*   fn(a, b)                        -> sync/reactive return
+*   await fn(a, b, { async: true }) -> async return
+* @param gen Generator workflow. Receives `(a)` which indicates async mode and should `yield`/`yield* unwrap(...)`
+*   any values that may be Promises.
+* @returns A callable method with overloads plus a `.generator` property for composition.
+*/
+function reactiveOrAsync(gen) {
+	/**
+	* The generated method wrapper.
+	* @param allArguments Method arguments, optionally ending with a `ModeOptions` object.
+	* @returns The workflow result (sync) or a Promise of the result (async).
+	*/
+	function method(...allArguments) {
+		const last = allArguments.length > 0 ? allArguments.at(-1) : void 0;
+		const hasMode = typeof last === "object" && last !== null && "async" in last;
+		const mode = hasMode ? last : void 0;
+		const parameters = hasMode ? allArguments.slice(0, -1) : allArguments;
+		return runReactiveOrAsync(this, mode, function* (a) {
+			return yield* gen.call(this, a, ...parameters);
+		});
+	}
+	method.generator = gen;
+	return method;
+}
+//#endregion
+export { reactiveOrAsync as default, unwrap };

package/dist/index29.cjs.js

@@ -0,0 +1,424 @@
+const require_isEqual = require("./index2.cjs.js");
+const require_getMatchingKeys = require("./index13.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/AsyncDataAdapter.ts
+/**
+* Carries the context needed to act on a failed query. The bare storage error
+* on its own does not say which collection or selector produced it, which made
+* the default `console.error` hook close to useless.
+*/
+var QueryError = class extends Error {
+	collectionName;
+	selector;
+	options;
+	attempts;
+	constructor(collectionName, selector, options, attempts, cause) {
+		const reason = cause instanceof Error ? cause.message : String(cause);
+		super(`Query on "${collectionName}" failed after ${attempts} attempt(s): ${reason}`);
+		this.name = "QueryError";
+		this.collectionName = collectionName;
+		this.selector = selector;
+		this.options = options;
+		this.attempts = attempts;
+		this.cause = cause;
+	}
+};
+var DEFAULT_RETRY_ATTEMPTS = 3;
+var defaultRetryDelay = (attempt) => 100 * 4 ** (attempt - 1);
+var wait = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+/**
+* AsyncDataAdapter
+* Combines WorkerDataAdapter + WorkerDataAdapterHost into a single, transport-free adapter.
+* - Keeps the DataAdapter/CollectionBackend surface identical to the Worker version.
+* - Executes queries and mutations directly against the provided StorageAdapter.
+* - Preserves index-aware query optimization and push-style query updates to listeners.
+*/
+var AsyncDataAdapter = class {
+	options;
+	id;
+	onError;
+	retryAttempts;
+	retryDelay;
+	storageAdapters = /* @__PURE__ */ new Map();
+	storageAdapterReady = /* @__PURE__ */ new Map();
+	collectionIndices = /* @__PURE__ */ new Map();
+	queries = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		this.id = options.id || "async-data-adapter";
+		this.onError = options.onError ?? ((error) => {
+			console.error(error);
+		});
+		this.retryAttempts = Math.max(1, options.retry?.attempts ?? DEFAULT_RETRY_ATTEMPTS);
+		this.retryDelay = options.retry?.delay ?? defaultRetryDelay;
+	}
+	createCollectionBackend(collection, indices) {
+		this.collectionIndices.set(collection.name, indices);
+		this.queries.set(collection.name, /* @__PURE__ */ new Map());
+		this.ensureStorageAdapter(collection.name);
+		const ready = (async () => {
+			try {
+				await this.setupStorage(collection.name, indices);
+			} catch (error) {
+				this.onError(error);
+				throw error;
+			}
+		})();
+		this.storageAdapterReady.set(collection.name, ready);
+		const registerQuery = (selector, options) => {
+			const qid = require_queryId.default(selector, options);
+			const registry = this.queries.get(collection.name);
+			if (!registry) throw new Error(`Collection ${collection.name} not initialized!`);
+			registry.set(qid, {
+				selector,
+				options,
+				items: [],
+				listeners: /* @__PURE__ */ new Set(),
+				...registry.get(qid),
+				state: "active",
+				error: null
+			});
+			this.fulfillQuery(collection.name, selector, options).catch(this.onError);
+		};
+		const unregisterQuery = (selector, options) => {
+			const qid = require_queryId.default(selector, options);
+			this.queries.get(collection.name)?.delete(qid);
+		};
+		const getQueryState = (selector, options) => {
+			return (this.queries.get(collection.name)?.get(require_queryId.default(selector, options)))?.state ?? "active";
+		};
+		const getQueryError = (selector, options) => {
+			return (this.queries.get(collection.name)?.get(require_queryId.default(selector, options)))?.error ?? null;
+		};
+		const getQueryResult = (selector, options) => {
+			return (this.queries.get(collection.name)?.get(require_queryId.default(selector, options)))?.items ?? [];
+		};
+		const retryQuery = (selector, options) => {
+			const qid = require_queryId.default(selector, options);
+			if (!this.queries.get(collection.name)?.get(qid)) return;
+			this.publishState(collection.name, qid, "active", null);
+			this.runQuery(collection.name, selector, options);
+		};
+		const onQueryStateChange = (selector, options, callback) => {
+			const qid = require_queryId.default(selector, options);
+			const registry = this.queries.get(collection.name);
+			if (!registry) throw new Error(`Collection ${collection.name} not initialized!`);
+			if (!registry.has(qid)) registry.set(qid, {
+				selector,
+				options,
+				state: "active",
+				error: null,
+				items: [],
+				listeners: /* @__PURE__ */ new Set()
+			});
+			registry.get(qid)?.listeners.add(callback);
+			if (registry.get(qid)?.state === "error") retryQuery(selector, options);
+			return () => registry.get(qid)?.listeners.delete(callback);
+		};
+		return {
+			insert: async (item) => {
+				await ready;
+				return await this.insert(collection.name, item);
+			},
+			updateOne: async (selector, modifier) => {
+				await ready;
+				return this.updateOne(collection.name, selector, modifier);
+			},
+			updateMany: async (selector, modifier) => {
+				await ready;
+				return this.updateMany(collection.name, selector, modifier);
+			},
+			replaceOne: async (selector, replacement) => {
+				await ready;
+				return this.replaceOne(collection.name, selector, replacement);
+			},
+			removeOne: async (selector) => {
+				await ready;
+				return this.removeOne(collection.name, selector);
+			},
+			removeMany: async (selector) => {
+				await ready;
+				return this.removeMany(collection.name, selector);
+			},
+			registerQuery,
+			unregisterQuery,
+			retryQuery,
+			getQueryState,
+			getQueryError,
+			getQueryResult,
+			onQueryStateChange,
+			executeQuery: async (selector, options) => {
+				await ready;
+				return this.executeQuery(collection.name, selector, options);
+			},
+			dispose: async () => {
+				this.storageAdapters.delete(collection.name);
+				this.queries.delete(collection.name);
+				this.collectionIndices.delete(collection.name);
+				this.storageAdapterReady.delete(collection.name);
+			},
+			isReady: async () => {
+				await ready;
+			}
+		};
+	}
+	async setupStorage(collectionName, indices) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		await storage.setup();
+		await Promise.all(indices.map((index) => storage.createIndex(index)));
+	}
+	ensureStorageAdapter(name) {
+		if (this.storageAdapters.has(name)) return;
+		const adapter = this.options.storage(name);
+		if (!adapter) return;
+		this.storageAdapters.set(name, adapter);
+	}
+	/**
+	* Compute and publish the result for a specific query
+	* @param collectionName - name of the collection
+	* @param selector - query selector
+	* @param options - query options
+	*/
+	async fulfillQuery(collectionName, selector, options) {
+		const qid = require_queryId.default(selector, options);
+		const registry = this.queries.get(collectionName);
+		if (!registry) throw new Error(`Collection ${collectionName} not initialized!`);
+		if (!registry.get(qid)) return;
+		this.publishState(collectionName, qid, "active", null);
+		await this.runQuery(collectionName, selector, options);
+	}
+	/**
+	* Executes a query, retrying transient failures before giving up. The state
+	* stays `'active'` across retries — consumers should see "still loading",
+	* not "failed", until we actually stop trying. Only the final failure is
+	* published as `'error'` and reported through `onError`; previously that
+	* error was swallowed entirely (`fulfillQuery` caught it internally, so the
+	* `.catch(this.onError)` on its call site was unreachable) and the query
+	* stayed dead for the rest of the session.
+	* @param collectionName - name of the collection
+	* @param selector - query selector
+	* @param options - query options
+	*/
+	async runQuery(collectionName, selector, options) {
+		const qid = require_queryId.default(selector, options);
+		let lastError;
+		for (let attempt = 1; attempt <= this.retryAttempts; attempt += 1) {
+			if (!this.queries.get(collectionName)?.has(qid)) return;
+			try {
+				const items = await this.executeQuery(collectionName, selector, options);
+				this.publishResult(collectionName, qid, items);
+				this.publishState(collectionName, qid, "complete", null);
+				return;
+			} catch (error) {
+				lastError = error;
+				if (attempt < this.retryAttempts) await wait(this.retryDelay(attempt));
+			}
+		}
+		const queryError = new QueryError(collectionName, selector, options, this.retryAttempts, lastError);
+		this.publishState(collectionName, qid, "error", queryError);
+		this.onError(queryError);
+	}
+	/**
+	* Notify listeners about state changes and keep the cache updated
+	* @param collectionName - name of the collection
+	* @param qid - query id
+	* @param state - new state
+	* @param error - error if state is 'error', null otherwise
+	*/
+	publishState(collectionName, qid, state, error) {
+		const rec = this.queries.get(collectionName)?.get(qid);
+		if (!rec) return;
+		rec.state = state;
+		rec.error = error;
+		for (const callback of rec.listeners) try {
+			callback(state);
+		} catch (error_) {
+			this.onError(error_);
+		}
+	}
+	publishResult(collectionName, qid, items) {
+		const rec = this.queries.get(collectionName)?.get(qid);
+		if (!rec) return;
+		rec.items = items;
+	}
+	async getIndexInfo(collectionName, selector) {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") return {
+			matched: true,
+			ids: [selector.id].filter(Boolean),
+			optimizedSelector: {}
+		};
+		if (selector == null) return {
+			matched: false,
+			ids: [],
+			optimizedSelector: {}
+		};
+		return require_getIndexInfo.default((this.collectionIndices.get(collectionName) ?? []).map((field) => async (flatSelector) => {
+			if (!Object.hasOwnProperty.call(flatSelector, field)) return { matched: false };
+			const index = await storageAdapter.readIndex(field);
+			const fieldSelector = flatSelector[field];
+			const filtersForNull = fieldSelector == null || fieldSelector.$exists === false;
+			const keys = filtersForNull ? {
+				include: null,
+				exclude: [...index.keys()].filter((key) => key != null)
+			} : require_getMatchingKeys.default(field, flatSelector);
+			if (keys.include == null && keys.exclude == null) return { matched: false };
+			let includedIds = [];
+			if (keys.include == null) for (const set of index.values()) for (const pos of set) includedIds.push(pos);
+			else for (const key of keys.include) {
+				const idSet = index.get(key);
+				if (idSet) for (const id of idSet) includedIds.push(id);
+			}
+			if (keys.exclude != null) {
+				const excludeIds = /* @__PURE__ */ new Set();
+				for (const key of keys.exclude) {
+					const idSet = index.get(key);
+					if (idSet) for (const id of idSet) excludeIds.add(id);
+				}
+				includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
+			}
+			return {
+				matched: true,
+				ids: includedIds,
+				fields: [field],
+				keepSelector: filtersForNull
+			};
+		}), selector);
+	}
+	async queryItems(collectionName, selector) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const index = await this.getIndexInfo(collectionName, selector);
+		const matchItems = (item) => {
+			if (index.optimizedSelector == null) return true;
+			if (Object.keys(index.optimizedSelector).length <= 0) return true;
+			return require_match.default(item, index.optimizedSelector);
+		};
+		if (index.matched) {
+			const items = await storage.readIds(index.ids);
+			if (require_isEqual.default(index.optimizedSelector, {})) return items;
+			return items.filter(matchItems);
+		} else {
+			const allItems = await storage.readAll();
+			if (require_isEqual.default(selector, {})) return allItems;
+			return allItems.filter(matchItems);
+		}
+	}
+	async executeQuery(collectionName, selector, options) {
+		const items = await this.queryItems(collectionName, 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)
+			};
+		});
+	}
+	/**
+	* After mutations, recompute and push updates for affected active queries
+	* @param collectionName - name of the collection
+	* @param affectedItems - item states before and/or after the mutation
+	*/
+	async checkQueryUpdates(collectionName, affectedItems) {
+		const registry = this.queries.get(collectionName);
+		if (!registry) throw new Error(`Collection ${collectionName} not initialized!`);
+		if (registry.size === 0) return;
+		const affected = [...registry.values()].filter(({ selector }) => affectedItems.some((item) => require_match.default(item, selector)));
+		if (affected.length === 0) return;
+		for (const { selector, options } of affected) {
+			const qid = require_queryId.default(selector, options);
+			this.publishState(collectionName, qid, "active", null);
+		}
+		await Promise.all(affected.map(({ selector, options }) => this.runQuery(collectionName, selector, options)));
+	}
+	async insert(collectionName, newItem) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		if ((await storage.readIds([newItem.id])).length > 0) throw new Error(`Item with id ${String(newItem.id)} already exists`);
+		await storage.insert([newItem]);
+		await this.checkQueryUpdates(collectionName, [newItem]);
+		return newItem;
+	}
+	async updateOne(collectionName, selector, modifier) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const [item] = await this.executeQuery(collectionName, selector, { limit: 1 });
+		const { $setOnInsert, ...rest } = modifier;
+		if (item == null) return [];
+		const modified = require_modify.default(require_deepClone.default(item), rest);
+		if (item.id !== modified.id) {
+			if ((await storage.readIds([modified.id])).length > 0) throw new Error(`Item with id ${String(modified.id)} already exists`);
+		}
+		await storage.replace([modified]);
+		await this.checkQueryUpdates(collectionName, [item, modified]);
+		return [modified];
+	}
+	async updateMany(collectionName, selector, modifier) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const items = await this.executeQuery(collectionName, selector);
+		if (items.length === 0) return [];
+		const { $setOnInsert, ...rest } = modifier;
+		const changed = await Promise.all(items.map(async (item) => {
+			const modified = require_modify.default(require_deepClone.default(item), rest);
+			if (item.id !== modified.id) {
+				if ((await storage.readIds([modified.id])).length > 0) throw new Error(`Item with id ${String(modified.id)} already exists`);
+			}
+			return modified;
+		}));
+		await storage.replace(changed);
+		await this.checkQueryUpdates(collectionName, [...items, ...changed]);
+		return changed;
+	}
+	async replaceOne(collectionName, selector, replacement) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const [item] = await this.executeQuery(collectionName, selector, { limit: 1 });
+		if (item == null) return [];
+		const modified = {
+			...replacement,
+			id: replacement.id ?? item.id
+		};
+		if (item.id !== modified.id) {
+			if ((await storage.readIds([modified.id])).length > 0) throw new Error(`Item with id ${String(modified.id)} already exists`);
+		}
+		await storage.replace([modified]);
+		await this.checkQueryUpdates(collectionName, [item, modified]);
+		return [modified];
+	}
+	async removeOne(collectionName, selector) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const [item] = await this.executeQuery(collectionName, selector, { limit: 1 });
+		if (item == null) return [];
+		await storage.remove([item]);
+		await this.checkQueryUpdates(collectionName, [item]);
+		return [item];
+	}
+	async removeMany(collectionName, selector) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const items = await this.executeQuery(collectionName, selector);
+		if (items.length === 0) return [];
+		await storage.remove(items);
+		await this.checkQueryUpdates(collectionName, items);
+		return items;
+	}
+};
+//#endregion
+exports.default = AsyncDataAdapter;