@signaldb/core 2.0.0-beta.18 → 2.0.0-beta.19

package/dist/index32.cjs.js

@@ -1,479 +1,90 @@
-const require_isEqual = require("./index2.cjs.js");
-const require_queryDelta = require("./index4.cjs.js");
-const require_getMatchingKeys = require("./index14.cjs.js");
-const require_getIndexInfo = require("./index17.cjs.js");
-const require_deepClone = require("./index18.cjs.js");
-const require_match = require("./index19.cjs.js");
-const require_modify = require("./index20.cjs.js");
-const require_projectItems = require("./index23.cjs.js");
-const require_sortItems = require("./index24.cjs.js");
-const require_incrementalQueryUpdate = require("./index25.cjs.js");
-const require_queryId = require("./index26.cjs.js");
-//#region src/AsyncDataAdapter.ts
+//#region src/utils/reactiveOrAsync.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.
+* 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`.
 */
-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;
-	}
-};
+function unwrap(value) {
+	return (function* () {
+		return yield value;
+	})();
+}
 /**
-* Turns the item states a write produced into the upsert/delete split a query update needs.
-*
-* The two lists are not symmetric: an item that is still there after the write is described by its
-* new state, while an item that is gone — removed, or given a new id — is described by the id it
-* used to have and nothing else. Mixing the states from before and after a write into one list
-* loses exactly that distinction.
-* @template T - The type of the items.
-* @param previousItems - The items as they were before the write.
-* @param modifiedItems - The items as they are after it.
-* @returns The changeset describing the write.
+* Internal: checks for thenables (Promise-like).
+* @param value The value to test.
+* @returns `true` if `value` looks like a Promise/thenable.
 */
-function toChangeset(previousItems, modifiedItems) {
-	const modifiedIds = new Set(modifiedItems.map((item) => item.id));
-	return {
-		upserts: modifiedItems,
-		deletes: previousItems.map((item) => item.id).filter((id) => !modifiedIds.has(id))
-	};
+function isThenable(value) {
+	return typeof value === "object" && value !== null && typeof value.then === "function";
 }
-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.
+* 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).
 */
-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);
-				const rec = this.queries.get(collectionName)?.get(qid);
-				const delta = rec?.answered ? require_queryDelta.diffQueryResults(rec.items, items) : void 0;
-				this.publishResult(collectionName, qid, items);
-				this.publishState(collectionName, qid, "complete", null, delta);
-				return;
-			} catch (error) {
-				lastError = error;
-				if (attempt < this.retryAttempts) await wait(this.retryDelay(attempt));
-			}
+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);
 		}
-		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
-	* @param delta - what changed about the result, when that is known
-	*/
-	publishState(collectionName, qid, state, error, delta) {
-		const rec = this.queries.get(collectionName)?.get(qid);
-		if (!rec) return;
-		rec.state = state;
-		rec.error = error;
-		const subscribers = [...rec.listeners];
-		for (const callback of subscribers) try {
-			require_queryDelta.callWithDelta(callback, state, delta);
-		} catch (error_) {
-			this.onError(error_);
+		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);
 		}
-	}
-	publishResult(collectionName, qid, items) {
-		const rec = this.queries.get(collectionName)?.get(qid);
-		if (!rec) return;
-		rec.items = items;
-		rec.itemIds = void 0;
-		rec.answered = true;
-	}
-	queryItemIds(rec) {
-		if (!rec.itemIds) rec.itemIds = new Set(rec.items.map((item) => item.id));
-		return rec.itemIds;
-	}
-	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;
-		return require_projectItems.default(limit ? skipped.slice(0, limit) : skipped, fields);
-	}
+		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) {
 	/**
-	* After mutations, bring every affected active query up to date.
-	*
-	* A query whose previous result is enough to answer the change is brought up to date from that
-	* result alone — no round trip to the storage, and no detour through `'active'`, because there is
-	* no window in which the query is stale. Only a query the change cannot be reasoned about
-	* locally — a window onto a larger set, or one that has never been answered — goes back to the
-	* store, and that one gets the same retry and reporting behaviour a freshly registered query
-	* gets: a refresh that fails silently leaves exactly the same dead cursor.
-	* @param collectionName - name of the collection
-	* @param changes - the items the write created, updated or removed
+	* 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).
 	*/
-	async checkQueryUpdates(collectionName, changes) {
-		const registry = this.queries.get(collectionName);
-		if (!registry) throw new Error(`Collection ${collectionName} not initialized!`);
-		if (registry.size === 0) return;
-		if (changes.upserts.length === 0 && changes.deletes.length === 0) return;
-		const affected = [...registry.values()].filter((rec) => {
-			const ids = this.queryItemIds(rec);
-			if (changes.deletes.some((id) => ids.has(id))) return true;
-			return changes.upserts.some((item) => ids.has(item.id) || require_match.default(item, rec.selector));
-		});
-		if (affected.length === 0) return;
-		const needsReExecution = [];
-		for (const rec of affected) {
-			const { selector, options } = rec;
-			const incremental = rec.answered ? require_incrementalQueryUpdate.default(rec.items, selector, options, changes) : null;
-			if (incremental == null) {
-				needsReExecution.push(rec);
-				continue;
-			}
-			const qid = require_queryId.default(selector, options);
-			const delta = require_queryDelta.diffQueryResults(rec.items, incremental);
-			if (require_queryDelta.isEmptyQueryDelta(delta)) continue;
-			this.publishResult(collectionName, qid, incremental);
-			this.publishState(collectionName, qid, "complete", null, delta);
-		}
-		for (const { selector, options } of needsReExecution) this.publishState(collectionName, require_queryId.default(selector, options), "active", null);
-		await Promise.all(needsReExecution.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, {
-			upserts: [newItem],
-			deletes: []
+	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);
 		});
-		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, toChangeset([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, toChangeset(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, toChangeset([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, {
-			upserts: [],
-			deletes: [item.id]
-		});
-		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, {
-			upserts: [],
-			deletes: items.map((item) => item.id)
-		});
-		return items;
-	}
-};
+	method.generator = gen;
+	return method;
+}
 //#endregion
-exports.default = AsyncDataAdapter;
+exports.default = reactiveOrAsync;
+exports.unwrap = unwrap;