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

package/dist/index13.mjs

@@ -1,366 +1,45 @@
-import createIndex from "./index22.mjs";
-import getIndexInfo from "./index23.mjs";
-import deepClone from "./index20.mjs";
-import EventEmitter from "./index9.mjs";
-import isEqual from "./index6.mjs";
-import match from "./index24.mjs";
-import modify from "./index7.mjs";
-import project from "./index25.mjs";
-import queryId from "./index21.mjs";
-import serializeValue from "./index11.mjs";
-import sortItems from "./index26.mjs";
-function hasPendingUpdates(pendingUpdates) {
-  return pendingUpdates.added.length > 0 || pendingUpdates.modified.length > 0 || pendingUpdates.removed.length > 0;
+import isFieldExpression from "./index11.mjs";
+import serializeValue from "./index12.mjs";
+//#region src/utils/getMatchingKeys.ts
+/**
+* Extracts the matching and excluded keys for a given field in a selector.
+* Supports serialized values and `$in`/`$nin` field expressions for optimization.
+* Returns `null` for include/exclude if the field cannot be optimized.
+* @template T - The type of the items in the selector.
+* @template I - The type of the unique identifier for the items.
+* @param field - The name of the field to extract matching keys for.
+* @param selector - The selector object containing query criteria.
+* @returns An object containing arrays of serialized included and excluded keys,
+*   or `null` if the field cannot be optimized.
+*/
+function getMatchingKeys(field, selector) {
+	const result = {
+		include: null,
+		exclude: null
+	};
+	const fieldSelector = selector[field];
+	if (fieldSelector instanceof RegExp) return result;
+	if (fieldSelector == null) return result;
+	if (isFieldExpression(fieldSelector)) {
+		if (fieldSelector.$ne != null) {
+			result.exclude = [serializeValue(fieldSelector.$ne)];
+			return result;
+		}
+		if (Array.isArray(fieldSelector.$in) && fieldSelector.$in.length > 0) {
+			result.include = fieldSelector.$in.map(serializeValue);
+			return result;
+		}
+		if (Array.isArray(fieldSelector.$nin) && fieldSelector.$nin.length > 0) {
+			result.exclude = fieldSelector.$nin.map(serializeValue);
+			return result;
+		}
+		return {
+			include: null,
+			exclude: null
+		};
+	}
+	result.include = [serializeValue(fieldSelector)];
+	return result;
 }
-class DefaultDataAdapter {
-  items = /* @__PURE__ */ new Map();
-  options;
-  storageAdapters = /* @__PURE__ */ new Map();
-  collections = /* @__PURE__ */ new Set();
-  indices = /* @__PURE__ */ new Map();
-  activeQueries = /* @__PURE__ */ new Map();
-  queryEmitters = /* @__PURE__ */ new Map();
-  queuedQueryUpdates = /* @__PURE__ */ new Map();
-  cachedQueryResults = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.options = options || {};
-  }
-  ensureStorageAdapter(name) {
-    if (this.storageAdapters.get(name))
-      return;
-    if (!this.options.storage)
-      return;
-    const adapter = this.options.storage(name);
-    if (!adapter)
-      return;
-    this.storageAdapters.set(name, adapter);
-  }
-  rebuildIndices(collection) {
-    const items = this.items.get(collection.name);
-    if (!items)
-      throw new Error(`Items not found for collection ${collection.name}`);
-    const indices = this.indices.get(collection.name);
-    if (!indices)
-      throw new Error(`Indices not found for collection ${collection.name}`);
-    indices.forEach((index) => index.rebuild([...items.values()]));
-  }
-  async setupStorageAdapter(collection) {
-    const storageAdapter = this.storageAdapters.get(collection.name);
-    if (!storageAdapter)
-      return;
-    return storageAdapter.setup().then(async () => {
-      await this.fetchItemsFromStorage(collection);
-    }).catch((error) => {
-      if (!this.options.onError) {
-        console.error(`Error during data persistence operation in collection ${collection.name}`, error);
-        return;
-      }
-      this.options.onError(collection.name, error instanceof Error ? error : new Error(error));
-    });
-  }
-  getIndexInfo(collection, selector) {
-    if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
-      return {
-        matched: true,
-        ids: [serializeValue(selector.id)],
-        optimizedSelector: {}
-      };
-    }
-    if (selector == null) {
-      return {
-        matched: false,
-        ids: [],
-        optimizedSelector: {}
-      };
-    }
-    return getIndexInfo((this.indices.get(collection.name) ?? []).map((i) => i.query.bind(i)), selector);
-  }
-  applyIndexDeltas(collection, changes) {
-    const indices = this.indices.get(collection.name) ?? [];
-    for (const index of indices) {
-      if (changes.modified)
-        index.update(changes.modified);
-      if (changes.added && changes.added.length > 0)
-        index.insert(changes.added);
-      if (changes.removed && changes.removed.length > 0)
-        index.remove(changes.removed);
-    }
-  }
-  getItem(collection, selector) {
-    const memory = this.items.get(collection.name) ?? /* @__PURE__ */ new Map();
-    const indexInfo = this.getIndexInfo(collection, selector);
-    const items = indexInfo.matched ? indexInfo.ids.map((id) => memory.get(serializeValue(id))).filter((i) => i != null) : [...memory.values()];
-    const item = items.find((document) => match(document, selector));
-    return item;
-  }
-  queryItems(collection, selector) {
-    const indexInfo = this.getIndexInfo(collection, 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;
-    };
-    const items = this.items.get(collection.name);
-    if (!indexInfo.matched) {
-      if (isEqual(selector, {}))
-        return [...items.values()];
-      return [...items.values()].filter(matchItems);
-    }
-    const foundItems = indexInfo.ids.map((ids) => items.get(serializeValue(ids))).filter((i) => i != null);
-    if (isEqual(indexInfo.optimizedSelector, {}))
-      return foundItems;
-    return foundItems.filter(matchItems);
-  }
-  executeQuery(collection, selector, options) {
-    const items = this.queryItems(collection, 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)
-      };
-    });
-  }
-  flushQueuedQueryUpdates(collection) {
-    if (!this.queuedQueryUpdates.get(collection.name))
-      return;
-    const changes = this.queuedQueryUpdates.get(collection.name);
-    if (!changes || !hasPendingUpdates(changes))
-      return;
-    this.queuedQueryUpdates.set(collection.name, { added: [], modified: [], removed: [] });
-    const flatItems = [...changes.added, ...changes.modified, ...changes.removed];
-    const itemIds = new Set(flatItems.map((i) => i.id));
-    const queries = [
-      ...this.activeQueries.get(collection.name)?.values() ?? []
-    ].filter(({ selector, options }) => {
-      const idsInQuery = this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options))?.map((i) => i.id) ?? [];
-      if (idsInQuery.some((id) => itemIds.has(id)))
-        return true;
-      return flatItems.some((item) => match(item, selector));
-    });
-    queries.forEach(({ selector, options }) => {
-      this.executeAndCacheQuery(collection, selector, options);
-    });
-  }
-  executeAndCacheQuery(collection, selector, options) {
-    const result = this.executeQuery(collection, selector, options);
-    this.cachedQueryResults.set(collection.name, this.cachedQueryResults.get(collection.name) || /* @__PURE__ */ new Map());
-    this.cachedQueryResults.get(collection.name)?.set(queryId(selector, options), result);
-    const emitter = this.queryEmitters.get(collection.name);
-    if (!emitter)
-      return;
-    emitter.emit("change", selector, options, "complete");
-  }
-  updateQueries(collection, changes) {
-    this.queuedQueryUpdates.set(collection.name, this.queuedQueryUpdates.get(collection.name) || { added: [], modified: [], removed: [] });
-    this.queuedQueryUpdates.get(collection.name)?.added.push(...changes.added);
-    this.queuedQueryUpdates.get(collection.name)?.modified.push(...changes.modified);
-    this.queuedQueryUpdates.get(collection.name)?.removed.push(...changes.removed);
-    this.flushQueuedQueryUpdates(collection);
-  }
-  createCollectionBackend(collection, indices) {
-    this.collections.add(collection);
-    this.ensureStorageAdapter(collection.name);
-    this.items.set(collection.name, this.items.get(collection.name) ?? /* @__PURE__ */ new Map());
-    this.queryEmitters.set(collection.name, this.queryEmitters.get(collection.name) ?? new EventEmitter());
-    this.queryEmitters.get(collection.name)?.setMaxListeners(Infinity);
-    this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
-    this.indices.set(collection.name, indices.map((field) => createIndex(field)));
-    this.rebuildIndices(collection);
-    const persistenceReadyPromise = this.setupStorageAdapter(collection);
-    const backend = {
-      // CRUD operations
-      insert: async (newItem) => {
-        const items = this.items.get(collection.name);
-        if (!items)
-          throw new Error(`Items not found for collection ${collection.name}`);
-        if (items.has(serializeValue(newItem.id))) {
-          throw new Error(`Item with id '${newItem.id}' already exists`);
-        }
-        this.items.get(collection.name)?.set(serializeValue(newItem.id), newItem);
-        await this.storageAdapters.get(collection.name)?.insert([newItem]);
-        this.applyIndexDeltas(collection, { added: [newItem] });
-        this.updateQueries(collection, {
-          added: [],
-          modified: [newItem],
-          removed: []
-        });
-        return newItem;
-      },
-      updateOne: async (selector, modifier) => {
-        const { $setOnInsert, ...restModifier } = modifier;
-        const item = this.getItem(collection, selector);
-        if (item == null)
-          return [];
-        const modifiedItem = modify(deepClone(item), restModifier);
-        const hasItemWithSameId = item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null;
-        if (hasItemWithSameId) {
-          throw new Error(`Item with id '${modifiedItem.id}' already exists`);
-        }
-        this.items.get(collection.name)?.set(serializeValue(modifiedItem.id), modifiedItem);
-        await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
-        this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
-        this.updateQueries(collection, {
-          added: [],
-          modified: [modifiedItem],
-          removed: []
-        });
-        return [modifiedItem];
-      },
-      updateMany: async (selector, modifier) => {
-        const { $setOnInsert, ...restModifier } = modifier;
-        const items = this.executeQuery(collection, selector, {});
-        const changedItems = items.map((item) => {
-          const modifiedItem = modify(deepClone(item), restModifier);
-          const hasItemWithSameId = item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null;
-          if (hasItemWithSameId) {
-            throw new Error(`Item with id '${modifiedItem.id}' already exists`);
-          }
-          return modifiedItem;
-        });
-        changedItems.forEach((item) => {
-          this.items.get(collection.name)?.set(serializeValue(item.id), item);
-        });
-        await this.storageAdapters.get(collection.name)?.replace(changedItems);
-        const pairs = items.map((oldItem, index) => ({ oldItem, newItem: changedItems[index] }));
-        this.applyIndexDeltas(collection, { modified: pairs });
-        this.updateQueries(collection, {
-          added: [],
-          modified: changedItems,
-          removed: []
-        });
-        return changedItems;
-      },
-      replaceOne: async (selector, replacement) => {
-        const item = this.getItem(collection, selector);
-        if (item == null)
-          return [];
-        const hasItemWithSameId = item.id !== replacement.id && replacement.id != null && this.getItem(collection, { id: replacement.id }) != null;
-        if (hasItemWithSameId) {
-          throw new Error(`Item with id '${replacement.id}' already exists`);
-        }
-        const modifiedItem = { id: item.id, ...replacement };
-        this.items.get(collection.name)?.set(serializeValue(modifiedItem.id), modifiedItem);
-        await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
-        this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
-        this.updateQueries(collection, {
-          added: [],
-          modified: [modifiedItem],
-          removed: []
-        });
-        return [modifiedItem];
-      },
-      removeOne: async (selector) => {
-        const item = this.getItem(collection, selector);
-        if (item == null)
-          return [];
-        this.items.get(collection.name)?.delete(serializeValue(item.id));
-        await this.storageAdapters.get(collection.name)?.remove([item]);
-        this.applyIndexDeltas(collection, { removed: [item] });
-        this.updateQueries(collection, {
-          added: [],
-          modified: [],
-          removed: [item]
-        });
-        return [item];
-      },
-      removeMany: async (selector) => {
-        const items = backend.getQueryResult(selector, {});
-        items.forEach((item) => {
-          this.items.get(collection.name)?.delete(serializeValue(item.id));
-        });
-        await this.storageAdapters.get(collection.name)?.remove(items);
-        this.applyIndexDeltas(collection, { removed: items });
-        this.updateQueries(collection, {
-          added: [],
-          modified: [],
-          removed: items
-        });
-        return items;
-      },
-      // methods for registering and unregistering queries that will be called from the collection during find/findOne
-      registerQuery: (selector, options) => {
-        this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
-        this.activeQueries.get(collection.name)?.set(queryId(selector, options), {
-          selector,
-          options
-        });
-        this.executeAndCacheQuery(collection, selector, options);
-      },
-      unregisterQuery: (selector, options) => {
-        if (!this.activeQueries.get(collection.name))
-          return;
-        this.activeQueries.get(collection.name)?.delete(queryId(selector, options));
-      },
-      getQueryState: () => "complete",
-      onQueryStateChange: (selector, options, callback) => {
-        const emitter = this.queryEmitters.get(collection.name);
-        if (!emitter)
-          throw new Error(`Query emitter not found for collection ${collection.name}`);
-        const handler = (querySelector, queryOptions, state) => {
-          if (queryId(querySelector, queryOptions) !== queryId(selector, options))
-            return;
-          callback(state);
-        };
-        emitter.on("change", handler);
-        return () => {
-          emitter.off("change", handler);
-        };
-      },
-      getQueryError: () => null,
-      getQueryResult: (selector, options) => {
-        const isQueryActive = this.activeQueries.get(collection.name)?.has(queryId(selector, options));
-        if (isQueryActive) {
-          const results = this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options));
-          if (!results)
-            throw new Error("Cached query results are not defined!");
-          return results;
-        }
-        return this.executeQuery(collection, selector, options);
-      },
-      executeQuery: (selector, options) => Promise.resolve(this.executeQuery(collection, selector, options)),
-      // lifecycle methods
-      dispose: async () => {
-        const adapter = this.storageAdapters.get(collection.name);
-        if (adapter?.teardown)
-          await adapter.teardown();
-        this.storageAdapters.delete(collection.name);
-        this.items.delete(collection.name);
-        this.indices.delete(collection.name);
-        this.activeQueries.delete(collection.name);
-        this.queryEmitters.delete(collection.name);
-        this.queuedQueryUpdates.delete(collection.name);
-        this.cachedQueryResults.delete(collection.name);
-      },
-      isReady: () => persistenceReadyPromise
-    };
-    return backend;
-  }
-  async fetchItemsFromStorage(collection) {
-    if (!collection) {
-      await Promise.all([...this.collections].map((currentCollection) => this.fetchItemsFromStorage(currentCollection)));
-      return;
-    }
-    const storageAdapter = this.storageAdapters.get(collection.name);
-    if (!storageAdapter)
-      return;
-    const items = await storageAdapter.readAll();
-    this.items.set(collection.name, items.reduce((map, item) => {
-      map.set(serializeValue(item.id), item);
-      return map;
-    }, /* @__PURE__ */ new Map()));
-    this.rebuildIndices(collection);
-  }
-}
-export {
-  DefaultDataAdapter as default
-};
+//#endregion
+export { getMatchingKeys as default };

package/dist/index14.cjs.js

@@ -0,0 +1,86 @@
+const require_createIndexProvider = require("./index9.cjs.js");
+const require_get = require("./index10.cjs.js");
+const require_serializeValue = require("./index12.cjs.js");
+const require_getMatchingKeys = require("./index13.cjs.js");
+//#region src/createIndex.ts
+/**
+* creates an index for a specific field
+* @param field name of the field
+* @returns an index provider to pass to the `indices` option of the collection constructor
+*/
+function createIndex(field) {
+	const index = /* @__PURE__ */ new Map();
+	const ensureSet = (key) => {
+		let set = index.get(key);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			index.set(key, set);
+		}
+		return set;
+	};
+	return require_createIndexProvider.default({
+		query(selector) {
+			if (!Object.hasOwnProperty.call(selector, field)) return { matched: false };
+			const fieldSelector = selector[field];
+			const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
+			const keys = filteresForNull ? {
+				include: null,
+				exclude: [...index.keys()].filter((key) => key != null)
+			} : require_getMatchingKeys.default(field, selector);
+			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 posSet = index.get(key);
+				if (posSet) for (const pos of posSet) includedIds.push(pos);
+			}
+			if (keys.exclude != null) {
+				const excludeIds = /* @__PURE__ */ new Set();
+				for (const key of keys.exclude) {
+					const posSet = index.get(key);
+					if (posSet) for (const pos of posSet) excludeIds.add(pos);
+				}
+				includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
+			}
+			return {
+				matched: true,
+				ids: includedIds,
+				fields: [field],
+				keepSelector: filteresForNull
+			};
+		},
+		rebuild(items) {
+			index.clear();
+			items.forEach((item) => {
+				ensureSet(require_serializeValue.default(require_get.default(item, field))).add(item.id);
+			});
+		},
+		insert(items) {
+			for (const item of items) ensureSet(require_serializeValue.default(require_get.default(item, field))).add(item.id);
+		},
+		remove(items) {
+			for (const item of items) {
+				const value = require_serializeValue.default(require_get.default(item, field));
+				const set = index.get(value);
+				if (!set) continue;
+				set.delete(item.id);
+				if (set.size === 0) index.delete(value);
+			}
+		},
+		update(pairs) {
+			for (const { oldItem, newItem } of pairs) {
+				const oldValue = require_serializeValue.default(require_get.default(oldItem, field));
+				const newValue = require_serializeValue.default(require_get.default(newItem, field));
+				if (oldValue === newValue) continue;
+				const oldSet = index.get(oldValue);
+				if (oldSet) {
+					oldSet.delete(oldItem.id);
+					if (oldSet.size === 0) index.delete(oldValue);
+				}
+				ensureSet(newValue).add(newItem.id);
+			}
+		}
+	});
+}
+//#endregion
+exports.default = createIndex;