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

package/dist/index40.mjs

@@ -0,0 +1,484 @@
+import isEqual from "./index2.mjs";
+import deepClone from "./index18.mjs";
+import match from "./index19.mjs";
+import modify from "./index20.mjs";
+import queryId from "./index26.mjs";
+import executeStorageQuery from "./index35.mjs";
+//#region src/AutoFetchDataAdapter.ts
+/**
+* Default merge strategy: shallow spread (right wins)
+* @param a first item
+* @param b second item
+* @returns merged item
+*/
+function defaultMergeItems(a, b) {
+	return {
+		...a,
+		...b
+	};
+}
+/**
+* Generates a stable key for a selector
+* @param selector - the selector
+* @returns the key
+*/
+function selectorId(selector) {
+	return JSON.stringify(selector ?? {});
+}
+/**
+* AutoFetchDataAdapter
+*
+* A DataAdapter that:
+* - Mirrors the CollectionBackend surface (CRUD + query registry + lifecycle)
+* - Executes queries against a provided StorageAdapter (local cache)
+* - On first registration of a selector, auto-fetches from a remote source and
+*   ingests the result into storage (upsert), then pushes query result updates
+* - Optionally purges auto-fetched items for a selector once no observers remain
+* - Can subscribe to remote change notifications to re-fetch active selectors
+*
+* IMPORTANT: Purging only ever deletes items that were introduced via the
+* auto-fetch path and are no longer referenced by any active selector. Items
+* inserted through CRUD calls are never purged.
+*/
+var AutoFetchDataAdapter = class {
+	options;
+	id;
+	onError;
+	fetchQueryItems;
+	mergeItems;
+	purgeDelay;
+	storageAdapters = /* @__PURE__ */ new Map();
+	storageAdapterReady = /* @__PURE__ */ new Map();
+	collectionIndices = /* @__PURE__ */ new Map();
+	queries = /* @__PURE__ */ new Map();
+	activeObservers = /* @__PURE__ */ new Map();
+	observerTimeouts = /* @__PURE__ */ new Map();
+	selectorIds = /* @__PURE__ */ new Map();
+	idRefCounts = /* @__PURE__ */ new Map();
+	autoloadIds = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		this.id = options.id || "autofetch-data-adapter";
+		this.onError = options.onError ?? ((error) => {
+			console.error(error);
+		});
+		this.fetchQueryItems = options.fetchQueryItems;
+		this.mergeItems = options.mergeItems ?? defaultMergeItems;
+		this.purgeDelay = options.purgeDelay ?? 1e4;
+		if (options.registerRemoteChange) options.registerRemoteChange(async () => {
+			await this.forceRefetchAll();
+		});
+	}
+	createCollectionBackend(collection, indices) {
+		this.collectionIndices.set(collection.name, indices);
+		this.queries.set(collection.name, /* @__PURE__ */ new Map());
+		this.ensureStorageAdapter(collection.name);
+		this.activeObservers.set(collection.name, /* @__PURE__ */ new Map());
+		this.observerTimeouts.set(collection.name, /* @__PURE__ */ new Map());
+		this.selectorIds.set(collection.name, /* @__PURE__ */ new Map());
+		this.idRefCounts.set(collection.name, /* @__PURE__ */ new Map());
+		this.autoloadIds.set(collection.name, /* @__PURE__ */ new Set());
+		const ready = this.setupStorage(collection.name, indices);
+		this.storageAdapterReady.set(collection.name, ready);
+		const registerQuery = (selector, options) => {
+			const qid = queryId(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
+			});
+			const key = selectorId(selector);
+			const perColObservers = this.activeObservers.get(collection.name);
+			const current = perColObservers?.get(key)?.count ?? 0;
+			perColObservers?.set(key, {
+				selector,
+				count: current + 1
+			});
+			const t = this.observerTimeouts.get(collection.name)?.get(key);
+			if (t) clearTimeout(t);
+			if (current === 0) this.fetchAndIngest(collection.name, selector).catch(this.onError);
+			this.fulfillQuery(collection.name, selector, options).catch(this.onError);
+		};
+		const unregisterQuery = (selector, options) => {
+			const qid = queryId(selector, options);
+			this.queries.get(collection.name)?.delete(qid);
+			const key = selectorId(selector);
+			const perColObservers = this.activeObservers.get(collection.name);
+			const current = perColObservers?.get(key)?.count ?? 0;
+			const remaining = Math.max(0, current - 1);
+			if (remaining > 0) {
+				perColObservers?.set(key, {
+					selector,
+					count: remaining
+				});
+				return;
+			}
+			const doPurge = () => {
+				perColObservers?.delete(key);
+				this.purgeSelector(collection.name, selector).catch(this.onError);
+			};
+			if (this.purgeDelay === 0) doPurge();
+			else {
+				const timeouts = this.observerTimeouts.get(collection.name);
+				const t = timeouts?.get(key);
+				if (t) clearTimeout(t);
+				timeouts?.set(key, setTimeout(doPurge, this.purgeDelay));
+			}
+		};
+		const getQueryState = (selector, options) => {
+			return (this.queries.get(collection.name)?.get(queryId(selector, options)))?.state ?? "active";
+		};
+		const getQueryError = (selector, options) => {
+			return (this.queries.get(collection.name)?.get(queryId(selector, options)))?.error ?? null;
+		};
+		const getQueryResult = (selector, options) => {
+			return (this.queries.get(collection.name)?.get(queryId(selector, options)))?.items ?? [];
+		};
+		const onQueryStateChange = (selector, options, callback) => {
+			const qid = queryId(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);
+			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,
+			getQueryState,
+			getQueryError,
+			getQueryResult,
+			onQueryStateChange,
+			executeQuery: async (selector, options) => {
+				await ready;
+				registerQuery(selector, options);
+				await new Promise((resolve) => {
+					let stop = () => {};
+					stop = onQueryStateChange(selector, options, (state) => {
+						if (state === "active") return;
+						resolve();
+						stop();
+					});
+				});
+				const result = getQueryResult(selector, options);
+				unregisterQuery(selector, options);
+				return result;
+			},
+			dispose: async () => {
+				this.storageAdapters.delete(collection.name);
+				this.queries.delete(collection.name);
+				this.collectionIndices.delete(collection.name);
+				this.storageAdapterReady.delete(collection.name);
+				this.activeObservers.delete(collection.name);
+				this.observerTimeouts.delete(collection.name);
+				this.selectorIds.delete(collection.name);
+				this.idRefCounts.delete(collection.name);
+				this.autoloadIds.delete(collection.name);
+			},
+			isReady: async () => {
+				await ready;
+			}
+		};
+	}
+	async forceRefetchAll() {
+		const tasks = [];
+		for (const [collectionName, observers] of this.activeObservers.entries()) for (const { selector, count } of observers.values()) if (count > 0) tasks.push(this.fetchAndIngest(collectionName, selector));
+		await Promise.all(tasks);
+	}
+	async fetchAndIngest(collectionName, selector) {
+		this.publishForSelector(collectionName, selector, "active", null);
+		try {
+			const items = await this.fetchQueryItems(collectionName, selector);
+			if (!items || !Array.isArray(items)) throw new Error("AutoFetchDataAdapter: fetchQueryItems must resolve to { items: T[] }");
+			const ids = items.map((i) => i.id);
+			const selectorKey = selectorId(selector);
+			const selMap = this.selectorIds.get(collectionName);
+			const previous = selMap?.get(selectorKey) ?? /* @__PURE__ */ new Set();
+			ids.forEach((id) => previous.add(id));
+			selMap?.set(selectorKey, previous);
+			await this.upsertMerged(collectionName, items);
+			await this.checkQueryUpdates(collectionName, items);
+		} catch (error) {
+			this.publishForSelector(collectionName, selector, "error", error);
+			this.onError(error);
+		}
+	}
+	async purgeSelector(collectionName, selector) {
+		const selectorKey = selectorId(selector);
+		const selMap = this.selectorIds.get(collectionName);
+		const ids = selMap?.get(selectorKey);
+		selMap?.delete(selectorKey);
+		if (!ids || ids.size === 0) return;
+		const referenceMap = this.idRefCounts.get(collectionName);
+		const autoload = this.autoloadIds.get(collectionName);
+		const toRemove = [];
+		for (const id of ids) {
+			const current = referenceMap?.get(id) ?? 0;
+			const next = Math.max(0, current - 1);
+			if (next === 0) {
+				referenceMap?.delete(id);
+				if (autoload?.has(id)) toRemove.push(id);
+			} else referenceMap?.set(id, next);
+		}
+		if (toRemove.length === 0) return;
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		const items = await storage.readIds(toRemove);
+		if (items.length > 0) {
+			await storage.remove(items);
+			await this.checkQueryUpdates(collectionName, items);
+		}
+		toRemove.forEach((id) => autoload?.delete(id));
+	}
+	async setupStorage(collectionName, indices) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		await storage.setup();
+		await Promise.all(indices.map((field) => storage.createIndex(field)));
+	}
+	ensureStorageAdapter(name) {
+		if (this.storageAdapters.has(name)) return;
+		const adapter = this.options.storage && this.options.storage(name);
+		if (!adapter) return;
+		this.storageAdapters.set(name, adapter);
+	}
+	publishForSelector(collectionName, selector, state, error) {
+		const registry = this.queries.get(collectionName);
+		if (!registry) return;
+		for (const query of registry.values()) {
+			if (!isEqual(query.selector, selector)) continue;
+			this.publishState(collectionName, queryId(query.selector, query.options), state, error);
+		}
+	}
+	publishState(collectionName, qid, state, error) {
+		const query = this.queries.get(collectionName)?.get(qid);
+		if (!query) return;
+		query.state = state;
+		query.error = error;
+		for (const callback of query.listeners) try {
+			callback(state);
+		} catch (error_) {
+			this.onError(error_);
+		}
+	}
+	publishResult(collectionName, qid, items) {
+		const query = this.queries.get(collectionName)?.get(qid);
+		if (!query) return;
+		query.items = items;
+		this.queries.get(collectionName)?.set(qid, query);
+	}
+	async fulfillQuery(collectionName, selector, options) {
+		const qid = queryId(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);
+		try {
+			const items = await this.executeQuery(collectionName, selector, options);
+			this.publishResult(collectionName, qid, items);
+			this.publishState(collectionName, qid, "complete", null);
+		} catch (error) {
+			this.publishState(collectionName, qid, "error", error);
+		}
+	}
+	/**
+	* Reads one query's result from the local storage adapter.
+	*
+	* Shares `executeStorageQuery` with the other adapters — the projection this
+	* used to do by hand was `projectItems` spelled out, so nothing about the
+	* result changes.
+	* @template T - The type of the items.
+	* @template I - The type of the item ids.
+	* @param collectionName - The collection to read from.
+	* @param selector - The query's selector.
+	* @param options - The query's sort, window and projection.
+	* @returns The query result.
+	*/
+	async executeQuery(collectionName, selector, options) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		return executeStorageQuery(storage, this.collectionIndices.get(collectionName) ?? [], selector, options);
+	}
+	async checkQueryUpdates(collectionName, changedItems) {
+		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 }) => changedItems.some((item) => match(item, selector)));
+		if (affected.length === 0) return;
+		for (const { selector, options } of affected) {
+			const qid = queryId(selector, options);
+			this.publishState(collectionName, qid, "active", null);
+		}
+		await Promise.all(affected.map(async ({ selector, options }) => {
+			const qid = queryId(selector, options);
+			try {
+				const items = await this.executeQuery(collectionName, selector, options);
+				this.publishResult(collectionName, qid, items);
+				this.publishState(collectionName, qid, "complete", null);
+			} catch (error) {
+				this.publishState(collectionName, qid, "error", error);
+			}
+		}));
+	}
+	async insert(collectionName, newItem) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		if ((await this.executeQuery(collectionName, { id: newItem.id }, { limit: 1 })).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 storage adapter for collection ${collectionName}`);
+		const [item] = await this.executeQuery(collectionName, selector, { limit: 1 });
+		const { $setOnInsert, ...rest } = modifier;
+		if (item == null) return [];
+		const modified = modify(deepClone(item), rest);
+		if (item.id !== modified.id) {
+			if ((await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 })).length > 0) throw new Error(`Item with id ${String(modified.id)} already exists`);
+		}
+		await storage.replace([modified]);
+		await this.checkQueryUpdates(collectionName, [item, modified]);
+		return {
+			items: [modified],
+			previousItems: [item]
+		};
+	}
+	async updateMany(collectionName, selector, modifier) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage 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 = modify(deepClone(item), rest);
+			if (item.id !== modified.id) {
+				if ((await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 })).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 {
+			items: changed,
+			previousItems: items
+		};
+	}
+	async replaceOne(collectionName, selector, replacement) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage 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 this.executeQuery(collectionName, { id: modified.id }, { limit: 1 })).length > 0) throw new Error(`Item with id ${String(modified.id)} already exists`);
+		}
+		await storage.replace([modified]);
+		await this.checkQueryUpdates(collectionName, [item, modified]);
+		return {
+			items: [modified],
+			previousItems: [item]
+		};
+	}
+	async removeOne(collectionName, selector) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage 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 storage 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;
+	}
+	async upsertMerged(collectionName, incoming) {
+		if (incoming.length === 0) return;
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		const ids = incoming.map((i) => i.id);
+		const existing = await storage.readIds(ids);
+		const existingById = new Map(existing.map((it) => [it.id, it]));
+		const toInsert = [];
+		const toReplace = [];
+		const referenceMap = this.idRefCounts.get(collectionName);
+		const autoload = this.autoloadIds.get(collectionName);
+		for (const item of incoming) {
+			const previous = existingById.get(item.id);
+			if (previous) toReplace.push(this.mergeItems(previous, item));
+			else toInsert.push(item);
+			autoload?.add(item.id);
+			referenceMap?.set(item.id, (referenceMap?.get(item.id) ?? 0) + 1);
+		}
+		if (toInsert.length > 0) await storage.insert(toInsert);
+		if (toReplace.length > 0) await storage.replace(toReplace);
+	}
+};
+/**
+* Usage (example):
+*
+* const adapter = new AutoFetchDataAdapter({
+*   storage: (name) => new IndexedDBStorage(name),
+*   fetchQueryItems: async (collectionName, selector) => {
+*     const res = await fetch(`/api/${collectionName}?q=${encodeURIComponent(JSON.stringify(selector||{}))}`)
+*     const items = await res.json()
+*     return { items }
+*   },
+*   registerRemoteChange: (onChange) => subscribeToWS(onChange),
+*   mergeItems: (a, b) => ({ ...a, ...b }),
+*   purgeDelay: 10_000,
+* })
+*
+* const backend = adapter.createCollectionBackend(myCollection, ['status', 'projectId'])
+*/
+//#endregion
+export { AutoFetchDataAdapter as default };

package/dist/index5.cjs.js

@@ -103,12 +103,12 @@ var Observer = class {
 			return;
 		}
 		const beforeOf = (index) => nextItems[index + 1] || null;
-		const previousById = delta.removed.length > 0 && this.hasCallbacks(["removed"]) || delta.changed.length > 0 && this.hasCallbacks(["changedField"]) ? new Map(this.previousItems.map((item) => [item.id, item])) : null;
+		const previousById = delta.removed.length > 0 && this.hasCallbacks(["removed"]) || delta.changed.length > 0 && this.hasCallbacks(["changed", "changedField"]) ? new Map(this.previousItems.map((item) => [item.id, item])) : null;
 		if (this.hasCallbacks(["changed", "changedField"])) delta.changed.forEach((item) => {
-			this.call("changed", item);
-			if (!this.hasCallbacks(["changedField"])) return;
 			const oldItem = previousById?.get(item.id);
 			if (!oldItem) return;
+			this.call("changed", item, oldItem);
+			if (!this.hasCallbacks(["changedField"])) return;
 			require_uniqueBy.default([...Object.keys(item), ...Object.keys(oldItem)], (value) => value).forEach((key) => {
 				if (require_isEqual.default(item[key], oldItem[key])) return;
 				this.call("changedField", item, key, oldItem[key], item[key]);

package/dist/index5.mjs

@@ -103,12 +103,12 @@ var Observer = class {
 			return;
 		}
 		const beforeOf = (index) => nextItems[index + 1] || null;
-		const previousById = delta.removed.length > 0 && this.hasCallbacks(["removed"]) || delta.changed.length > 0 && this.hasCallbacks(["changedField"]) ? new Map(this.previousItems.map((item) => [item.id, item])) : null;
+		const previousById = delta.removed.length > 0 && this.hasCallbacks(["removed"]) || delta.changed.length > 0 && this.hasCallbacks(["changed", "changedField"]) ? new Map(this.previousItems.map((item) => [item.id, item])) : null;
 		if (this.hasCallbacks(["changed", "changedField"])) delta.changed.forEach((item) => {
-			this.call("changed", item);
-			if (!this.hasCallbacks(["changedField"])) return;
 			const oldItem = previousById?.get(item.id);
 			if (!oldItem) return;
+			this.call("changed", item, oldItem);
+			if (!this.hasCallbacks(["changedField"])) return;
 			uniqueBy([...Object.keys(item), ...Object.keys(oldItem)], (value) => value).forEach((key) => {
 				if (isEqual(item[key], oldItem[key])) return;
 				this.call("changedField", item, key, oldItem[key], item[key]);

package/dist/index6.cjs.js

@@ -301,3 +301,4 @@ var Cursor = class {
 };
 //#endregion
 exports.default = Cursor;
+exports.isInReactiveScope = isInReactiveScope;

package/dist/index6.mjs

@@ -300,4 +300,4 @@ var Cursor = class {
 	}
 };
 //#endregion
-export { Cursor as default };
+export { Cursor as default, isInReactiveScope };

package/dist/types/StorageAdapter.d.ts

@@ -1,8 +1,63 @@
+import { BaseItem, FieldSpecifier, SortSpecifier } from '../Collection';
+import { default as Selector } from './Selector';
 export interface Changeset<T> {
     added: T[];
     modified: T[];
     removed: T[];
 }
+/**
+ * What a caller wants answered, in one piece.
+ *
+ * The same four options a query carries (`DataAdapter`'s `QueryOptions`) plus
+ * the selector, so an adapter that can push some of them down to its backing
+ * store sees the whole question rather than a filter at a time.
+ */
+export interface StorageQuery<T extends BaseItem> {
+    selector: Selector<T>;
+    sort?: SortSpecifier<T> | undefined;
+    skip?: number | undefined;
+    limit?: number | undefined;
+    fields?: FieldSpecifier<T> | undefined;
+}
+/**
+ * What an adapter answered, and how much of the question it actually took on.
+ *
+ * Every flag defaults to "no": an adapter says only what it did, and the
+ * caller does the rest in JavaScript, exactly as it does for an adapter with
+ * no `query` at all. That is what makes partial support the normal case rather
+ * than a special one — an adapter may translate an equality and decline a
+ * `$regex`, or sort but not window, and never has to understand a selector it
+ * does not recognise.
+ *
+ * Three combinations are contradictions rather than choices, and
+ * `executeStorageQuery` throws on them rather than returning a wrong result
+ * quietly:
+ *
+ * - `windowed` without having applied the whole selector — the rows it dropped
+ *   at the window's edge may be rows the caller was going to filter out, so the
+ *   window is over the wrong set and nothing can repair it.
+ * - `windowed` without `sorted`, when a sort was asked for — the same, one step
+ *   earlier: a window over an unordered set is an arbitrary subset.
+ * - `projected` without `sorted`, when the sort is on a field the projection
+ *   dropped — the caller is then asked to sort by something that is no longer
+ *   there. This is the trap `incrementalQueryUpdate` already documents.
+ */
+export interface StorageQueryAnswer<T extends BaseItem> {
+    items: T[];
+    /**
+     * The part of the selector the adapter could *not* apply, for the caller to
+     * evaluate over `items`. Omit it, or give `{}`, to say the whole selector was
+     * applied. This mirrors `getIndexInfo`'s `optimizedSelector`: an adapter
+     * narrows as far as it can and hands back what is left.
+     */
+    residualSelector?: Selector<T>;
+    /** The items are in the requested order. */
+    sorted?: boolean;
+    /** `skip` and `limit` have already been applied. */
+    windowed?: boolean;
+    /** The items already carry only the requested fields. */
+    projected?: boolean;
+}
 export default interface StorageAdapter<T extends {
     id: I;
 } & Record<string, any>, I> {
@@ -10,6 +65,28 @@ export default interface StorageAdapter<T extends {
     teardown(): Promise<void>;
     readAll(): Promise<T[]>;
     readIds(positions: I[]): Promise<T[]>;
+    /**
+     * Answers a whole query — predicate, order, window and projection — as far as
+     * the backing store can.
+     *
+     * **Optional, and a pure optimisation.** An adapter that does not implement
+     * it is read through `readIds`/`readAll` and filtered, sorted, windowed and
+     * projected in JavaScript, which is what every adapter did before this
+     * existed and what several of them can only ever do: a store that holds one
+     * blob — `localstorage`, `fs`, `opfs` — has no way to answer less than all of
+     * it, and implementing this to do the same work behind a new name would buy
+     * nothing.
+     *
+     * It exists because without it there is no way to *express* a bounded read.
+     * `limit` costs exactly what no limit costs when the store hands over every
+     * matching row first, so nobody writes one, and a query over a table that
+     * grows with a user's history stays proportional to that history however
+     * carefully its consumer is written.
+     *
+     * An adapter may always answer less than it was asked; see
+     * `StorageQueryAnswer` for what it must not claim.
+     */
+    query?(query: StorageQuery<T>): Promise<StorageQueryAnswer<T>>;
     createIndex(field: string): Promise<void>;
     dropIndex(field: string): Promise<void>;
     /**
@@ -19,6 +96,9 @@ export default interface StorageAdapter<T extends {
      * makes `3`, `'3'` and `new Date(...)` comparable as map keys at all. An
      * adapter that stores its backend's own keys instead answers nothing for
      * every non-string field, and everything for a `$ne` on one.
+     *
+     * Never consulted for a query an adapter answered through `query` itself —
+     * that adapter's own store already did the narrowing this index exists for.
      */
     readIndex(field: string): Promise<Map<string | null, Set<I>>>;
     insert(items: T[]): Promise<void>;

package/dist/utils/executeStorageQuery.d.ts

@@ -0,0 +1,28 @@
+import { BaseItem } from '../Collection';
+import { default as Selector } from '../types/Selector';
+import { default as StorageAdapter, StorageQuery } from '../types/StorageAdapter';
+type QueryShape<T extends BaseItem> = Omit<StorageQuery<T>, 'selector'>;
+/**
+ * Runs one query against a storage adapter and returns its finished result.
+ *
+ * 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.
+ */
+export default function executeStorageQuery<T extends BaseItem<I>, I = any>(storageAdapter: StorageAdapter<any, any>, indices: string[], selector: Selector<T> | null, options?: QueryShape<T>): Promise<T[]>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaldb/core",
-  "version": "2.0.0-beta.21",
+  "version": "2.0.0-beta.22",
   "description": "SignalDB is a client-side database that provides a simple MongoDB-like interface to the data with first-class typescript support to achieve an optimistic UI. Data persistence can be achieved by using storage providers that store the data through a JSON interface to places such as localStorage.",
   "scripts": {
     "build": "rimraf dist && vite build",