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

package/dist/index16.mjs

@@ -1,15 +1,18 @@
 import deepClone from "./index19.mjs";
-import match from "./index22.mjs";
+import match from "./index23.mjs";
 import modify from "./index7.mjs";
-import queryId from "./index24.mjs";
+import queryId from "./index20.mjs";
 import isEqual from "./index6.mjs";
-import getIndexInfo from "./index21.mjs";
+import getIndexInfo from "./index22.mjs";
 import getMatchingKeys from "./index26.mjs";
 import sortItems from "./index25.mjs";
-import project from "./index23.mjs";
+import project from "./index24.mjs";
 function defaultMergeItems(a, b) {
   return { ...a, ...b };
 }
+function selectorId(selector) {
+  return JSON.stringify(selector ?? {});
+}
 class AutoFetchDataAdapter {
   options;
   id;
@@ -73,7 +76,7 @@ class AutoFetchDataAdapter {
         state: "active",
         error: null
       });
-      const key = this.selectorKey(selector);
+      const key = selectorId(selector);
       const perColObservers = this.activeObservers.get(collection.name);
       const current = perColObservers?.get(key)?.count ?? 0;
       perColObservers?.set(key, { selector, count: current + 1 });
@@ -90,7 +93,7 @@ class AutoFetchDataAdapter {
       const qid = queryId(selector, options);
       const registry = this.queries.get(collection.name);
       registry?.delete(qid);
-      const key = this.selectorKey(selector);
+      const key = selectorId(selector);
       const perColObservers = this.activeObservers.get(collection.name);
       const current = perColObservers?.get(key)?.count ?? 0;
       const remaining = Math.max(0, current - 1);
@@ -140,7 +143,9 @@ class AutoFetchDataAdapter {
         });
       }
       registry.get(qid)?.listeners.add(callback);
-      return () => registry.get(qid)?.listeners.delete(callback);
+      return () => {
+        registry.get(qid)?.listeners.delete(callback);
+      };
     };
     return {
       insert: async (item) => {
@@ -174,6 +179,23 @@ class AutoFetchDataAdapter {
       getQueryError,
       getQueryResult,
       onQueryStateChange,
+      executeQuery: async (selector, options) => {
+        await ready;
+        registerQuery(selector, options);
+        await new Promise((resolve) => {
+          let stop = () => {
+          };
+          stop = onQueryStateChange(selector, options, (state) => {
+            if (state === "active")
+              return;
+            resolve();
+            stop();
+          });
+        });
+        const result = getQueryResult(selector, options);
+        unregisterQuery(selector, options);
+        return result;
+      },
       dispose: async () => {
         this.storageAdapters.delete(collection.name);
         this.queries.delete(collection.name);
@@ -191,9 +213,6 @@ class AutoFetchDataAdapter {
     };
   }
   // ===== Auto-fetch mechanics =====
-  selectorKey(selector) {
-    return JSON.stringify(selector ?? {});
-  }
   async forceRefetchAll() {
     const tasks = [];
     for (const [collectionName, observers] of this.activeObservers.entries()) {
@@ -212,7 +231,7 @@ class AutoFetchDataAdapter {
         throw new Error("AutoFetchDataAdapter: fetchQueryItems must resolve to { items: T[] }");
       }
       const ids = items.map((i) => i.id);
-      const selectorKey = this.selectorKey(selector);
+      const selectorKey = selectorId(selector);
       const selMap = this.selectorIds.get(collectionName);
       const previous = selMap?.get(selectorKey) ?? /* @__PURE__ */ new Set();
       ids.forEach((id) => previous.add(id));
@@ -225,7 +244,7 @@ class AutoFetchDataAdapter {
     }
   }
   async purgeSelector(collectionName, selector) {
-    const selectorKey = this.selectorKey(selector);
+    const selectorKey = selectorId(selector);
     const selMap = this.selectorIds.get(collectionName);
     const ids = selMap?.get(selectorKey);
     selMap?.delete(selectorKey);
@@ -262,10 +281,7 @@ class AutoFetchDataAdapter {
     const storage = this.storageAdapters.get(collectionName);
     if (!storage)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    await Promise.all([
-      storage.createIndex("id"),
-      ...indices.map((field) => storage.createIndex(field))
-    ]);
+    await Promise.all(indices.map((field) => storage.createIndex(field)));
     await storage.setup();
   }
   ensureStorageAdapter(name) {
@@ -283,24 +299,16 @@ class AutoFetchDataAdapter {
     for (const query of registry.values()) {
       if (!isEqual(query.selector, selector))
         continue;
-      query.state = state;
-      query.error = error;
-      for (const callback of query.listeners) {
-        try {
-          callback(state);
-        } catch (error_) {
-          this.onError(error_);
-        }
-      }
+      this.publishState(collectionName, queryId(query.selector, query.options), state, error);
     }
   }
   publishState(collectionName, qid, state, error) {
-    const rec = this.queries.get(collectionName)?.get(qid);
-    if (!rec)
+    const query = this.queries.get(collectionName)?.get(qid);
+    if (!query)
       return;
-    rec.state = state;
-    rec.error = error;
-    for (const callback of rec.listeners) {
+    query.state = state;
+    query.error = error;
+    for (const callback of query.listeners) {
       try {
         callback(state);
       } catch (error_) {
@@ -309,10 +317,11 @@ class AutoFetchDataAdapter {
     }
   }
   publishResult(collectionName, qid, items) {
-    const rec = this.queries.get(collectionName)?.get(qid);
-    if (!rec)
+    const query = this.queries.get(collectionName)?.get(qid);
+    if (!query)
       return;
-    rec.items = items;
+    query.items = items;
+    this.queries.get(collectionName)?.set(qid, query);
   }
   async fulfillQuery(collectionName, selector, options) {
     const qid = queryId(selector, options);
@@ -471,7 +480,7 @@ class AutoFetchDataAdapter {
         throw new Error(`Item with id ${String(modified.id)} already exists`);
     }
     await storage.replace([modified]);
-    await this.checkQueryUpdates(collectionName, [modified]);
+    await this.checkQueryUpdates(collectionName, [item, modified]);
     return [modified];
   }
   async updateMany(collectionName, selector, modifier) {
@@ -492,7 +501,7 @@ class AutoFetchDataAdapter {
       return modified;
     }));
     await storage.replace(changed);
-    await this.checkQueryUpdates(collectionName, changed);
+    await this.checkQueryUpdates(collectionName, [...items, ...changed]);
     return changed;
   }
   async replaceOne(collectionName, selector, replacement) {
@@ -510,7 +519,7 @@ class AutoFetchDataAdapter {
         throw new Error(`Item with id ${String(modified.id)} already exists`);
     }
     await storage.replace([modified]);
-    await this.checkQueryUpdates(collectionName, [modified]);
+    await this.checkQueryUpdates(collectionName, [item, modified]);
     return [modified];
   }
   async removeOne(collectionName, selector) {

package/dist/index17.mjs

@@ -1,5 +1,5 @@
 import isEqual from "./index6.mjs";
-import uniqueBy from "./index31.mjs";
+import uniqueBy from "./index32.mjs";
 class Observer {
   previousItems = [];
   callbacks;
@@ -52,7 +52,9 @@ class Observer {
   runChecks(getItems) {
     const result = getItems();
     if (result instanceof Promise) {
-      void result.then((newItems) => this.checkItems(newItems));
+      result.then((newItems) => this.checkItems(newItems)).catch((error) => {
+        console.error("Error while asynchronously querying items", error);
+      });
     } else {
       this.checkItems(result);
     }

package/dist/index19.mjs

@@ -34,7 +34,6 @@ function clone(value) {
 function deepClone(object) {
   if (typeof structuredClone === "function")
     return structuredClone(object);
-  /* istanbul ignore next -- @preserve */
   return clone(object);
 }
 export {

package/dist/index2.mjs

@@ -26,6 +26,7 @@ class Cursor {
    * @param options.limit - The maximum number of items to return in the result set.
    * @param options.reactive - A reactivity adapter to enable observing changes in the cursor's result set.
    * @param options.fieldTracking - A boolean to enable fine-grained field tracking for reactivity.
+   * @param options.transformAll - A function that will be able to solve the n+1 problem
    */
   constructor(getItems, options) {
     this.getItems = getItems;
@@ -60,9 +61,12 @@ class Cursor {
     return this.options.transform(item);
   }
   depend(changeEvents) {
-    if (!this.options.reactive)
+    if (this.options?.async)
       return;
-    if (!isInReactiveScope(this.options.reactive))
+    if (!isInReactiveScope(this.options.reactive)) {
+      console.warn("Cursor.depend() called outside of a reactive scope without async option; consider using { async: true } or wrapping in a reactive scope");
+    }
+    if (!this.options.reactive)
       return;
     const signal = this.options.reactive.create();
     signal.depend();

package/dist/index20.mjs

@@ -1,105 +1,17 @@
-import createIndexProvider from "./index27.mjs";
-import get from "./index10.mjs";
-import getMatchingKeys from "./index26.mjs";
-import serializeValue from "./index11.mjs";
-function createIndex(field) {
-  const index = /* @__PURE__ */ new Map();
-  const ensureSet = (key) => {
-    let set = index.get(key);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      index.set(key, set);
-    }
-    return set;
-  };
-  return createIndexProvider({
-    query(selector) {
-      if (!Object.hasOwnProperty.call(selector, field)) {
-        return { matched: false };
-      }
-      const fieldSelector = selector[field];
-      const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
-      const keys = filteresForNull ? { include: null, exclude: [...index.keys()].filter((key) => key != null) } : getMatchingKeys(field, selector);
-      if (keys.include == null && keys.exclude == null)
-        return { matched: false };
-      let includedIds = [];
-      if (keys.include == null) {
-        for (const set of index.values()) {
-          for (const pos of set) {
-            includedIds.push(pos);
-          }
-        }
-      } else {
-        for (const key of keys.include) {
-          const posSet = index.get(key);
-          if (posSet) {
-            for (const pos of posSet) {
-              includedIds.push(pos);
-            }
-          }
-        }
-      }
-      if (keys.exclude != null) {
-        const excludeIds = /* @__PURE__ */ new Set();
-        for (const key of keys.exclude) {
-          const posSet = index.get(key);
-          if (posSet) {
-            for (const pos of posSet) {
-              excludeIds.add(pos);
-            }
-          }
-        }
-        includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
-      }
-      return {
-        matched: true,
-        ids: includedIds,
-        fields: [field],
-        keepSelector: filteresForNull
-      };
-    },
-    rebuild(items) {
-      index.clear();
-      items.forEach((item) => {
-        const value = serializeValue(get(item, field));
-        ensureSet(value).add(item.id);
-      });
-    },
-    // NEW: delta methods
-    insert(items) {
-      for (const item of items) {
-        const value = serializeValue(get(item, field));
-        ensureSet(value).add(item.id);
-      }
-    },
-    remove(items) {
-      for (const item of items) {
-        const value = serializeValue(get(item, field));
-        const set = index.get(value);
-        if (!set)
-          continue;
-        set.delete(item.id);
-        if (set.size === 0)
-          index.delete(value);
-      }
-    },
-    update(pairs) {
-      for (const { oldItem, newItem } of pairs) {
-        const oldValue = serializeValue(get(oldItem, field));
-        const newValue = serializeValue(get(newItem, field));
-        if (oldValue === newValue)
-          continue;
-        const oldSet = index.get(oldValue);
-        if (oldSet) {
-          oldSet.delete(oldItem.id);
-          if (oldSet.size === 0)
-            index.delete(oldValue);
-        }
-        ensureSet(newValue).add(newItem.id);
-      }
-    }
-  });
+function isEmptyOptions(options) {
+  if (options == null)
+    return true;
+  if (typeof options !== "object")
+    return false;
+  if (Array.isArray(options))
+    return false;
+  return Object.keys(options).length === 0;
+}
+function queryId(selector, options) {
+  const selectorId = JSON.stringify(selector);
+  const optionsId = isEmptyOptions(options) ? -1 : JSON.stringify(options);
+  return `${selectorId}:${optionsId}`;
 }
 export {
-  createIndex as default
+  queryId as default
 };

package/dist/index21.mjs

@@ -1,129 +1,105 @@
-import intersection from "./index28.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);
-      });
+import createIndexProvider from "./index33.mjs";
+import get from "./index10.mjs";
+import getMatchingKeys from "./index26.mjs";
+import serializeValue from "./index11.mjs";
+function createIndex(field) {
+  const index = /* @__PURE__ */ new Map();
+  const ensureSet = (key) => {
+    let set = index.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      index.set(key, set);
     }
-    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;
+    return set;
+  };
+  return createIndexProvider({
+    query(selector) {
+      if (!Object.hasOwnProperty.call(selector, field)) {
+        return { matched: false };
+      }
+      const fieldSelector = selector[field];
+      const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
+      const keys = filteresForNull ? { include: null, exclude: [...index.keys()].filter((key) => key != null) } : getMatchingKeys(field, selector);
+      if (keys.include == null && keys.exclude == null)
+        return { matched: false };
+      let includedIds = [];
+      if (keys.include == null) {
+        for (const set of index.values()) {
+          for (const pos of set) {
+            includedIds.push(pos);
+          }
         }
       } else {
-        idsCallback(false, []);
-        return sel;
+        for (const key of keys.include) {
+          const posSet = index.get(key);
+          if (posSet) {
+            for (const pos of posSet) {
+              includedIds.push(pos);
+            }
+          }
+        }
       }
-    };
-    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;
+      if (keys.exclude != null) {
+        const excludeIds = /* @__PURE__ */ new Set();
+        for (const key of keys.exclude) {
+          const posSet = index.get(key);
+          if (posSet) {
+            for (const pos of posSet) {
+              excludeIds.add(pos);
+            }
+          }
         }
-        return {
-          matched,
-          ids: ids || [],
-          optimizedSelector: newSelector
-        };
+        includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
+      }
+      return {
+        matched: true,
+        ids: includedIds,
+        fields: [field],
+        keepSelector: filteresForNull
       };
-      const $orNewOrPromise = Array.isArray($or) ? optimizeLogicGate(queryFunctions, $or, (match, selIds) => {
-        if (match) {
-          ids = [.../* @__PURE__ */ new Set([...ids, ...selIds])];
-          matched = true;
-        } else {
-          hasNonIndexField = true;
+    },
+    rebuild(items) {
+      index.clear();
+      items.forEach((item) => {
+        const value = serializeValue(get(item, field));
+        ensureSet(value).add(item.id);
+      });
+    },
+    // NEW: delta methods
+    insert(items) {
+      for (const item of items) {
+        const value = serializeValue(get(item, field));
+        ensureSet(value).add(item.id);
+      }
+    },
+    remove(items) {
+      for (const item of items) {
+        const value = serializeValue(get(item, field));
+        const set = index.get(value);
+        if (!set)
+          continue;
+        set.delete(item.id);
+        if (set.size === 0)
+          index.delete(value);
+      }
+    },
+    update(pairs) {
+      for (const { oldItem, newItem } of pairs) {
+        const oldValue = serializeValue(get(oldItem, field));
+        const newValue = serializeValue(get(newItem, field));
+        if (oldValue === newValue)
+          continue;
+        const oldSet = index.get(oldValue);
+        if (oldSet) {
+          oldSet.delete(oldItem.id);
+          if (oldSet.size === 0)
+            index.delete(oldValue);
         }
-      }) : void 0;
-      if ($orNewOrPromise instanceof Promise) {
-        return $orNewOrPromise.then(($orNew) => process$or($orNew));
+        ensureSet(newValue).add(newItem.id);
       }
-      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 {
-  getIndexInfo as default,
-  getMergedIndexInfo
+  createIndex as default
 };