@signaldb/core 2.0.0-beta.6 → 2.0.0-beta.8

package/dist/index16.mjs

@@ -1,389 +1,136 @@
-import deepClone from "./index20.mjs";
-import match from "./index24.mjs";
-import modify from "./index7.mjs";
-import queryId from "./index21.mjs";
-import isEqual from "./index6.mjs";
-import getIndexInfo from "./index23.mjs";
-import getMatchingKeys from "./index27.mjs";
-import sortItems from "./index26.mjs";
-import project from "./index25.mjs";
-import compact from "./index29.mjs";
-class WorkerDataAdapterHost {
-  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;
-    if (typeof addEventListener === "undefined" || typeof postMessage === "undefined") {
-      throw new TypeError("WorkerDataAdapterHost can only be used in a Web Worker context");
-    }
-    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, 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: compact([selector.id]),
-        optimizedSelector: {}
-      };
-    }
-    if (selector == null) {
-      return {
-        matched: false,
-        ids: [],
-        optimizedSelector: {}
-      };
-    }
-    const indices = this.collectionIndices.get(collectionName) ?? [];
-    return getIndexInfo(indices.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) } : getMatchingKeys(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;
-      const matches = match(item, indexInfo.optimizedSelector);
-      return matches;
-    };
-    if (indexInfo.matched) {
-      const items = await storageAdapter.readIds(indexInfo.ids);
-      if (isEqual(indexInfo.optimizedSelector, {}))
-        return items;
-      return items.filter(matchItems);
-    } else {
-      const allItems = await storageAdapter.readAll();
-      if (isEqual(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 ? sortItems(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 },
-        ...project(item, fields)
-      };
-    });
-  }
-  ensureQuery(collectionName, selector, options) {
-    const id = queryId(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 };
-      this.queries.get(collectionName)?.set(id, query);
-    }
-    return query;
-  }
-  emitQueryUpdate(collectionName, selector, options, state, error, items) {
-    const id = queryId(selector, options);
-    const collectionQueries = this.queries.get(collectionName);
-    if (!collectionQueries)
-      throw new Error(`Collection ${collectionName} not initialized!`);
-    this.respond(id, { collectionName, selector, options, state, error, items }, 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, items) {
-    const queries = this.queries.get(collectionName);
-    if (!queries)
-      throw new Error(`Collection ${collectionName} not initialized!`);
-    const affectedQueries = [...queries.values()].filter(({ selector }) => items.some((item) => match(item, selector))) ?? [];
-    if (affectedQueries.length === 0)
-      return;
-    affectedQueries.forEach(({ selector, options }) => {
-      this.emitQueryUpdate(collectionName, selector, options, "active", null);
-    });
-    await Promise.all(affectedQueries.map(async ({ selector, options }) => {
-      const queryItems = await this.executeQuery(collectionName, selector, options);
-      this.emitQueryUpdate(collectionName, selector, options, "complete", null, queryItems);
-    }));
-  }
-  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) => {
-    this.ensureQuery(collectionName, selector, options);
-    const queryItems = await this.executeQuery(collectionName, selector, options);
-    this.emitQueryUpdate(collectionName, selector, options, "complete", null, queryItems);
-  };
-  unregisterQuery = async (collectionName, selector, options) => {
-    const id = queryId(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 new Error("Item must have an id");
-      if (existingItems.some((existing) => existing.id === item.id)) {
-        return 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, newItems);
-    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 = modify(deepClone(item), restModifier);
-      if (item.id !== modifiedItem.id) {
-        const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
-        if (existingItems.length > 0) {
-          return new Error(`Item with id ${modifiedItem.id} already exists`);
-        }
-      }
-      return [modifiedItem];
-    }));
-    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
-    if (modifiedItems.length > 0) {
-      await storageAdapter.replace(modifiedItems);
-      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
-    }
-    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 {
-        const changedItems = await Promise.all(items.map(async (item) => {
-          const modifiedItem = modify(deepClone(item), restModifier);
-          if (item.id !== modifiedItem.id) {
-            const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
-            if (existingItems.length > 0) {
-              throw new Error(`Item with id ${modifiedItem.id} already exists`);
-            }
-          }
-          previousItems.push(item);
-          return modifiedItem;
-        }));
-        return changedItems;
-      } catch (error) {
-        return error;
-      }
-    }));
-    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
-    if (modifiedItems.length > 0) {
-      await storageAdapter.replace(modifiedItems);
-      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
-    }
-    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) {
-        const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
-        if (existingItems.length > 0) {
-          return new Error(`Item with id ${modifiedItem.id} already exists`);
-        }
-      }
-      return [modifiedItem];
-    }));
-    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
-    if (modifiedItems.length > 0) {
-      await storageAdapter.replace(modifiedItems);
-      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
-    }
-    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((items2) => items2[0] ?? null);
-      if (item == null)
-        return [];
-      return [item];
-    }));
-    const items = result.flat();
-    if (items.length > 0) {
-      await storageAdapter.remove(items);
-      await this.checkQueryUpdates(collectionName, items);
-    }
-    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, items);
-    }
-    return result;
-  };
-  isReady = async (collectionName) => {
-    return this.storageAdapterReady.get(collectionName);
-  };
+import intersection from "./index15.mjs";
+//#region src/getIndexInfo.ts
+/**
+* Retrieves merged index information for a given flat selector by querying multiple
+* index providers. Combines results from all index providers to determine matched ids
+* and an optimized selector.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param queryFunctions - An array of index providers to query.
+* @param selector - The flat selector used to filter items.
+* @returns An object containing:
+*   - `matched`: A boolean indicating if the selector matched any items.
+*   - `ids`: An array of matched item ids.
+*   - `optimizedSelector`: A flat selector optimized based on the index results.
+*/
+function getMergedIndexInfo(queryFunctions, selector) {
+	return queryFunctions.reduce((memoOrPromise, queryFunction) => {
+		const resultOrPromise = queryFunction(selector);
+		const processResult = (memo, result) => {
+			if (!result.matched) return memo;
+			const optimizedSelector = result.keepSelector ? memo.optimizedSelector : Object.fromEntries(Object.entries(memo.optimizedSelector).filter(([key]) => !result.fields.includes(key)));
+			return {
+				matched: true,
+				ids: [...new Set(memo.matched ? intersection(memo.ids, result.ids) : result.ids)],
+				optimizedSelector
+			};
+		};
+		if (resultOrPromise instanceof Promise) return resultOrPromise.then(async (result) => {
+			return processResult(memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise, result);
+		});
+		const memo = memoOrPromise;
+		if (memo instanceof Promise) throw new Error("Mixing async and sync index providers is not supported");
+		return processResult(memo, resultOrPromise);
+	}, {
+		matched: false,
+		ids: [],
+		optimizedSelector: { ...selector }
+	});
 }
-export {
-  WorkerDataAdapterHost as default
-};
+/**
+* Optimizes a logic gate ($and/$or) of selectors by querying multiple index providers.
+* @param queryFunctions - An array of index providers to query.
+* @param logicGate - An array of selectors representing the logic gate.
+* @param idsCallback - A callback function called with matched ids.
+* @returns An array of optimized selectors or a promise that resolves to such an array.
+*/
+function optimizeLogicGate(queryFunctions, logicGate, idsCallback) {
+	return logicGate.reduce((memoOrPromise, sel) => {
+		const getSelector = (indexInfo) => {
+			const { matched: selMatched, ids: selIds, optimizedSelector } = indexInfo;
+			if (selMatched) {
+				idsCallback(true, selIds);
+				if (Object.keys(optimizedSelector).length > 0) return optimizedSelector;
+			} else {
+				idsCallback(false, []);
+				return sel;
+			}
+		};
+		const indexInfoOrPromise = getIndexInfo(queryFunctions, sel);
+		if (indexInfoOrPromise instanceof Promise) return indexInfoOrPromise.then(async (indexInfo) => {
+			const memo = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
+			const optimizedSelector = getSelector(indexInfo);
+			if (optimizedSelector) memo.push(optimizedSelector);
+			return memo;
+		});
+		const memo = memoOrPromise;
+		if (memo instanceof Promise) throw new Error("Mixing async and sync index providers is not supported");
+		const optimizedSelector = getSelector(indexInfoOrPromise);
+		if (optimizedSelector) memo.push(optimizedSelector);
+		return memo;
+	}, []);
+}
+/**
+* Retrieves index information for a given complex selector by querying multiple
+* index providers. Handles nested `$and` and `$or` conditions in the selector and
+* optimizes the selector to minimize processing overhead.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param queryFunctions - An array of index providers to query.
+* @param selector - The complex selector used to filter items.
+* @returns An object containing:
+*   - `matched`: A boolean indicating if the selector matched any items.
+*   - `ids`: An array of matched item ids.
+*   - `optimizedSelector`: A selector optimized based on the index results, with unused
+*     conditions removed.
+*/
+function getIndexInfo(queryFunctions, selector) {
+	if (selector == null || Object.keys(selector).length <= 0) return {
+		matched: false,
+		ids: [],
+		optimizedSelector: selector
+	};
+	const { $and, $or, ...rest } = selector;
+	const flatInfoOrPromise = getMergedIndexInfo(queryFunctions, rest);
+	const processFlatInfo = (flatInfo) => {
+		let { matched, ids } = flatInfo;
+		const newSelector = flatInfo.optimizedSelector;
+		const $andNewOrPromise = Array.isArray($and) ? optimizeLogicGate(queryFunctions, $and, (match, selIds) => {
+			if (!match) return;
+			ids = matched ? intersection(ids, selIds) : selIds;
+			matched = true;
+		}) : void 0;
+		const process$and = ($andNew) => {
+			if ($andNew && $andNew.length > 0) newSelector.$and = $andNew;
+			let hasNonIndexField = false;
+			const matchedBefore = matched;
+			const idsBefore = ids;
+			const process$or = ($orNew) => {
+				if (hasNonIndexField || $orNew && $orNew.length > 0) {
+					newSelector.$or = $or;
+					matched = matchedBefore;
+					ids = idsBefore;
+				}
+				return {
+					matched,
+					ids: ids || [],
+					optimizedSelector: newSelector
+				};
+			};
+			const $orNewOrPromise = Array.isArray($or) ? optimizeLogicGate(queryFunctions, $or, (match, selIds) => {
+				if (match) {
+					ids = [...new Set([...ids, ...selIds])];
+					matched = true;
+				} else hasNonIndexField = true;
+			}) : void 0;
+			if ($orNewOrPromise instanceof Promise) return $orNewOrPromise.then(($orNew) => process$or($orNew));
+			return process$or($orNewOrPromise);
+		};
+		if ($andNewOrPromise instanceof Promise) return $andNewOrPromise.then(($andNew) => process$and($andNew));
+		return process$and($andNewOrPromise);
+	};
+	if (flatInfoOrPromise instanceof Promise) return flatInfoOrPromise.then(processFlatInfo);
+	return processFlatInfo(flatInfoOrPromise);
+}
+//#endregion
+export { getIndexInfo as default };

package/dist/index17.cjs.js

@@ -0,0 +1,47 @@
+//#region src/utils/deepClone.ts
+/**
+* Performs a deep clone of a value, supporting various types including arrays, objects,
+* Maps, Sets, Dates, and RegExps. Functions are not supported and will throw an error.
+* @template T - The type of the value to clone.
+* @param value - The value to deep clone.
+* @returns A deep copy of the provided value.
+* @throws {Error} An error if the value is a function, as cloning functions is not supported.
+*/
+function clone(value) {
+	if (typeof value === "function") throw new Error("Cloning functions is not supported");
+	if (value === null || typeof value !== "object") return value;
+	if (value instanceof Date) return new Date(value);
+	if (Array.isArray(value)) return value.map((item) => clone(item));
+	if (value instanceof Map) {
+		const result = /* @__PURE__ */ new Map();
+		value.forEach((currentValue, key) => {
+			result.set(key, clone(currentValue));
+		});
+		return result;
+	}
+	if (value instanceof Set) {
+		const result = /* @__PURE__ */ new Set();
+		value.forEach((currentValue) => {
+			result.add(clone(currentValue));
+		});
+		return result;
+	}
+	if (value instanceof RegExp) return new RegExp(value);
+	const result = {};
+	for (const key in value) if (Object.hasOwnProperty.call(value, key)) result[key] = clone(value[key]);
+	return result;
+}
+/**
+* Creates a deep clone of an object. Uses the `structuredClone` function if available,
+* otherwise falls back to a manual deep clone implementation.
+* @template T - The type of the object to clone.
+* @param object - The object to deep clone.
+* @returns A deep copy of the provided object.
+*/
+function deepClone(object) {
+	if (typeof structuredClone === "function") return structuredClone(object);
+	/* istanbul ignore next -- @preserve */
+	return clone(object);
+}
+//#endregion
+exports.default = deepClone;