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

package/dist/index15.mjs

@@ -1,16 +1,19 @@
 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";
+import compact from "./index28.mjs";
 class WorkerDataAdapterHost {
   workerContext;
   options;
   id;
+  log = () => {
+  };
   storageAdapters = /* @__PURE__ */ new Map();
   storageAdapterReady = /* @__PURE__ */ new Map();
   collectionIndices = /* @__PURE__ */ new Map();
@@ -25,6 +28,8 @@ class WorkerDataAdapterHost {
     if (this.options.onError) {
       this.onError = this.options.onError;
     }
+    if (this.options.log)
+      this.log = this.options.log;
     if (typeof addEventListener === "undefined" || typeof postMessage === "undefined") {
       throw new TypeError("WorkerDataAdapterHost can only be used in a Web Worker context");
     }
@@ -49,6 +54,8 @@ class WorkerDataAdapterHost {
       this.respond(id, null, new Error(`Method ${method} not found`));
       return;
     }
+    this.log(method, ...args);
+    await this.isReady(args[0]);
     try {
       const result = await fn.apply(this, args);
       this.respond(id, result);
@@ -63,7 +70,7 @@ class WorkerDataAdapterHost {
     if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
       return {
         matched: true,
-        ids: [selector.id],
+        ids: compact([selector.id]),
         optimizedSelector: {}
       };
     }
@@ -213,10 +220,7 @@ class WorkerDataAdapterHost {
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
     const setupPromise = (async () => {
-      await Promise.all([
-        storageAdapter.createIndex("id"),
-        ...indices.map((index) => storageAdapter.createIndex(index))
-      ]);
+      await Promise.all(indices.map((index) => storageAdapter.createIndex(index)));
       await storageAdapter.setup();
     })();
     this.storageAdapterReady.set(collectionName, setupPromise);
@@ -237,101 +241,142 @@ class WorkerDataAdapterHost {
       throw new Error(`Collection ${collectionName} not initialized!`);
     this.queries.get(collectionName)?.delete(id);
   };
-  insert = async (collectionName, newItem) => {
-    const storageAdapter = this.storageAdapters.get(collectionName);
-    if (!storageAdapter)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const existingItems = await this.executeQuery(collectionName, { id: newItem.id }, { limit: 1 });
-    if (existingItems.length > 0) {
-      throw new Error(`Item with id ${newItem.id} already exists`);
-    }
-    await storageAdapter.insert([newItem]);
-    await this.checkQueryUpdates(collectionName, [newItem]);
-    return newItem;
-  };
-  updateOne = async (collectionName, selector, modifier) => {
+  insert = async (collectionName, input) => {
     const storageAdapter = this.storageAdapters.get(collectionName);
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-    const { $setOnInsert, ...restModifier } = modifier;
-    if (item == null)
-      return [];
-    const modifiedItem = modify(deepClone(item), restModifier);
-    if (item.id !== modifiedItem.id) {
-      const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
-      if (existingItems.length > 0) {
-        throw new Error(`Item with id ${modifiedItem.id} already exists`);
+    const existingItems = await this.executeQuery(collectionName, { id: { $in: input.map((i) => i[0].id) } });
+    const result = input.map(([item]) => {
+      if (item.id == null)
+        throw new Error("Item must have an id");
+      if (existingItems.some((existing) => existing.id === item.id)) {
+        return new Error(`Item with id ${item.id} already exists`);
       }
-    }
-    await storageAdapter.replace([modifiedItem]);
-    await this.checkQueryUpdates(collectionName, [modifiedItem]);
-    return [modifiedItem];
+      return item;
+    });
+    const newItems = result.filter((item) => !(item instanceof Error));
+    await storageAdapter.insert(newItems);
+    await this.checkQueryUpdates(collectionName, newItems);
+    return result;
   };
-  updateMany = async (collectionName, selector, modifier) => {
+  updateOne = async (collectionName, parameters) => {
     const storageAdapter = this.storageAdapters.get(collectionName);
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector);
-    if (items.length === 0)
-      return [];
-    const { $setOnInsert, ...restModifier } = modifier;
-    const changedItems = await Promise.all(items.map(async (item) => {
+    const previousItems = [];
+    const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
+      const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
+      const { $setOnInsert, ...restModifier } = modifier;
+      if (item == null)
+        return [];
+      previousItems.push(item);
       const modifiedItem = modify(deepClone(item), restModifier);
       if (item.id !== modifiedItem.id) {
         const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
         if (existingItems.length > 0) {
-          throw new Error(`Item with id ${modifiedItem.id} already exists`);
+          return new Error(`Item with id ${modifiedItem.id} already exists`);
         }
       }
-      return modifiedItem;
+      return [modifiedItem];
     }));
-    await storageAdapter.replace(changedItems);
-    await this.checkQueryUpdates(collectionName, changedItems);
-    return changedItems;
+    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
+    if (modifiedItems.length > 0) {
+      await storageAdapter.replace(modifiedItems);
+      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+    }
+    return result;
   };
-  replaceOne = async (collectionName, selector, replacement) => {
+  updateMany = async (collectionName, parameters) => {
     const storageAdapter = this.storageAdapters.get(collectionName);
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-    if (item == null)
-      return [];
-    const modifiedItem = {
-      ...replacement,
-      id: replacement.id ?? item.id
-    };
-    if (item.id !== modifiedItem.id) {
-      const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
-      if (existingItems.length > 0) {
-        throw new Error(`Item with id ${modifiedItem.id} already exists`);
+    const previousItems = [];
+    const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
+      const items = await this.executeQuery(collectionName, selector);
+      if (items.length === 0)
+        return [];
+      const { $setOnInsert, ...restModifier } = modifier;
+      try {
+        const changedItems = await Promise.all(items.map(async (item) => {
+          const modifiedItem = modify(deepClone(item), restModifier);
+          if (item.id !== modifiedItem.id) {
+            const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
+            if (existingItems.length > 0) {
+              throw new Error(`Item with id ${modifiedItem.id} already exists`);
+            }
+          }
+          previousItems.push(item);
+          return modifiedItem;
+        }));
+        return changedItems;
+      } catch (error) {
+        return error;
+      }
+    }));
+    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
+    if (modifiedItems.length > 0) {
+      await storageAdapter.replace(modifiedItems);
+      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+    }
+    return result;
+  };
+  replaceOne = async (collectionName, parameters) => {
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
+      throw new Error(`No persistence adapter for collection ${collectionName}`);
+    const previousItems = [];
+    const result = await Promise.all(parameters.map(async ([selector, replacement]) => {
+      const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
+      if (item == null)
+        return [];
+      previousItems.push(item);
+      const modifiedItem = {
+        ...replacement,
+        id: replacement.id ?? item.id
+      };
+      if (item.id !== modifiedItem.id) {
+        const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
+        if (existingItems.length > 0) {
+          return new Error(`Item with id ${modifiedItem.id} already exists`);
+        }
       }
+      return [modifiedItem];
+    }));
+    const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
+    if (modifiedItems.length > 0) {
+      await storageAdapter.replace(modifiedItems);
+      await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
     }
-    await storageAdapter.replace([modifiedItem]);
-    await this.checkQueryUpdates(collectionName, [modifiedItem]);
-    return [modifiedItem];
+    return result;
   };
-  removeOne = async (collectionName, selector) => {
+  removeOne = async (collectionName, selectors) => {
     const storageAdapter = this.storageAdapters.get(collectionName);
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-    if (item == null)
-      return [];
-    await storageAdapter.remove([item]);
-    await this.checkQueryUpdates(collectionName, [item]);
-    return [item];
+    const result = await Promise.all(selectors.map(async ([selector]) => {
+      const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items2) => items2[0] ?? null);
+      if (item == null)
+        return [];
+      return [item];
+    }));
+    const items = result.flat();
+    if (items.length > 0) {
+      await storageAdapter.remove(items);
+      await this.checkQueryUpdates(collectionName, items);
+    }
+    return result;
   };
-  removeMany = async (collectionName, selector) => {
+  removeMany = async (collectionName, selectors) => {
     const storageAdapter = this.storageAdapters.get(collectionName);
     if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector);
-    if (items.length === 0)
-      return [];
-    await storageAdapter.remove(items);
-    await this.checkQueryUpdates(collectionName, items);
-    return items;
+    const result = await Promise.all(selectors.map(async ([selector]) => this.executeQuery(collectionName, selector)));
+    const items = result.flat();
+    if (items.length > 0) {
+      await storageAdapter.remove(items);
+      await this.checkQueryUpdates(collectionName, items);
+    }
+    return result;
   };
   isReady = async (collectionName) => {
     return this.storageAdapterReady.get(collectionName);

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 "./index29.mjs";
 class Observer {
   previousItems = [];
   callbacks;

package/dist/index2.mjs

@@ -60,9 +60,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,8 @@
-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 queryId(selector, options) {
+  const selectorId = JSON.stringify(selector);
+  const optionsId = options == null ? -1 : JSON.stringify(options);
+  return `${selectorId}:${optionsId}`;
 }
 export {
-  createIndex as default
+  queryId as default
 };