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

package/dist/index22.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 "./index29.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/index23.mjs

@@ -1,28 +1,8 @@
-import get from "./index10.mjs";
-import set from "./index29.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/index24.mjs

@@ -1,8 +1,28 @@
-function queryId(selector, options) {
-  const selectorId = JSON.stringify(selector);
-  const optionsId = options == null ? -1 : JSON.stringify(options);
-  return `${selectorId}:${optionsId}`;
+import get from "./index10.mjs";
+import set from "./index31.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 {
-  queryId as default
+  project as default
 };

package/dist/index27.mjs

@@ -1,6 +1,47 @@
-function createIndexProvider(definition) {
-  return definition;
+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 {
-  createIndexProvider as default
+  batchOnNextTick as default
 };

package/dist/index28.mjs

@@ -1,8 +1,9 @@
-function intersection(...arrays) {
-  if (arrays.length === 0)
-    return [];
-  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
+function truthy(value) {
+  return !!value;
+}
+function compact(array) {
+  return array.filter(truthy);
 }
 export {
-  intersection as default
+  compact as default
 };

package/dist/index29.mjs

@@ -1,30 +1,8 @@
-function set(object, path, value, deleteIfUndefined = false) {
-  if (object == null)
-    return object;
-  const segments = path.split(/[.[\]]/g);
-  if (segments[0] === "")
-    segments.shift();
-  if (segments.at(-1) === "")
-    segments.pop();
-  const apply = (node) => {
-    if (segments.length > 1) {
-      const key = segments.shift();
-      const nextIsNumber = !Number.isNaN(Number.parseInt(segments[0], 10));
-      if (node[key] === void 0) {
-        node[key] = nextIsNumber ? [] : {};
-      }
-      apply(node[key]);
-    } else {
-      if (deleteIfUndefined && value === void 0) {
-        delete node[segments[0]];
-        return;
-      }
-      node[segments[0]] = value;
-    }
-  };
-  apply(object);
-  return object;
+function intersection(...arrays) {
+  if (arrays.length === 0)
+    return [];
+  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
 }
 export {
-  set as default
+  intersection as default
 };

package/dist/index3.mjs

@@ -4,6 +4,7 @@ import randomId from "./index8.mjs";
 import DefaultDataAdapter from "./index12.mjs";
 import modify from "./index7.mjs";
 import deepClone from "./index19.mjs";
+import queryId from "./index20.mjs";
 import Cursor from "./index2.mjs";
 class Collection extends EventEmitter {
   static collections = [];
@@ -66,6 +67,7 @@ class Collection extends EventEmitter {
   isDisposed = false;
   postBatchCallbacks = /* @__PURE__ */ new Set();
   fieldTracking = false;
+  queryListenersMap = /* @__PURE__ */ new Map();
   constructor(nameOrOptions, maybeDataAdapter, maybeOptions) {
     super();
     const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name || `${this.constructor.name}-${randomId()}`;
@@ -190,6 +192,11 @@ class Collection extends EventEmitter {
       return item;
     return this.options.transform(item);
   }
+  transformAll(items, fields) {
+    if (!this.options.transformAll)
+      return items;
+    return this.options.transformAll(deepClone(items), fields);
+  }
   getItem(selector, options) {
     const itemsOrPromise = this.getItems(selector, { ...options, limit: 1 });
     if (itemsOrPromise instanceof Promise) {
@@ -204,21 +211,9 @@ class Collection extends EventEmitter {
     return this.profile(() => {
       if (!options?.async)
         return this.backend.getQueryResult(selector, options);
-      return new Promise((resolve, reject) => {
-        this.isPullingSignal.set(true);
-        const cleanup = this.backend.onQueryStateChange(selector, options, (state) => {
-          if (state === "error") {
-            cleanup();
-            reject(this.backend.getQueryError(selector, options) || new Error("Unknown error"));
-          } else if (state === "complete") {
-            cleanup();
-            resolve(this.backend.getQueryResult(selector, options) || []);
-          }
-        });
-        this.backend.registerQuery(selector, options);
-      }).finally(() => {
+      this.isPullingSignal.set(true);
+      return this.backend.executeQuery(selector, options).finally(() => {
         this.isPullingSignal.set(false);
-        this.backend.unregisterQuery(selector, options);
       });
     }, (measuredTime) => this.executeInDebugMode((callstack) => this.emit("_debug.getItems", callstack, selector, measuredTime)));
   }
@@ -230,6 +225,13 @@ class Collection extends EventEmitter {
       this.isPushingSignal.set(false);
     }
   }
+  queryListeners(query, listeners) {
+    const id = queryId(query.selector, query.options);
+    if (listeners != null) {
+      return this.queryListenersMap.set(id, listeners);
+    }
+    return this.queryListenersMap.get(id) ?? 0;
+  }
   /**
    * Disposes the collection, unregisters persistence adapters, clears memory, and
    * cleans up all resources used by the collection.
@@ -255,7 +257,17 @@ class Collection extends EventEmitter {
       throw new Error("Collection is disposed");
     if (selector !== void 0 && (!selector || typeof selector !== "object"))
       throw new Error("Invalid selector");
-    const cursor = new Cursor((() => this.getItems(selector, options || {})), {
+    const getTransformedItems = () => {
+      const itemsOrPromise = this.getItems(selector, options || {});
+      if (itemsOrPromise instanceof Promise) {
+        return itemsOrPromise.then((items2) => {
+          return this.transformAll(items2, options?.fields);
+        });
+      }
+      const items = itemsOrPromise;
+      return this.transformAll(items, options?.fields);
+    };
+    const cursor = new Cursor(getTransformedItems, {
       reactive: this.options.reactivity,
       fieldTracking: this.fieldTracking,
       ...options,
@@ -268,17 +280,25 @@ class Collection extends EventEmitter {
           }
           requery();
         };
-        this.backend.registerQuery(selector, options);
-        const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options, (state) => {
+        const listeners = this.queryListeners({ selector, options });
+        if (listeners === 0)
+          this.backend.registerQuery(selector, options || {});
+        this.queryListeners({ selector, options }, listeners + 1);
+        const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options || {}, (state) => {
           if (state !== "complete")
             return;
           handleRequery();
         });
         this.emit("observer.created", selector, options);
         return () => {
-          this.backend.unregisterQuery(selector, options);
-          queryStateChangeCleanup();
-          this.emit("observer.disposed", selector, options);
+          setTimeout(() => {
+            const newListeners = Math.max(0, this.queryListeners({ selector, options }) - 1);
+            if (newListeners === 0)
+              this.backend.unregisterQuery(selector, options || {});
+            this.queryListeners({ selector, options }, newListeners);
+            queryStateChangeCleanup();
+            this.emit("observer.disposed", selector, options);
+          }, 0);
         };
       }
     });
@@ -371,9 +391,8 @@ class Collection extends EventEmitter {
       throw new Error("Collection is disposed");
     if (!items)
       throw new Error("Invalid items");
-    if (items.length === 0) {
+    if (items.length === 0)
       return [];
-    }
     const ids = [];
     await this.batch(async () => {
       await Promise.all(items.map(async (item) => {

package/dist/index31.mjs

@@ -1,10 +1,30 @@
-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 set(object, path, value, deleteIfUndefined = false) {
+  if (object == null)
+    return object;
+  const segments = path.split(/[.[\]]/g);
+  if (segments[0] === "")
+    segments.shift();
+  if (segments.at(-1) === "")
+    segments.pop();
+  const apply = (node) => {
+    if (segments.length > 1) {
+      const key = segments.shift();
+      const nextIsNumber = !Number.isNaN(Number.parseInt(segments[0], 10));
+      if (node[key] === void 0) {
+        node[key] = nextIsNumber ? [] : {};
+      }
+      apply(node[key]);
+    } else {
+      if (deleteIfUndefined && value === void 0) {
+        delete node[segments[0]];
+        return;
+      }
+      node[segments[0]] = value;
+    }
+  };
+  apply(object);
+  return object;
 }
 export {
-  uniqueBy as default
+  set as default
 };

package/dist/index32.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/index33.mjs

@@ -0,0 +1,6 @@
+function createIndexProvider(definition) {
+  return definition;
+}
+export {
+  createIndexProvider as default
+};

package/dist/utils/batchOnNextTick.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Groups multiple calls by key and flushes them on the next tick (macrotask).
+ * @param onFlush - Function that will be called with the key and all queued items when flushing.
+ * @returns An object with `enqueue` and `flush` methods.
+ * @example
+ *   const batcher = batchOnNextTick<string>(async (key, items) => {
+ *     // items is an array of { args, resolve, reject }
+ *     // do something once with all args...
+ *   })
+ *
+ *   batcher.enqueue("my-key", [arg1, arg2])
+ */
+export default function batchOnNextTick<TKey>(onFlush: (key: TKey, items: any[][]) => Promise<any[]>): {
+    enqueue: (key: TKey, args: any[]) => Promise<any>;
+    flush: (key: TKey) => Promise<void>;
+};

package/dist/utils/deepClone.d.ts

@@ -4,7 +4,7 @@
  * @template T - The type of the value to clone.
  * @param value - The value to deep clone.
  * @returns A deep copy of the provided value.
- * @throws An error if the value is a function, as cloning functions is not supported.
+ * @throws {Error} An error if the value is a function, as cloning functions is not supported.
  */
 export declare function clone<T>(value: T): T;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaldb/core",
-  "version": "2.0.0-beta.0",
+  "version": "2.0.0-beta.2",
   "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"
   }
 }