@signaldb/core 2.0.0-beta.4 → 2.0.0-beta.5

package/dist/index23.mjs

@@ -1,8 +1,129 @@
-import { Query } from "mingo";
-function match(item, selector) {
-  const query = new Query(selector);
-  return query.test(item);
+import intersection from "./index30.mjs";
+function getMergedIndexInfo(queryFunctions, selector) {
+  return queryFunctions.reduce((memoOrPromise, queryFunction) => {
+    const resultOrPromise = queryFunction(selector);
+    const processResult = (memo2, result) => {
+      if (!result.matched)
+        return memo2;
+      const optimizedSelector = result.keepSelector ? memo2.optimizedSelector : Object.fromEntries(Object.entries(memo2.optimizedSelector).filter(([key]) => !result.fields.includes(key)));
+      return {
+        matched: true,
+        ids: [...new Set(memo2.matched ? intersection(memo2.ids, result.ids) : result.ids)],
+        optimizedSelector
+      };
+    };
+    if (resultOrPromise instanceof Promise) {
+      return resultOrPromise.then(async (result) => {
+        const memo2 = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
+        return processResult(memo2, 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 }
+  });
+}
+function optimizeLogicGate(queryFunctions, logicGate, idsCallback) {
+  return logicGate.reduce((memoOrPromise, sel) => {
+    const getSelector = (indexInfo) => {
+      const { matched: selMatched, ids: selIds, optimizedSelector: optimizedSelector2 } = indexInfo;
+      if (selMatched) {
+        idsCallback(true, selIds);
+        if (Object.keys(optimizedSelector2).length > 0) {
+          return optimizedSelector2;
+        }
+      } else {
+        idsCallback(false, []);
+        return sel;
+      }
+    };
+    const indexInfoOrPromise = getIndexInfo(queryFunctions, sel);
+    if (indexInfoOrPromise instanceof Promise) {
+      return indexInfoOrPromise.then(async (indexInfo) => {
+        const memo2 = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
+        const optimizedSelector2 = getSelector(indexInfo);
+        if (optimizedSelector2)
+          memo2.push(optimizedSelector2);
+        return memo2;
+      });
+    }
+    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;
+  }, []);
+}
+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 ($orNew && $orNew.length > 0)
+          newSelector.$or = $orNew;
+        if (hasNonIndexField) {
+          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 = [.../* @__PURE__ */ 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);
 }
 export {
-  match as default
+  getIndexInfo as default,
+  getMergedIndexInfo
 };

package/dist/index24.mjs

@@ -1,28 +1,8 @@
-import get from "./index10.mjs";
-import set from "./index32.mjs";
-function project(item, fields) {
-  const allFieldsDeactivated = Object.values(fields).every((value) => value === 0);
-  if (allFieldsDeactivated) {
-    const result2 = { ...item };
-    Object.keys(fields).forEach((key) => {
-      const fieldValue = get(item, key);
-      if (fieldValue === void 0)
-        return;
-      set(result2, key, void 0, true);
-    });
-    return result2;
-  }
-  const result = {};
-  Object.entries(fields).forEach(([key, value]) => {
-    const fieldValue = get(item, key);
-    if (fieldValue === void 0)
-      return;
-    if (fieldValue == null && value !== 1)
-      return;
-    set(result, key, value === 1 ? fieldValue : void 0);
-  });
-  return result;
+import { Query } from "mingo";
+function match(item, selector) {
+  const query = new Query(selector);
+  return query.test(item);
 }
 export {
-  project as default
+  match as default
 };

package/dist/index25.mjs

@@ -1,11 +1,28 @@
-import { sort } from "fast-sort";
 import get from "./index10.mjs";
-function sortItems(items, sortFields) {
-  return sort(items).by(Object.entries(sortFields).map(([key, value]) => {
-    const order = value === 1 ? "asc" : "desc";
-    return { [order]: (i) => get(i, key) };
-  }));
+import set from "./index32.mjs";
+function project(item, fields) {
+  const allFieldsDeactivated = Object.values(fields).every((value) => value === 0);
+  if (allFieldsDeactivated) {
+    const result2 = { ...item };
+    Object.keys(fields).forEach((key) => {
+      const fieldValue = get(item, key);
+      if (fieldValue === void 0)
+        return;
+      set(result2, key, void 0, true);
+    });
+    return result2;
+  }
+  const result = {};
+  Object.entries(fields).forEach(([key, value]) => {
+    const fieldValue = get(item, key);
+    if (fieldValue === void 0)
+      return;
+    if (fieldValue == null && value !== 1)
+      return;
+    set(result, key, value === 1 ? fieldValue : void 0);
+  });
+  return result;
 }
 export {
-  sortItems as default
+  project as default
 };

package/dist/index26.mjs

@@ -1,30 +1,11 @@
-import isFieldExpression from "./index33.mjs";
-import serializeValue from "./index11.mjs";
-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;
+import { sort } from "fast-sort";
+import get from "./index10.mjs";
+function sortItems(items, sortFields) {
+  return sort(items).by(Object.entries(sortFields).map(([key, value]) => {
+    const order = value === 1 ? "asc" : "desc";
+    return { [order]: (i) => get(i, key) };
+  }));
 }
 export {
-  getMatchingKeys as default
+  sortItems as default
 };

package/dist/index27.mjs

@@ -1,47 +1,30 @@
-function batchOnNextTick(onFlush) {
-  const queues = /* @__PURE__ */ new Map();
-  function enqueue(key, args) {
-    return new Promise((resolve, reject) => {
-      let q = queues.get(key);
-      if (!q) {
-        q = {
-          timer: null,
-          items: [],
-          flush: () => flush(key)
-        };
-        queues.set(key, q);
-      }
-      q.items.push({ args, resolve, reject });
-      if (q.timer == null) {
-        q.timer = setTimeout(() => {
-          q.timer = null;
-          void q.flush();
-        }, 0);
-      }
-    });
-  }
-  async function flush(key) {
-    const q = queues.get(key);
-    if (!q || q.items.length === 0)
-      return;
-    if (q.timer != null) {
-      clearTimeout(q.timer);
-      q.timer = null;
+import isFieldExpression from "./index31.mjs";
+import serializeValue from "./index11.mjs";
+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;
     }
-    const items = q.items.splice(0);
-    onFlush(key, items.map((i) => i.args)).then((results) => {
-      for (const [index, result] of results.entries()) {
-        const { resolve } = items[index];
-        resolve(result);
-      }
-    }).catch((error) => {
-      for (const { reject } of items) {
-        reject(error);
-      }
-    });
+    return { include: null, exclude: null };
   }
-  return { enqueue, flush };
+  result.include = [serializeValue(fieldSelector)];
+  return result;
 }
 export {
-  batchOnNextTick as default
+  getMatchingKeys as default
 };

package/dist/index28.mjs

@@ -1,9 +1,47 @@
-function truthy(value) {
-  return !!value;
-}
-function compact(array) {
-  return array.filter(truthy);
+function batchOnNextTick(onFlush) {
+  const queues = /* @__PURE__ */ new Map();
+  function enqueue(key, args) {
+    return new Promise((resolve, reject) => {
+      let q = queues.get(key);
+      if (!q) {
+        q = {
+          timer: null,
+          items: [],
+          flush: () => flush(key)
+        };
+        queues.set(key, q);
+      }
+      q.items.push({ args, resolve, reject });
+      if (q.timer == null) {
+        q.timer = setTimeout(() => {
+          q.timer = null;
+          void q.flush();
+        }, 0);
+      }
+    });
+  }
+  async function flush(key) {
+    const q = queues.get(key);
+    if (!q || q.items.length === 0)
+      return;
+    if (q.timer != null) {
+      clearTimeout(q.timer);
+      q.timer = null;
+    }
+    const items = q.items.splice(0);
+    onFlush(key, items.map((i) => i.args)).then((results) => {
+      for (const [index, result] of results.entries()) {
+        const { resolve } = items[index];
+        resolve(result);
+      }
+    }).catch((error) => {
+      for (const { reject } of items) {
+        reject(error);
+      }
+    });
+  }
+  return { enqueue, flush };
 }
 export {
-  compact as default
+  batchOnNextTick as default
 };

package/dist/index29.mjs

@@ -1,10 +1,9 @@
-function uniqueBy(array, fn) {
-  const set = /* @__PURE__ */ new Set();
-  return array.filter((element) => {
-    const value = typeof fn === "function" ? fn(element) : element[fn];
-    return !set.has(value) && set.add(value);
-  });
+function truthy(value) {
+  return !!value;
+}
+function compact(array) {
+  return array.filter(truthy);
 }
 export {
-  uniqueBy as default
+  compact as default
 };

package/dist/index3.mjs

@@ -1,10 +1,10 @@
 import EventEmitter from "./index9.mjs";
-import createSignal from "./index18.mjs";
+import createSignal from "./index19.mjs";
 import randomId from "./index8.mjs";
-import DefaultDataAdapter from "./index12.mjs";
+import DefaultDataAdapter from "./index13.mjs";
 import modify from "./index7.mjs";
-import deepClone from "./index19.mjs";
-import queryId from "./index20.mjs";
+import deepClone from "./index20.mjs";
+import queryId from "./index21.mjs";
 import Cursor from "./index2.mjs";
 class Collection extends EventEmitter {
   static collections = [];
@@ -244,14 +244,6 @@ class Collection extends EventEmitter {
     Collection.collections = Collection.collections.filter((collection) => collection !== this);
     Collection.onDisposeCallbacks.forEach((callback) => callback(this));
   }
-  /**
-   * Finds multiple items in the collection based on a selector and optional options.
-   * Returns a cursor for reactive data queries.
-   * @template O - The options type for the find operation.
-   * @param [selector] - The criteria to select items.
-   * @param [options] - Options for the find operation, such as limit and sort.
-   * @returns A cursor to fetch and observe the matching items.
-   */
   find(selector = {}, options) {
     if (this.isDisposed)
       throw new Error("Collection is disposed");
@@ -281,7 +273,8 @@ class Collection extends EventEmitter {
           requery();
         };
         const listeners = this.queryListeners({ selector, options });
-        if (listeners === 0)
+        const didRegister = listeners === 0;
+        if (didRegister)
           this.backend.registerQuery(selector, options || {});
         this.queryListeners({ selector, options }, listeners + 1);
         const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options || {}, (state) => {
@@ -291,14 +284,14 @@ class Collection extends EventEmitter {
         });
         this.emit("observer.created", selector, options);
         return () => {
-          setTimeout(() => {
+          queueMicrotask(() => {
             const newListeners = Math.max(0, this.queryListeners({ selector, options }) - 1);
-            if (newListeners === 0)
+            if (newListeners === 0 && didRegister)
               this.backend.unregisterQuery(selector, options || {});
             this.queryListeners({ selector, options }, newListeners);
             queryStateChangeCleanup();
             this.emit("observer.disposed", selector, options);
-          }, 0);
+          });
         };
       }
     });
@@ -306,16 +299,6 @@ class Collection extends EventEmitter {
     this.executeInDebugMode((callstack) => this.emit("_debug.find", callstack, selector, options, cursor));
     return cursor;
   }
-  /**
-   * Finds a single item in the collection based on a selector and optional options.
-   * ⚡️ this function is reactive!
-   * Returns the found item or undefined if no item matches.
-   * @template Async - Whether to perform the operation asynchronously.
-   * @template O - The options type for the find operation.
-   * @param selector - The criteria to select the item.
-   * @param [options] - Options for the find operation, such as projection.
-   * @returns The found item or `undefined`.
-   */
   findOne(selector, options) {
     if (this.isDisposed)
       throw new Error("Collection is disposed");

package/dist/index30.mjs

@@ -1,6 +1,8 @@
-function createIndexProvider(definition) {
-  return definition;
+function intersection(...arrays) {
+  if (arrays.length === 0)
+    return [];
+  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
 }
 export {
-  createIndexProvider as default
+  intersection as default
 };

package/dist/index31.mjs

@@ -1,8 +1,43 @@
-function intersection(...arrays) {
-  if (arrays.length === 0)
-    return [];
-  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
+const expressionKeys = /* @__PURE__ */ 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"
+]);
+function isFieldExpression(expression) {
+  if (typeof expression !== "object" || expression == null) {
+    return false;
+  }
+  const keys = Object.keys(expression);
+  if (keys.length === 0) {
+    return false;
+  }
+  const hasInvalidKeys = keys.some((key) => !expressionKeys.has(key));
+  if (hasInvalidKeys)
+    return false;
+  const hasValidKeys = keys.every((key) => expressionKeys.has(key));
+  return hasValidKeys;
 }
 export {
-  intersection as default
+  isFieldExpression as default
 };

package/dist/index33.mjs

@@ -1,43 +1,6 @@
-const expressionKeys = /* @__PURE__ */ 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"
-]);
-function isFieldExpression(expression) {
-  if (typeof expression !== "object" || expression == null) {
-    return false;
-  }
-  const keys = Object.keys(expression);
-  if (keys.length === 0) {
-    return false;
-  }
-  const hasInvalidKeys = keys.some((key) => !expressionKeys.has(key));
-  if (hasInvalidKeys)
-    return false;
-  const hasValidKeys = keys.every((key) => expressionKeys.has(key));
-  return hasValidKeys;
+function createIndexProvider(definition) {
+  return definition;
 }
 export {
-  isFieldExpression as default
+  createIndexProvider as default
 };

package/dist/index34.mjs

@@ -0,0 +1,10 @@
+function uniqueBy(array, fn) {
+  const set = /* @__PURE__ */ new Set();
+  return array.filter((element) => {
+    const value = typeof fn === "function" ? fn(element) : element[fn];
+    return !set.has(value) && set.add(value);
+  });
+}
+export {
+  uniqueBy as default
+};

package/dist/index7.mjs

@@ -1,5 +1,5 @@
 import { update } from "mingo";
-import deepClone from "./index19.mjs";
+import deepClone from "./index20.mjs";
 function modify(item, modifier) {
   const hasOperators = Object.keys(modifier).some((key) => key.startsWith("$"));
   if (!hasOperators)

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.4",
+  "version": "2.0.0-beta.5",
   "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",