@signaldb/core 2.0.0-beta.21 → 2.0.0-beta.22

package/dist/index35.cjs.js

@@ -1,72 +1,139 @@
-//#region src/utils/batchOnNextTick.ts
+const require_isEqual = require("./index2.cjs.js");
+const require_getIndexInfo = require("./index17.cjs.js");
+const require_match = require("./index19.cjs.js");
+const require_projectItems = require("./index23.cjs.js");
+const require_sortItems = require("./index24.cjs.js");
+const require_idIndexQuery = require("./index27.cjs.js");
+const require_compact = require("./index33.cjs.js");
+const require_storageIndexQuery = require("./index34.cjs.js");
+//#region src/utils/executeStorageQuery.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...
-*   })
+* Runs one query against a storage adapter and returns its finished result.
 *
-*   batcher.enqueue("my-key", [arg1, arg2])
+* This is the single place a query becomes rows. It used to be three copies — `AsyncDataAdapter`,
+* `AutoFetchDataAdapter` and `WorkerDataAdapterHost` each had the same eight lines — which is how a
+* capability like `StorageAdapter#query` ends up supported in one of them and quietly missing from
+* the other two. The copies had already drifted apart in one respect: each maintained its own
+* primary-key fast path.
+*
+* Two paths, and the second is what every adapter had before:
+*
+* - the adapter answers `query` itself, and this applies whatever it declined;
+* - it does not, and this reads through the index (or the whole store) and filters, sorts, windows
+*   and projects here.
+* @template T - The type of the items.
+* @template I - The type of the item ids.
+* @param storageAdapter - The storage adapter to read from.
+* @param indices - The fields this collection has declared indices for.
+* @param selector - The query's selector. `null` matches nothing.
+* @param options - The query's sort, window and projection.
+* @returns The query's result.
 */
-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);
-		});
+async function executeStorageQuery(storageAdapter, indices, selector, options) {
+	if (selector === null) return [];
+	const effectiveSelector = selector || {};
+	if (storageAdapter.query) return finishAnswer(await storageAdapter.query({
+		selector: effectiveSelector,
+		...options
+	}), options);
+	return finishAnswer({ items: await readMatching(storageAdapter, indices, effectiveSelector) }, options);
+}
+/**
+* Applies whatever the adapter did not, and refuses what it cannot have meant.
+* @template T - The type of the items.
+* @param answer - What the adapter answered, and how much of the question it took on.
+* @param options - The query's sort, window and projection.
+* @returns The finished result.
+*/
+function finishAnswer(answer, options) {
+	const { sort, skip, limit, fields } = options || {};
+	const residual = answer.residualSelector;
+	const hasResidual = residual != null && Object.keys(residual).length > 0;
+	assertAnswerIsCoherent(answer, hasResidual, sort, fields);
+	const matched = hasResidual ? answer.items.filter((item) => require_match.default(item, residual)) : answer.items;
+	const sorted = sort && !answer.sorted ? require_sortItems.default(matched, sort) : matched;
+	const windowed = answer.windowed ? sorted : applyWindow(sorted, skip, limit);
+	return answer.projected ? windowed : require_projectItems.default(windowed, fields);
+}
+/**
+* Fails on the three claims that are contradictions rather than choices.
+*
+* Each of them produces a result nothing downstream can repair, so this throws where the mistake
+* is rather than serving a subset that looks like an answer.
+* @template T - The type of the items.
+* @param answer - What the adapter answered.
+* @param hasResidual - Whether part of the selector was left to the caller.
+* @param sort - The sort the query asked for, if any.
+* @param fields - The projection the query asked for, if any.
+*/
+function assertAnswerIsCoherent(answer, hasResidual, sort, fields) {
+	if (answer.windowed && hasResidual) throw new Error("StorageAdapter#query claimed `windowed` while leaving part of the selector unapplied; the window is over the wrong set");
+	if (answer.windowed && sort != null && !answer.sorted) throw new Error("StorageAdapter#query claimed `windowed` without `sorted` for a sorted query; the window is an arbitrary subset");
+	const sortIsStillOwed = sort != null && !answer.sorted;
+	if (answer.projected && sortIsStillOwed && !sortKeysSurviveProjection(sort, fields)) throw new Error("StorageAdapter#query claimed `projected` without `sorted`, and the projection drops a key the sort needs");
+}
+/**
+* Applies `skip` and `limit`.
+* @template T - The type of the items.
+* @param items - The items to window.
+* @param skip - How many to drop from the front.
+* @param limit - How many to keep.
+* @returns The windowed items.
+*/
+function applyWindow(items, skip, limit) {
+	const skipped = skip ? items.slice(skip) : items;
+	return limit == null ? skipped : skipped.slice(0, limit);
+}
+/**
+* Whether every key the sort is on survives the projection.
+* @template T - The type of the items.
+* @param sort - The query's sort.
+* @param fields - The query's projection, if any.
+* @returns `true` when the sort can still be applied to the projected items.
+*/
+function sortKeysSurviveProjection(sort, fields) {
+	if (fields == null) return true;
+	const specKeys = Object.keys(fields);
+	const spec = fields;
+	const excluding = specKeys.length > 0 && specKeys.every((key) => !spec[key]);
+	const covers = (key) => specKeys.some((entry) => entry === key || key.startsWith(`${entry}.`));
+	return Object.keys(sort).every((key) => excluding ? !covers(key) : covers(key));
+}
+/**
+* The pre-`query` read path: the primary key if the selector is one, then a declared index, then
+* the whole store.
+*
+* The `id` fast path is not an optimisation on top of the index machinery, it is the only way a
+* primary-key lookup works at all: `id` is never a *declared* index — `readIds` is exactly the
+* lookup it describes — so a selector of `{ id: … }` matches no index and would otherwise fall
+* through to `readAll`. All three adapters carried their own copy of it; losing it here turned
+* every point read into a full scan, which is how it was noticed.
+* @template T - The type of the items.
+* @template I - The type of the item ids.
+* @param storageAdapter - The storage adapter to read from.
+* @param indices - The fields this collection has declared indices for.
+* @param selector - The query's selector.
+* @returns Every stored item the selector matches.
+*/
+async function readMatching(storageAdapter, indices, selector) {
+	if (Object.keys(selector).length === 1 && "id" in selector) {
+		const idResult = require_idIndexQuery.default(selector);
+		if (idResult.matched) return storageAdapter.readIds(require_compact.default(idResult.ids));
 	}
-	return {
-		enqueue,
-		flush
+	const indexInfo = await require_getIndexInfo.default(indices.map((field) => require_storageIndexQuery.default(storageAdapter, field)), selector);
+	const matchItems = (item) => {
+		if (indexInfo.optimizedSelector == null) return true;
+		if (Object.keys(indexInfo.optimizedSelector).length <= 0) return true;
+		return require_match.default(item, indexInfo.optimizedSelector);
 	};
+	if (indexInfo.matched) {
+		const items = await storageAdapter.readIds(indexInfo.ids);
+		if (require_isEqual.default(indexInfo.optimizedSelector, {})) return items;
+		return items.filter(matchItems);
+	}
+	const allItems = await storageAdapter.readAll();
+	if (require_isEqual.default(selector, {})) return allItems;
+	return allItems.filter(matchItems);
 }
 //#endregion
-exports.default = batchOnNextTick;
+exports.default = executeStorageQuery;

package/dist/index35.mjs

@@ -1,72 +1,139 @@
-//#region src/utils/batchOnNextTick.ts
+import isEqual from "./index2.mjs";
+import getIndexInfo from "./index17.mjs";
+import match from "./index19.mjs";
+import projectItems from "./index23.mjs";
+import sortItems from "./index24.mjs";
+import idIndexQuery from "./index27.mjs";
+import compact from "./index33.mjs";
+import storageIndexQuery from "./index34.mjs";
+//#region src/utils/executeStorageQuery.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...
-*   })
+* Runs one query against a storage adapter and returns its finished result.
 *
-*   batcher.enqueue("my-key", [arg1, arg2])
+* This is the single place a query becomes rows. It used to be three copies — `AsyncDataAdapter`,
+* `AutoFetchDataAdapter` and `WorkerDataAdapterHost` each had the same eight lines — which is how a
+* capability like `StorageAdapter#query` ends up supported in one of them and quietly missing from
+* the other two. The copies had already drifted apart in one respect: each maintained its own
+* primary-key fast path.
+*
+* Two paths, and the second is what every adapter had before:
+*
+* - the adapter answers `query` itself, and this applies whatever it declined;
+* - it does not, and this reads through the index (or the whole store) and filters, sorts, windows
+*   and projects here.
+* @template T - The type of the items.
+* @template I - The type of the item ids.
+* @param storageAdapter - The storage adapter to read from.
+* @param indices - The fields this collection has declared indices for.
+* @param selector - The query's selector. `null` matches nothing.
+* @param options - The query's sort, window and projection.
+* @returns The query's result.
 */
-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);
-		});
+async function executeStorageQuery(storageAdapter, indices, selector, options) {
+	if (selector === null) return [];
+	const effectiveSelector = selector || {};
+	if (storageAdapter.query) return finishAnswer(await storageAdapter.query({
+		selector: effectiveSelector,
+		...options
+	}), options);
+	return finishAnswer({ items: await readMatching(storageAdapter, indices, effectiveSelector) }, options);
+}
+/**
+* Applies whatever the adapter did not, and refuses what it cannot have meant.
+* @template T - The type of the items.
+* @param answer - What the adapter answered, and how much of the question it took on.
+* @param options - The query's sort, window and projection.
+* @returns The finished result.
+*/
+function finishAnswer(answer, options) {
+	const { sort, skip, limit, fields } = options || {};
+	const residual = answer.residualSelector;
+	const hasResidual = residual != null && Object.keys(residual).length > 0;
+	assertAnswerIsCoherent(answer, hasResidual, sort, fields);
+	const matched = hasResidual ? answer.items.filter((item) => match(item, residual)) : answer.items;
+	const sorted = sort && !answer.sorted ? sortItems(matched, sort) : matched;
+	const windowed = answer.windowed ? sorted : applyWindow(sorted, skip, limit);
+	return answer.projected ? windowed : projectItems(windowed, fields);
+}
+/**
+* Fails on the three claims that are contradictions rather than choices.
+*
+* Each of them produces a result nothing downstream can repair, so this throws where the mistake
+* is rather than serving a subset that looks like an answer.
+* @template T - The type of the items.
+* @param answer - What the adapter answered.
+* @param hasResidual - Whether part of the selector was left to the caller.
+* @param sort - The sort the query asked for, if any.
+* @param fields - The projection the query asked for, if any.
+*/
+function assertAnswerIsCoherent(answer, hasResidual, sort, fields) {
+	if (answer.windowed && hasResidual) throw new Error("StorageAdapter#query claimed `windowed` while leaving part of the selector unapplied; the window is over the wrong set");
+	if (answer.windowed && sort != null && !answer.sorted) throw new Error("StorageAdapter#query claimed `windowed` without `sorted` for a sorted query; the window is an arbitrary subset");
+	const sortIsStillOwed = sort != null && !answer.sorted;
+	if (answer.projected && sortIsStillOwed && !sortKeysSurviveProjection(sort, fields)) throw new Error("StorageAdapter#query claimed `projected` without `sorted`, and the projection drops a key the sort needs");
+}
+/**
+* Applies `skip` and `limit`.
+* @template T - The type of the items.
+* @param items - The items to window.
+* @param skip - How many to drop from the front.
+* @param limit - How many to keep.
+* @returns The windowed items.
+*/
+function applyWindow(items, skip, limit) {
+	const skipped = skip ? items.slice(skip) : items;
+	return limit == null ? skipped : skipped.slice(0, limit);
+}
+/**
+* Whether every key the sort is on survives the projection.
+* @template T - The type of the items.
+* @param sort - The query's sort.
+* @param fields - The query's projection, if any.
+* @returns `true` when the sort can still be applied to the projected items.
+*/
+function sortKeysSurviveProjection(sort, fields) {
+	if (fields == null) return true;
+	const specKeys = Object.keys(fields);
+	const spec = fields;
+	const excluding = specKeys.length > 0 && specKeys.every((key) => !spec[key]);
+	const covers = (key) => specKeys.some((entry) => entry === key || key.startsWith(`${entry}.`));
+	return Object.keys(sort).every((key) => excluding ? !covers(key) : covers(key));
+}
+/**
+* The pre-`query` read path: the primary key if the selector is one, then a declared index, then
+* the whole store.
+*
+* The `id` fast path is not an optimisation on top of the index machinery, it is the only way a
+* primary-key lookup works at all: `id` is never a *declared* index — `readIds` is exactly the
+* lookup it describes — so a selector of `{ id: … }` matches no index and would otherwise fall
+* through to `readAll`. All three adapters carried their own copy of it; losing it here turned
+* every point read into a full scan, which is how it was noticed.
+* @template T - The type of the items.
+* @template I - The type of the item ids.
+* @param storageAdapter - The storage adapter to read from.
+* @param indices - The fields this collection has declared indices for.
+* @param selector - The query's selector.
+* @returns Every stored item the selector matches.
+*/
+async function readMatching(storageAdapter, indices, selector) {
+	if (Object.keys(selector).length === 1 && "id" in selector) {
+		const idResult = idIndexQuery(selector);
+		if (idResult.matched) return storageAdapter.readIds(compact(idResult.ids));
 	}
-	return {
-		enqueue,
-		flush
+	const indexInfo = await getIndexInfo(indices.map((field) => storageIndexQuery(storageAdapter, field)), selector);
+	const matchItems = (item) => {
+		if (indexInfo.optimizedSelector == null) return true;
+		if (Object.keys(indexInfo.optimizedSelector).length <= 0) return true;
+		return match(item, indexInfo.optimizedSelector);
 	};
+	if (indexInfo.matched) {
+		const items = await storageAdapter.readIds(indexInfo.ids);
+		if (isEqual(indexInfo.optimizedSelector, {})) return items;
+		return items.filter(matchItems);
+	}
+	const allItems = await storageAdapter.readAll();
+	if (isEqual(selector, {})) return allItems;
+	return allItems.filter(matchItems);
 }
 //#endregion
-export { batchOnNextTick as default };
+export { executeStorageQuery as default };