@signaldb/core 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/utils/reactiveOrAsync.d.ts

@@ -0,0 +1,59 @@
+export type MaybePromise<T> = T | Promise<T>;
+/**
+ * Options that control execution mode (and potential future mode-specific behavior).
+ * Keep this minimal; you can extend it later (e.g. signal, timeoutMs, debugLabel).
+ */
+export type ModeOptions = {
+    async?: boolean;
+};
+/**
+ * A generator helper that makes TypeScript infer the “synchronous value type” for maybe-async expressions.
+ *
+ * Usage:
+ *   const doc = yield* unwrap(Collection.findOne(...))
+ *   const list = yield* unwrap(Collection.find(...).fetch())
+ *
+ * Runtime note:
+ *   This does not “unwrap” Promises by itself. It yields the value/Promise to the runner and returns the
+ *   value that the runner feeds back via `.next(...)`.
+ * @param value The value (or Promise of a value) to yield to the runner.
+ * @returns A generator that yields `value` and resolves to the runner-supplied unwrapped `T`.
+ */
+export declare function unwrap<T>(value: MaybePromise<T>): Generator<MaybePromise<T>, T, T>;
+/**
+ * Generator shape used by the factory.
+ *
+ * `TThis` is the type of `this` inside the generator.
+ * `Args` are the method parameters (excluding the mode flag).
+ * `TReturn` is the final return value of the workflow.
+ * `TNext` is the type that is yielded/awaited and fed back via `.next(...)`.
+ *
+ * Note:
+ * - For best inference at yield sites, prefer `yield* unwrap(expr)` for maybe-async expressions.
+ */
+export type ReactiveOrAsyncGen<TThis, Arguments extends any[], TReturn, TNext> = (this: TThis, a: boolean, ...args: Arguments) => Generator<MaybePromise<TNext>, TReturn, TNext>;
+/**
+ * The method type produced from the generator signature.
+ * Adds overloads so that `{ async: true }` yields a `Promise<...>` return type.
+ */
+export type ReactiveOrAsyncMethod<TThis, P extends any[], R, N> = {
+    (this: TThis, ...args: P): R;
+    (this: TThis, ...args: [...P, ModeOptions?]): MaybePromise<R>;
+    (this: TThis, ...args: [...P, {
+        async: true;
+    }]): Promise<R>;
+} & {
+    /** Exposes the underlying generator for composition via `yield* method.generator.call(this, a, ...)` */
+    generator: (this: TThis, a: boolean, ...args: P) => Generator<MaybePromise<N>, R, N>;
+};
+/**
+ * Factory that turns a generator workflow into a callable method that can run in sync (reactive) or async mode.
+ *
+ * Call style:
+ *   fn(a, b)                        -> sync/reactive return
+ *   await fn(a, b, { async: true }) -> async return
+ * @param gen Generator workflow. Receives `(a)` which indicates async mode and should `yield`/`yield* unwrap(...)`
+ *   any values that may be Promises.
+ * @returns A callable method with overloads plus a `.generator` property for composition.
+ */
+export default function reactiveOrAsync<TThis, P extends any[], R, N>(gen: (this: TThis, a: boolean, ...args: P) => Generator<MaybePromise<N>, R, N>): ReactiveOrAsyncMethod<TThis, P, R, N>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaldb/core",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.11",
   "description": "SignalDB is a client-side database that provides a simple MongoDB-like interface to the data with first-class typescript support to achieve an optimistic UI. Data persistence can be achieved by using storage providers that store the data through a JSON interface to places such as localStorage.",
   "scripts": {
     "build": "rimraf dist && vite build",
@@ -55,9 +55,9 @@
   ],
   "dependencies": {
     "fast-sort": "^3.4.1",
-    "mingo": "^6.5.1"
+    "mingo": "^7.1.1"
   },
   "devDependencies": {
-    "zod": "^4.0.14"
+    "zod": "^4.3.5"
   }
 }

package/dist/index.cjs10.js

@@ -1,18 +0,0 @@
-"use strict";
-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;
-}
-module.exports = get;

package/dist/index.cjs11.js

@@ -1,15 +0,0 @@
-"use strict";
-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);
-}
-module.exports = serializeValue;

package/dist/index.cjs12.js

@@ -1,350 +0,0 @@
-"use strict";
-const createIndex = require("./index.cjs21.js");
-const getIndexInfo = require("./index.cjs22.js");
-const deepClone = require("./index.cjs19.js");
-const EventEmitter = require("./index.cjs9.js");
-const isEqual = require("./index.cjs6.js");
-const match = require("./index.cjs23.js");
-const modify = require("./index.cjs7.js");
-const project = require("./index.cjs24.js");
-const queryId = require("./index.cjs20.js");
-const serializeValue = require("./index.cjs11.js");
-const sortItems = require("./index.cjs25.js");
-function hasPendingUpdates(pendingUpdates) {
-  return pendingUpdates.added.length > 0 || pendingUpdates.modified.length > 0 || pendingUpdates.removed.length > 0;
-}
-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.default((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.default(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.default(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) {
-          return this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options)) ?? [];
-        }
-        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;
-  }
-}
-module.exports = DefaultDataAdapter;