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

package/dist/index34.cjs.js

@@ -1,453 +1,53 @@
-const require_isEqual = require("./index2.cjs.js");
-const require_queryDelta = require("./index4.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");
-const require_idIndexQuery = require("./index27.cjs.js");
-const require_storageIndexQuery = require("./index33.cjs.js");
-//#region src/AsyncDataAdapter.ts
+const require_getMatchingKeys = require("./index14.cjs.js");
+//#region src/utils/storageIndexQuery.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;
-	}
-};
-/**
-* Turns the item states a write produced into the upsert/delete split a query update needs.
+* Builds the index provider a data adapter uses to narrow a selector down through
+* a storage adapter's index.
 *
-* 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.
-*/
-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))
-	};
-}
-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.
+* Every adapter that keeps its data in a `StorageAdapter` needs exactly this, and
+* each of them used to carry its own copy — three transcriptions of one set of
+* rules about null, `$exists`, inclusion and exclusion, which is how they drift
+* apart without anyone noticing. The index is keyed by `serializeValue(value)`,
+* which is what `getMatchingKeys` produces, so the two only agree while they stay
+* in one place.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param storage - The storage adapter holding the index.
+* @param field - The indexed field this provider answers for.
+* @returns A query function for `getIndexInfo`.
 */
-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));
-			}
-		}
-		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_);
-		}
-	}
-	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) {
-			const idResult = require_idIndexQuery.default(selector);
-			if (idResult.matched) return {
-				matched: true,
-				ids: idResult.ids.filter(Boolean),
-				optimizedSelector: {}
-			};
-		}
-		if (selector == null) return {
-			matched: false,
-			ids: [],
-			optimizedSelector: {}
-		};
-		return require_getIndexInfo.default((this.collectionIndices.get(collectionName) ?? []).map((field) => require_storageIndexQuery.default(storageAdapter, field)), 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);
+function storageIndexQuery(storage, field) {
+	return async (flatSelector) => {
+		if (!Object.hasOwnProperty.call(flatSelector, field)) return { matched: false };
+		const index = await storage.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 id of set) includedIds.push(id);
+		else for (const key of keys.include) {
+			const idSet = index.get(key);
+			if (idSet) for (const id of idSet) includedIds.push(id);
 		}
-	}
-	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);
-	}
-	/**
-	* 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
-	*/
-	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;
+		if (keys.exclude != null) {
+			const excludedIds = /* @__PURE__ */ new Set();
+			for (const key of keys.exclude) {
+				const idSet = index.get(key);
+				if (idSet) for (const id of idSet) excludedIds.add(id);
 			}
-			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: []
-		});
-		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`);
+			includedIds = includedIds.filter((id) => !excludedIds.has(id));
 		}
-		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
+		return {
+			matched: true,
+			ids: includedIds,
+			fields: [field],
+			keepSelector: filtersForNull
 		};
-		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;
-	}
-};
+	};
+}
 //#endregion
-exports.default = AsyncDataAdapter;
+exports.default = storageIndexQuery;