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

package/dist/index36.cjs.js

@@ -0,0 +1,389 @@
+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");
+const require_compact = require("./index35.cjs.js");
+//#region src/WorkerDataAdapterHost.ts
+/**
+* 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.
+*/
+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 WorkerDataAdapterHost = class {
+	workerContext;
+	options;
+	id;
+	log = () => {};
+	storageAdapters = /* @__PURE__ */ new Map();
+	storageAdapterReady = /* @__PURE__ */ new Map();
+	collectionIndices = /* @__PURE__ */ new Map();
+	queries = /* @__PURE__ */ new Map();
+	onError = (error) => {
+		console.error(error);
+	};
+	constructor(workerContext, options) {
+		this.workerContext = workerContext;
+		this.options = options;
+		this.id = this.options.id || "default-worker-data-adapter";
+		if (this.options.onError) this.onError = this.options.onError;
+		if (this.options.log) this.log = this.options.log;
+		this.workerContext.addEventListener("message", async (event) => {
+			try {
+				const { workerId, id, method, args } = event.data;
+				await this.handleMessage(workerId, id, method, args);
+			} catch (error) {
+				this.onError(error);
+			}
+		});
+		this.respond("ready", null, null, "ready");
+	}
+	respond(id, data, error = null, type = "response") {
+		this.workerContext.postMessage({
+			id,
+			workerId: this.id,
+			type,
+			data,
+			error
+		});
+	}
+	async handleMessage(workerId, id, method, args) {
+		if (workerId !== this.id) return;
+		const fn = this[method];
+		if (typeof fn !== "function") {
+			this.respond(id, null, /* @__PURE__ */ new Error(`Method ${method} not found`));
+			return;
+		}
+		this.log(method, ...args);
+		await this.isReady(args[0]);
+		try {
+			const result = await fn.apply(this, args);
+			this.respond(id, result);
+		} catch (error) {
+			this.respond(id, null, error);
+		}
+	}
+	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: require_compact.default([selector.id]),
+			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 filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
+			const keys = filteresForNull ? {
+				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: filteresForNull
+			};
+		}), selector);
+	}
+	async queryItems(collectionName, selector) {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const indexInfo = await this.getIndexInfo(collectionName, 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);
+		} else {
+			const allItems = await storageAdapter.readAll();
+			if (require_isEqual.default(selector, {})) return allItems;
+			return allItems.filter(matchItems);
+		}
+	}
+	async executeQuery(collectionName, selector, options) {
+		if (selector === null) return [];
+		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);
+	}
+	ensureQuery(collectionName, selector, options) {
+		const id = require_queryId.default(selector, options);
+		if (!this.queries.get(collectionName)) throw new Error(`Collection ${collectionName} not initialized!`);
+		let query = this.queries.get(collectionName)?.get(id);
+		if (!query) {
+			query = {
+				selector,
+				options,
+				items: null
+			};
+			this.queries.get(collectionName)?.set(id, query);
+		}
+		return query;
+	}
+	setQueryItems(query, items) {
+		query.items = items;
+		query.itemIds = void 0;
+	}
+	queryItemIds(query) {
+		if (!query.itemIds) query.itemIds = new Set((query.items ?? []).map((item) => item.id));
+		return query.itemIds;
+	}
+	emitQueryUpdate(collectionName, selector, options, state, error, items, delta) {
+		const id = require_queryId.default(selector, options);
+		if (!this.queries.get(collectionName)) throw new Error(`Collection ${collectionName} not initialized!`);
+		this.respond(id, {
+			collectionName,
+			qid: id,
+			selector,
+			options,
+			state,
+			error,
+			items,
+			delta
+		}, null, "queryUpdate");
+	}
+	ensureStorageAdapter(name) {
+		if (this.storageAdapters.has(name)) return;
+		const adapter = this.options.storage(name);
+		if (!adapter) return;
+		this.storageAdapters.set(name, adapter);
+	}
+	async checkQueryUpdates(collectionName, changes) {
+		const queries = this.queries.get(collectionName);
+		if (!queries) throw new Error(`Collection ${collectionName} not initialized!`);
+		if (changes.upserts.length === 0 && changes.deletes.length === 0) return;
+		const affectedQueries = [...queries.values()].filter((query) => {
+			const ids = this.queryItemIds(query);
+			if (changes.deletes.some((id) => ids.has(id))) return true;
+			return changes.upserts.some((item) => ids.has(item.id) || require_match.default(item, query.selector));
+		});
+		if (affectedQueries.length === 0) return;
+		await Promise.all(affectedQueries.map(async (query) => {
+			const { selector, options } = query;
+			const previous = query.items;
+			const incremental = previous == null ? null : require_incrementalQueryUpdate.default(previous, selector, options, changes);
+			if (incremental != null) {
+				const delta = require_queryDelta.diffQueryResults(previous, incremental);
+				if (require_queryDelta.isEmptyQueryDelta(delta)) return;
+				this.setQueryItems(query, incremental);
+				this.emitQueryUpdate(collectionName, selector, options, "complete", null, void 0, delta);
+				return;
+			}
+			this.emitQueryUpdate(collectionName, selector, options, "active", null);
+			const queryItems = await this.executeQuery(collectionName, selector, options);
+			if (previous == null) {
+				this.setQueryItems(query, queryItems);
+				this.emitQueryUpdate(collectionName, selector, options, "complete", null, queryItems);
+				return;
+			}
+			const delta = require_queryDelta.diffQueryResults(previous, queryItems);
+			this.setQueryItems(query, queryItems);
+			this.emitQueryUpdate(collectionName, selector, options, "complete", null, void 0, delta);
+		}));
+	}
+	registerCollection = async (collectionName, indices) => {
+		this.collectionIndices.set(collectionName, indices);
+		this.queries.set(collectionName, /* @__PURE__ */ new Map());
+		this.ensureStorageAdapter(collectionName);
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const setupPromise = (async () => {
+			await storageAdapter.setup();
+			await Promise.all(indices.map((index) => storageAdapter.createIndex(index)));
+		})();
+		this.storageAdapterReady.set(collectionName, setupPromise);
+		await setupPromise;
+	};
+	unregisterCollection = async (collectionName) => {
+		this.storageAdapters.delete(collectionName);
+		this.queries.delete(collectionName);
+	};
+	registerQuery = async (collectionName, selector, options) => {
+		const query = this.ensureQuery(collectionName, selector, options);
+		const queryItems = await this.executeQuery(collectionName, selector, options);
+		this.setQueryItems(query, queryItems);
+		this.emitQueryUpdate(collectionName, selector, options, "complete", null, queryItems);
+	};
+	unregisterQuery = async (collectionName, selector, options) => {
+		const id = require_queryId.default(selector, options);
+		if (!this.queries.get(collectionName)) throw new Error(`Collection ${collectionName} not initialized!`);
+		this.queries.get(collectionName)?.delete(id);
+	};
+	insert = async (collectionName, input) => {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const existingItems = await this.executeQuery(collectionName, { id: { $in: input.map((i) => i[0].id) } });
+		const result = input.map(([item]) => {
+			if (item.id == null) return /* @__PURE__ */ new Error("Item must have an id");
+			if (existingItems.some((existing) => existing.id === item.id)) return /* @__PURE__ */ new Error(`Item with id ${item.id} already exists`);
+			return item;
+		});
+		const newItems = result.filter((item) => !(item instanceof Error));
+		await storageAdapter.insert(newItems);
+		await this.checkQueryUpdates(collectionName, {
+			upserts: newItems,
+			deletes: []
+		});
+		return result;
+	};
+	updateOne = async (collectionName, parameters) => {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const previousItems = [];
+		const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
+			const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
+			const { $setOnInsert, ...restModifier } = modifier;
+			if (item == null) return [];
+			previousItems.push(item);
+			const modifiedItem = require_modify.default(require_deepClone.default(item), restModifier);
+			if (item.id !== modifiedItem.id) {
+				if ((await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 })).length > 0) return /* @__PURE__ */ new Error(`Item with id ${modifiedItem.id} already exists`);
+			}
+			return [modifiedItem];
+		}));
+		const modifiedItems = require_compact.default(result.filter((item) => !(item instanceof Error)).flat());
+		if (modifiedItems.length > 0) {
+			await storageAdapter.replace(modifiedItems);
+			await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
+		}
+		return result;
+	};
+	updateMany = async (collectionName, parameters) => {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const previousItems = [];
+		const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
+			const items = await this.executeQuery(collectionName, selector);
+			if (items.length === 0) return [];
+			const { $setOnInsert, ...restModifier } = modifier;
+			try {
+				return await Promise.all(items.map(async (item) => {
+					const modifiedItem = require_modify.default(require_deepClone.default(item), restModifier);
+					if (item.id !== modifiedItem.id) {
+						if ((await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 })).length > 0) throw new Error(`Item with id ${modifiedItem.id} already exists`);
+					}
+					previousItems.push(item);
+					return modifiedItem;
+				}));
+			} catch (error) {
+				return error;
+			}
+		}));
+		const modifiedItems = require_compact.default(result.filter((item) => !(item instanceof Error)).flat());
+		if (modifiedItems.length > 0) {
+			await storageAdapter.replace(modifiedItems);
+			await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
+		}
+		return result;
+	};
+	replaceOne = async (collectionName, parameters) => {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const previousItems = [];
+		const result = await Promise.all(parameters.map(async ([selector, replacement]) => {
+			const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
+			if (item == null) return [];
+			previousItems.push(item);
+			const modifiedItem = {
+				...replacement,
+				id: replacement.id ?? item.id
+			};
+			if (item.id !== modifiedItem.id) {
+				if ((await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 })).length > 0) return /* @__PURE__ */ new Error(`Item with id ${modifiedItem.id} already exists`);
+			}
+			return [modifiedItem];
+		}));
+		const modifiedItems = require_compact.default(result.filter((item) => !(item instanceof Error)).flat());
+		if (modifiedItems.length > 0) {
+			await storageAdapter.replace(modifiedItems);
+			await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
+		}
+		return result;
+	};
+	removeOne = async (collectionName, selectors) => {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const result = await Promise.all(selectors.map(async ([selector]) => {
+			const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
+			if (item == null) return [];
+			return [item];
+		}));
+		const items = result.flat();
+		if (items.length > 0) {
+			await storageAdapter.remove(items);
+			await this.checkQueryUpdates(collectionName, {
+				upserts: [],
+				deletes: items.map((item) => item.id)
+			});
+		}
+		return result;
+	};
+	removeMany = async (collectionName, selectors) => {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
+		const result = await Promise.all(selectors.map(async ([selector]) => this.executeQuery(collectionName, selector)));
+		const items = result.flat();
+		if (items.length > 0) {
+			await storageAdapter.remove(items);
+			await this.checkQueryUpdates(collectionName, {
+				upserts: [],
+				deletes: items.map((item) => item.id)
+			});
+		}
+		return result;
+	};
+	isReady = async (collectionName) => {
+		return this.storageAdapterReady.get(collectionName);
+	};
+};
+//#endregion
+exports.default = WorkerDataAdapterHost;