@signaldb/core 2.0.0-beta.13 → 2.0.0-beta.14

package/dist/index29.cjs.js

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