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

package/dist/index11.mjs

@@ -1,16 +1,45 @@
-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/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));
 }
-export {
-  serializeValue as default
-};
+//#endregion
+export { isFieldExpression as default };

package/dist/index12.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;

package/dist/index12.mjs

@@ -1,48 +1,22 @@
-function unwrap(value) {
-  return (function* () {
-    return yield value;
-  })();
+//#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);
 }
-function isThenable(value) {
-  return typeof value === "object" && value !== null && typeof value.then === "function";
-}
-function runReactiveOrAsync(thisArgument, mode, gen) {
-  const a = !!mode?.async;
-  const it = gen.call(thisArgument, a);
-  if (!a) {
-    let step = it.next();
-    while (!step.done) {
-      const y = step.value;
-      if (isThenable(y))
-        throw new Error("Promise yielded in sync flow");
-      step = it.next(y);
-    }
-    return step.value;
-  }
-  return (async function() {
-    let step = it.next();
-    while (!step.done) {
-      const y = step.value;
-      const v = isThenable(y) ? await y : y;
-      step = it.next(v);
-    }
-    return step.value;
-  })();
-}
-function reactiveOrAsync(gen) {
-  function method(...allArguments) {
-    const last = allArguments.length > 0 ? allArguments.at(-1) : void 0;
-    const hasMode = typeof last === "object" && last !== null && "async" in last;
-    const mode = hasMode ? last : void 0;
-    const parameters = hasMode ? allArguments.slice(0, -1) : allArguments;
-    return runReactiveOrAsync(this, mode, function* (a) {
-      return yield* gen.call(this, a, ...parameters);
-    });
-  }
-  method.generator = gen;
-  return method;
-}
-export {
-  reactiveOrAsync as default,
-  unwrap
-};
+//#endregion
+export { serializeValue as default };

package/dist/index13.cjs.js

@@ -0,0 +1,45 @@
+const require_isFieldExpression = require("./index11.cjs.js");
+const require_serializeValue = require("./index12.cjs.js");
+//#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 (require_isFieldExpression.default(fieldSelector)) {
+		if (fieldSelector.$ne != null) {
+			result.exclude = [require_serializeValue.default(fieldSelector.$ne)];
+			return result;
+		}
+		if (Array.isArray(fieldSelector.$in) && fieldSelector.$in.length > 0) {
+			result.include = fieldSelector.$in.map(require_serializeValue.default);
+			return result;
+		}
+		if (Array.isArray(fieldSelector.$nin) && fieldSelector.$nin.length > 0) {
+			result.exclude = fieldSelector.$nin.map(require_serializeValue.default);
+			return result;
+		}
+		return {
+			include: null,
+			exclude: null
+		};
+	}
+	result.include = [require_serializeValue.default(fieldSelector)];
+	return result;
+}
+//#endregion
+exports.default = getMatchingKeys;

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 };