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

package/dist/index10.mjs

@@ -1,19 +1,11 @@
-function get(value, path) {
-  const normalized = path.replaceAll(/\[(\w+)\]/g, ".$1");
-  if (normalized.includes("..") || normalized.startsWith(".") || normalized.endsWith(".")) {
-    return;
-  }
-  const segments = normalized.split(".");
-  let current = value;
-  for (const key of segments) {
-    if (current == null)
-      return;
-    current = current[key];
-  }
-  if (current === void 0)
-    return;
-  return current;
+//#region src/createIndexProvider.ts
+/**
+* Creates an IndexProvider based on the given definition.
+* @param definition - The definition of the IndexProvider.
+* @returns The created IndexProvider.
+*/
+function createIndexProvider(definition) {
+	return definition;
 }
-export {
-  get as default
-};
+//#endregion
+export { createIndexProvider as default };

package/dist/index11.cjs.js

@@ -0,0 +1,23 @@
+//#region src/utils/get.ts
+/**
+* Retrieves the value at a specified path within an object.
+* Supports dot and bracket notation for navigating nested properties.
+* @template T - The type of the object to retrieve the value from.
+* @param value - The object to navigate.
+* @param path - The path (dot or bracket notation) to the desired value.
+* @returns The value at the specified path, or `undefined` if the path does not exist.
+*/
+function get(value, path) {
+	const normalized = path.replaceAll(/\[(\w+)\]/g, ".$1");
+	if (normalized.includes("..") || normalized.startsWith(".") || normalized.endsWith(".")) return;
+	const segments = normalized.split(".");
+	let current = value;
+	for (const key of segments) {
+		if (current == null) return;
+		current = current[key];
+	}
+	if (current === void 0) return;
+	return current;
+}
+//#endregion
+exports.default = get;

package/dist/index11.mjs

@@ -1,16 +1,23 @@
-function serializeValue(value) {
-  if (value == null)
-    return null;
-  if (typeof value === "string")
-    return value;
-  if (typeof value === "number")
-    return value.toString();
-  if (typeof value === "boolean")
-    return value.toString();
-  if (value instanceof Date)
-    return value.toISOString();
-  return JSON.stringify(value);
+//#region src/utils/get.ts
+/**
+* Retrieves the value at a specified path within an object.
+* Supports dot and bracket notation for navigating nested properties.
+* @template T - The type of the object to retrieve the value from.
+* @param value - The object to navigate.
+* @param path - The path (dot or bracket notation) to the desired value.
+* @returns The value at the specified path, or `undefined` if the path does not exist.
+*/
+function get(value, path) {
+	const normalized = path.replaceAll(/\[(\w+)\]/g, ".$1");
+	if (normalized.includes("..") || normalized.startsWith(".") || normalized.endsWith(".")) return;
+	const segments = normalized.split(".");
+	let current = value;
+	for (const key of segments) {
+		if (current == null) return;
+		current = current[key];
+	}
+	if (current === void 0) return;
+	return current;
 }
-export {
-  serializeValue as default
-};
+//#endregion
+export { get as default };

package/dist/index12.cjs.js

@@ -0,0 +1,45 @@
+//#region src/utils/isFieldExpression.ts
+var expressionKeys = new Set([
+	"$eq",
+	"$gt",
+	"$gte",
+	"$lt",
+	"$lte",
+	"$in",
+	"$nin",
+	"$ne",
+	"$exists",
+	"$not",
+	"$expr",
+	"$jsonSchema",
+	"$mod",
+	"$regex",
+	"$options",
+	"$text",
+	"$where",
+	"$all",
+	"$elemMatch",
+	"$size",
+	"$bitsAllClear",
+	"$bitsAllSet",
+	"$bitsAnyClear",
+	"$bitsAnySet"
+]);
+/**
+* Determines whether a given object is a valid field expression.
+* A field expression is an object containing query operators supported by MongoDB-style queries.
+* @template T - The type of the field expression.
+* @param expression - The object to test.
+* @returns A boolean indicating whether the object is a valid field expression.
+*   - `true` if the object contains only recognized query operators.
+*   - `false` otherwise.
+*/
+function isFieldExpression(expression) {
+	if (typeof expression !== "object" || expression == null) return false;
+	const keys = Object.keys(expression);
+	if (keys.length === 0) return false;
+	if (keys.some((key) => !expressionKeys.has(key))) return false;
+	return keys.every((key) => expressionKeys.has(key));
+}
+//#endregion
+exports.default = isFieldExpression;

package/dist/index12.mjs

@@ -1,354 +1,45 @@
-import createIndex from "./index21.mjs";
-import getIndexInfo from "./index22.mjs";
-import deepClone from "./index19.mjs";
-import EventEmitter from "./index9.mjs";
-import isEqual from "./index6.mjs";
-import match from "./index23.mjs";
-import modify from "./index7.mjs";
-import project from "./index24.mjs";
-import queryId from "./index20.mjs";
-import serializeValue from "./index11.mjs";
-import sortItems from "./index25.mjs";
-function hasPendingUpdates(pendingUpdates) {
-  return pendingUpdates.added.length > 0 || pendingUpdates.modified.length > 0 || pendingUpdates.removed.length > 0;
+//#region src/utils/isFieldExpression.ts
+var expressionKeys = new Set([
+	"$eq",
+	"$gt",
+	"$gte",
+	"$lt",
+	"$lte",
+	"$in",
+	"$nin",
+	"$ne",
+	"$exists",
+	"$not",
+	"$expr",
+	"$jsonSchema",
+	"$mod",
+	"$regex",
+	"$options",
+	"$text",
+	"$where",
+	"$all",
+	"$elemMatch",
+	"$size",
+	"$bitsAllClear",
+	"$bitsAllSet",
+	"$bitsAnyClear",
+	"$bitsAnySet"
+]);
+/**
+* Determines whether a given object is a valid field expression.
+* A field expression is an object containing query operators supported by MongoDB-style queries.
+* @template T - The type of the field expression.
+* @param expression - The object to test.
+* @returns A boolean indicating whether the object is a valid field expression.
+*   - `true` if the object contains only recognized query operators.
+*   - `false` otherwise.
+*/
+function isFieldExpression(expression) {
+	if (typeof expression !== "object" || expression == null) return false;
+	const keys = Object.keys(expression);
+	if (keys.length === 0) return false;
+	if (keys.some((key) => !expressionKeys.has(key))) return false;
+	return keys.every((key) => expressionKeys.has(key));
 }
-class DefaultDataAdapter {
-  items = /* @__PURE__ */ new Map();
-  options;
-  storageAdapters = /* @__PURE__ */ new Map();
-  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 () => {
-      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);
-    }).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.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;
-  }
-}
-export {
-  DefaultDataAdapter as default
-};
+//#endregion
+export { isFieldExpression as default };

package/dist/index13.cjs.js

@@ -0,0 +1,22 @@
+//#region src/utils/serializeValue.ts
+/**
+* Serializes a value into a string representation.
+* Handles various types, including strings, numbers, booleans, dates, and objects.
+* Falls back to JSON stringification for unsupported types.
+* @param value - The value to serialize.
+*   - Strings are returned as-is.
+*   - Numbers and booleans are converted to their string representation.
+*   - Dates are converted to ISO string format.
+*   - Other values are stringified using `JSON.stringify`.
+* @returns A string representation of the value.
+*/
+function serializeValue(value) {
+	if (value == null) return null;
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return value.toString();
+	if (typeof value === "boolean") return value.toString();
+	if (value instanceof Date) return value.toISOString();
+	return JSON.stringify(value);
+}
+//#endregion
+exports.default = serializeValue;