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

package/dist/index16.mjs

@@ -1,385 +1,123 @@
-import deepClone from "./index19.mjs";
-import match from "./index23.mjs";
+import deepClone from "./index20.mjs";
+import match from "./index24.mjs";
 import modify from "./index7.mjs";
-import queryId from "./index20.mjs";
+import queryId from "./index21.mjs";
 import isEqual from "./index6.mjs";
-import getIndexInfo from "./index22.mjs";
-import getMatchingKeys from "./index26.mjs";
-import sortItems from "./index25.mjs";
-import project from "./index24.mjs";
-function defaultMergeItems(a, b) {
-  return { ...a, ...b };
-}
-function selectorId(selector) {
-  return JSON.stringify(selector ?? {});
-}
-class AutoFetchDataAdapter {
+import getIndexInfo from "./index23.mjs";
+import getMatchingKeys from "./index27.mjs";
+import sortItems from "./index26.mjs";
+import project from "./index25.mjs";
+import compact from "./index29.mjs";
+class WorkerDataAdapterHost {
+  workerContext;
   options;
   id;
-  onError;
-  fetchQueryItems;
-  mergeItems;
-  purgeDelay;
-  // Per-collection resources
+  log = () => {
+  };
   storageAdapters = /* @__PURE__ */ new Map();
   storageAdapterReady = /* @__PURE__ */ new Map();
   collectionIndices = /* @__PURE__ */ new Map();
-  // Per-collection query registries and auto-fetch bookkeeping
   queries = /* @__PURE__ */ new Map();
-  activeObservers = /* @__PURE__ */ new Map();
-  // per-collection: key->record
-  observerTimeouts = /* @__PURE__ */ new Map();
-  // per-collection
-  selectorIds = /* @__PURE__ */ new Map();
-  // per-collection: selectorKey -> Set<id>
-  idRefCounts = /* @__PURE__ */ new Map();
-  // per-collection: id -> refcount (for auto-fetched items)
-  autoloadIds = /* @__PURE__ */ new Map();
-  // per-collection: ids that were introduced via auto-fetch
-  constructor(options) {
+  onError = (error) => {
+    console.error(error);
+  };
+  constructor(workerContext, options) {
+    this.workerContext = workerContext;
     this.options = options;
-    this.id = options.id || "autofetch-data-adapter";
-    this.onError = options.onError ?? ((error) => {
-      console.error(error);
-    });
-    this.fetchQueryItems = options.fetchQueryItems;
-    this.mergeItems = options.mergeItems ?? defaultMergeItems;
-    this.purgeDelay = options.purgeDelay ?? 1e4;
-    if (options.registerRemoteChange) {
-      void options.registerRemoteChange(async () => {
-        await this.forceRefetchAll();
-      });
-    }
-  }
-  createCollectionBackend(collection, indices) {
-    this.collectionIndices.set(collection.name, indices);
-    this.queries.set(collection.name, /* @__PURE__ */ new Map());
-    this.ensureStorageAdapter(collection.name);
-    this.activeObservers.set(collection.name, /* @__PURE__ */ new Map());
-    this.observerTimeouts.set(collection.name, /* @__PURE__ */ new Map());
-    this.selectorIds.set(collection.name, /* @__PURE__ */ new Map());
-    this.idRefCounts.set(collection.name, /* @__PURE__ */ new Map());
-    this.autoloadIds.set(collection.name, /* @__PURE__ */ new Set());
-    const ready = this.setupStorage(collection.name, indices);
-    this.storageAdapterReady.set(collection.name, ready);
-    const registerQuery = (selector, options) => {
-      const qid = queryId(selector, options);
-      const registry = this.queries.get(collection.name);
-      if (!registry)
-        throw new Error(`Collection ${collection.name} not initialized!`);
-      registry.set(qid, {
-        selector,
-        options,
-        items: [],
-        listeners: /* @__PURE__ */ new Set(),
-        ...registry.get(qid),
-        state: "active",
-        error: null
-      });
-      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 });
-      const timeouts = this.observerTimeouts.get(collection.name);
-      const t = timeouts?.get(key);
-      if (t)
-        clearTimeout(t);
-      if (current === 0) {
-        void this.fetchAndIngest(collection.name, selector).catch(this.onError);
-      }
-      void this.fulfillQuery(collection.name, selector, options).catch(this.onError);
-    };
-    const unregisterQuery = (selector, options) => {
-      const qid = queryId(selector, options);
-      const registry = this.queries.get(collection.name);
-      registry?.delete(qid);
-      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);
-      if (remaining > 0) {
-        perColObservers?.set(key, { selector, count: remaining });
-        return;
-      }
-      const doPurge = () => {
-        perColObservers?.delete(key);
-        void this.purgeSelector(collection.name, selector).catch(this.onError);
-      };
-      if (this.purgeDelay === 0) {
-        doPurge();
-      } else {
-        const timeouts = this.observerTimeouts.get(collection.name);
-        const t = timeouts?.get(key);
-        if (t)
-          clearTimeout(t);
-        timeouts?.set(key, setTimeout(doPurge, this.purgeDelay));
-      }
-    };
-    const getQueryState = (selector, options) => {
-      const q = this.queries.get(collection.name)?.get(queryId(selector, options));
-      return q?.state ?? "active";
-    };
-    const getQueryError = (selector, options) => {
-      const q = this.queries.get(collection.name)?.get(queryId(selector, options));
-      return q?.error ?? null;
-    };
-    const getQueryResult = (selector, options) => {
-      const q = this.queries.get(collection.name)?.get(queryId(selector, options));
-      return q?.items ?? [];
-    };
-    const onQueryStateChange = (selector, options, callback) => {
-      const qid = queryId(selector, options);
-      const registry = this.queries.get(collection.name);
-      if (!registry)
-        throw new Error(`Collection ${collection.name} not initialized!`);
-      if (!registry.has(qid)) {
-        registry.set(qid, {
-          selector,
-          options,
-          state: "active",
-          error: null,
-          items: [],
-          listeners: /* @__PURE__ */ new Set()
-        });
-      }
-      registry.get(qid)?.listeners.add(callback);
-      return () => {
-        registry.get(qid)?.listeners.delete(callback);
-      };
-    };
-    return {
-      insert: async (item) => {
-        await ready;
-        const inserted = await this.insert(collection.name, item);
-        return inserted;
-      },
-      updateOne: async (selector, modifier) => {
-        await ready;
-        return this.updateOne(collection.name, selector, modifier);
-      },
-      updateMany: async (selector, modifier) => {
-        await ready;
-        return this.updateMany(collection.name, selector, modifier);
-      },
-      replaceOne: async (selector, replacement) => {
-        await ready;
-        return this.replaceOne(collection.name, selector, replacement);
-      },
-      removeOne: async (selector) => {
-        await ready;
-        return this.removeOne(collection.name, selector);
-      },
-      removeMany: async (selector) => {
-        await ready;
-        return this.removeMany(collection.name, selector);
-      },
-      registerQuery,
-      unregisterQuery,
-      getQueryState,
-      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);
-        this.collectionIndices.delete(collection.name);
-        this.storageAdapterReady.delete(collection.name);
-        this.activeObservers.delete(collection.name);
-        this.observerTimeouts.delete(collection.name);
-        this.selectorIds.delete(collection.name);
-        this.idRefCounts.delete(collection.name);
-        this.autoloadIds.delete(collection.name);
-      },
-      isReady: async () => {
-        await ready;
-      }
-    };
-  }
-  // ===== Auto-fetch mechanics =====
-  async forceRefetchAll() {
-    const tasks = [];
-    for (const [collectionName, observers] of this.activeObservers.entries()) {
-      for (const { selector, count } of observers.values()) {
-        if (count > 0)
-          tasks.push(this.fetchAndIngest(collectionName, selector));
-      }
+    this.id = this.options.id || "default-worker-data-adapter";
+    if (this.options.onError) {
+      this.onError = this.options.onError;
     }
-    await Promise.all(tasks);
-  }
-  async fetchAndIngest(collectionName, selector) {
-    this.publishForSelector(collectionName, selector, "active", null);
-    try {
-      const items = await this.fetchQueryItems(collectionName, selector);
-      if (!items || !Array.isArray(items)) {
-        throw new Error("AutoFetchDataAdapter: fetchQueryItems must resolve to { items: T[] }");
-      }
-      const ids = items.map((i) => i.id);
-      const selectorKey = selectorId(selector);
-      const selMap = this.selectorIds.get(collectionName);
-      const previous = selMap?.get(selectorKey) ?? /* @__PURE__ */ new Set();
-      ids.forEach((id) => previous.add(id));
-      selMap?.set(selectorKey, previous);
-      await this.upsertMerged(collectionName, items);
-      await this.checkQueryUpdates(collectionName, items);
-    } catch (error) {
-      this.publishForSelector(collectionName, selector, "error", error);
-      this.onError(error);
+    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");
     }
-  }
-  async purgeSelector(collectionName, selector) {
-    const selectorKey = selectorId(selector);
-    const selMap = this.selectorIds.get(collectionName);
-    const ids = selMap?.get(selectorKey);
-    selMap?.delete(selectorKey);
-    if (!ids || ids.size === 0)
-      return;
-    const referenceMap = this.idRefCounts.get(collectionName);
-    const autoload = this.autoloadIds.get(collectionName);
-    const toRemove = [];
-    for (const id of ids) {
-      const current = referenceMap?.get(id) ?? 0;
-      const next = Math.max(0, current - 1);
-      if (next === 0) {
-        referenceMap?.delete(id);
-        if (autoload?.has(id))
-          toRemove.push(id);
-      } else {
-        referenceMap?.set(id, next);
+    this.workerContext.addEventListener("message", async (event) => {
+      try {
+        const { workerId, id, method, args } = event.data;
+        await this.handleMessage(workerId, id, method, args);
+      } catch (error) {
+        this.onError(error);
       }
-    }
-    if (toRemove.length === 0)
-      return;
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await storage.readIds(toRemove);
-    if (items.length > 0) {
-      await storage.remove(items);
-      await this.checkQueryUpdates(collectionName, items);
-    }
-    toRemove.forEach((id) => autoload?.delete(id));
-  }
-  // ===== Core query + CRUD plumbing (index-aware, same semantics as AsyncDataAdapter) =====
-  async setupStorage(collectionName, indices) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    await Promise.all(indices.map((field) => storage.createIndex(field)));
-    await storage.setup();
+    });
+    this.respond("ready", null, null, "ready");
   }
-  ensureStorageAdapter(name) {
-    if (this.storageAdapters.has(name))
-      return;
-    const adapter = this.options.storage && this.options.storage(name);
-    if (!adapter)
-      return;
-    this.storageAdapters.set(name, adapter);
+  respond(id, data, error = null, type = "response") {
+    this.workerContext.postMessage({ id, workerId: this.id, type, data, error });
   }
-  publishForSelector(collectionName, selector, state, error) {
-    const registry = this.queries.get(collectionName);
-    if (!registry)
+  async handleMessage(workerId, id, method, args) {
+    if (workerId !== this.id)
       return;
-    for (const query of registry.values()) {
-      if (!isEqual(query.selector, selector))
-        continue;
-      this.publishState(collectionName, queryId(query.selector, query.options), state, error);
-    }
-  }
-  publishState(collectionName, qid, state, error) {
-    const query = this.queries.get(collectionName)?.get(qid);
-    if (!query)
+    const fn = this[method];
+    if (typeof fn !== "function") {
+      this.respond(id, null, new Error(`Method ${method} not found`));
       return;
-    query.state = state;
-    query.error = error;
-    for (const callback of query.listeners) {
-      try {
-        callback(state);
-      } catch (error_) {
-        this.onError(error_);
-      }
     }
-  }
-  publishResult(collectionName, qid, items) {
-    const query = this.queries.get(collectionName)?.get(qid);
-    if (!query)
-      return;
-    query.items = items;
-    this.queries.get(collectionName)?.set(qid, query);
-  }
-  async fulfillQuery(collectionName, selector, options) {
-    const qid = queryId(selector, options);
-    const registry = this.queries.get(collectionName);
-    if (!registry)
-      throw new Error(`Collection ${collectionName} not initialized!`);
-    const rec = registry.get(qid);
-    if (!rec)
-      return;
-    this.publishState(collectionName, qid, "active", null);
+    this.log(method, ...args);
+    await this.isReady(args[0]);
     try {
-      const items = await this.executeQuery(collectionName, selector, options);
-      this.publishResult(collectionName, qid, items);
-      this.publishState(collectionName, qid, "complete", null);
+      const result = await fn.apply(this, args);
+      this.respond(id, result);
     } catch (error) {
-      this.publishState(collectionName, qid, "error", error);
+      this.respond(id, null, error);
     }
   }
   async getIndexInfo(collectionName, selector) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
     if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
-      return { matched: true, ids: [selector.id], optimizedSelector: {} };
+      return {
+        matched: true,
+        ids: compact([selector.id]),
+        optimizedSelector: {}
+      };
     }
     if (selector == null) {
-      return { matched: false, ids: [], optimizedSelector: {} };
+      return {
+        matched: false,
+        ids: [],
+        optimizedSelector: {}
+      };
     }
     const indices = this.collectionIndices.get(collectionName) ?? [];
     return getIndexInfo(indices.map((field) => async (flatSelector) => {
-      if (!Object.hasOwnProperty.call(flatSelector, field))
+      if (!Object.hasOwnProperty.call(flatSelector, field)) {
         return { matched: false };
-      const index = await storage.readIndex(field);
+      }
+      const index = await storageAdapter.readIndex(field);
       const fieldSelector = flatSelector[field];
-      const filtersForNull = fieldSelector == null || fieldSelector.$exists === false;
-      const keys = filtersForNull ? { include: null, exclude: [...index.keys()].filter((key) => key != null) } : getMatchingKeys(field, flatSelector);
+      const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
+      const keys = filteresForNull ? { include: null, exclude: [...index.keys()].filter((key) => key != null) } : getMatchingKeys(field, flatSelector);
       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)
+        for (const set of index.values()) {
+          for (const pos of set) {
             includedIds.push(pos);
+          }
+        }
       } else {
         for (const key of keys.include) {
           const idSet = index.get(key);
-          if (idSet)
-            for (const id of idSet)
+          if (idSet) {
+            for (const id of idSet) {
               includedIds.push(id);
+            }
+          }
         }
       }
       if (keys.exclude != null) {
         const excludeIds = /* @__PURE__ */ new Set();
         for (const key of keys.exclude) {
           const idSet = index.get(key);
-          if (idSet)
-            for (const id of idSet)
+          if (idSet) {
+            for (const id of idSet) {
               excludeIds.add(id);
+            }
+          }
         }
         includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
       }
@@ -387,35 +125,38 @@ class AutoFetchDataAdapter {
         matched: true,
         ids: includedIds,
         fields: [field],
-        keepSelector: filtersForNull
+        keepSelector: filteresForNull
       };
     }), selector);
   }
   async queryItems(collectionName, selector) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const index = await this.getIndexInfo(collectionName, selector);
+    const indexInfo = await this.getIndexInfo(collectionName, selector);
     const matchItems = (item) => {
-      if (index.optimizedSelector == null)
+      if (indexInfo.optimizedSelector == null)
         return true;
-      if (Object.keys(index.optimizedSelector).length <= 0)
+      if (Object.keys(indexInfo.optimizedSelector).length <= 0)
         return true;
-      return match(item, index.optimizedSelector);
+      const matches = match(item, indexInfo.optimizedSelector);
+      return matches;
     };
-    if (index.matched) {
-      const items = await storage.readIds(index.ids);
-      if (isEqual(index.optimizedSelector, {}))
+    if (indexInfo.matched) {
+      const items = await storageAdapter.readIds(indexInfo.ids);
+      if (isEqual(indexInfo.optimizedSelector, {}))
         return items;
       return items.filter(matchItems);
     } else {
-      const allItems = await storage.readAll();
+      const allItems = await storageAdapter.readAll();
       if (isEqual(selector, {}))
         return allItems;
       return allItems.filter(matchItems);
     }
   }
   async executeQuery(collectionName, selector, options) {
+    if (selector === null)
+      return [];
     const items = await this.queryItems(collectionName, selector || {});
     const { sort, skip, limit, fields } = options || {};
     const sorted = sort ? sortItems(items, sort) : items;
@@ -425,156 +166,224 @@ class AutoFetchDataAdapter {
     return limited.map((item) => {
       if (!fields)
         return item;
-      return { ...idExcluded ? {} : { id: item.id }, ...project(item, fields) };
+      return {
+        ...idExcluded ? {} : { id: item.id },
+        ...project(item, fields)
+      };
     });
   }
-  async checkQueryUpdates(collectionName, changedItems) {
-    const registry = this.queries.get(collectionName);
-    if (!registry)
+  ensureQuery(collectionName, selector, options) {
+    const id = queryId(selector, options);
+    if (!this.queries.get(collectionName)) {
       throw new Error(`Collection ${collectionName} not initialized!`);
-    if (registry.size === 0)
+    }
+    let query = this.queries.get(collectionName)?.get(id);
+    if (!query) {
+      query = { selector, options };
+      this.queries.get(collectionName)?.set(id, query);
+    }
+    return query;
+  }
+  emitQueryUpdate(collectionName, selector, options, state, error, items) {
+    const id = queryId(selector, options);
+    const collectionQueries = this.queries.get(collectionName);
+    if (!collectionQueries)
+      throw new Error(`Collection ${collectionName} not initialized!`);
+    this.respond(id, { collectionName, selector, options, state, error, items }, null, "queryUpdate");
+  }
+  ensureStorageAdapter(name) {
+    if (this.storageAdapters.has(name))
       return;
-    const affected = [...registry.values()].filter(({ selector }) => changedItems.some((item) => match(item, selector)));
-    if (affected.length === 0)
+    const adapter = this.options.storage(name);
+    if (!adapter)
       return;
-    for (const { selector, options } of affected) {
-      const qid = queryId(selector, options);
-      this.publishState(collectionName, qid, "active", null);
-    }
-    await Promise.all(affected.map(async ({ selector, options }) => {
-      const qid = queryId(selector, options);
-      try {
-        const items = await this.executeQuery(collectionName, selector, options);
-        this.publishResult(collectionName, qid, items);
-        this.publishState(collectionName, qid, "complete", null);
-      } catch (error) {
-        this.publishState(collectionName, qid, "error", error);
-      }
+    this.storageAdapters.set(name, adapter);
+  }
+  async checkQueryUpdates(collectionName, items) {
+    const queries = this.queries.get(collectionName);
+    if (!queries)
+      throw new Error(`Collection ${collectionName} not initialized!`);
+    const affectedQueries = [...queries.values()].filter(({ selector }) => items.some((item) => match(item, selector))) ?? [];
+    if (affectedQueries.length === 0)
+      return;
+    affectedQueries.forEach(({ selector, options }) => {
+      this.emitQueryUpdate(collectionName, selector, options, "active", null);
+    });
+    await Promise.all(affectedQueries.map(async ({ selector, options }) => {
+      const queryItems = await this.executeQuery(collectionName, selector, options);
+      this.emitQueryUpdate(collectionName, selector, options, "complete", null, queryItems);
     }));
   }
-  // ===== CRUD with push-style query updates =====
-  async insert(collectionName, newItem) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
+  registerCollection = async (collectionName, indices) => {
+    this.collectionIndices.set(collectionName, indices);
+    this.queries.set(collectionName, /* @__PURE__ */ new Map());
+    this.ensureStorageAdapter(collectionName);
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const existing = await this.executeQuery(collectionName, { id: newItem.id }, { limit: 1 });
-    if (existing.length > 0)
-      throw new Error(`Item with id ${String(newItem.id)} already exists`);
-    await storage.insert([newItem]);
-    await this.checkQueryUpdates(collectionName, [newItem]);
-    return newItem;
-  }
-  async updateOne(collectionName, selector, modifier) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
+    const setupPromise = (async () => {
+      await Promise.all(indices.map((index) => storageAdapter.createIndex(index)));
+      await storageAdapter.setup();
+    })();
+    this.storageAdapterReady.set(collectionName, setupPromise);
+    await setupPromise;
+  };
+  unregisterCollection = async (collectionName) => {
+    this.storageAdapters.delete(collectionName);
+    this.queries.delete(collectionName);
+  };
+  registerQuery = async (collectionName, selector, options) => {
+    this.ensureQuery(collectionName, selector, options);
+    const queryItems = await this.executeQuery(collectionName, selector, options);
+    this.emitQueryUpdate(collectionName, selector, options, "complete", null, queryItems);
+  };
+  unregisterQuery = async (collectionName, selector, options) => {
+    const id = queryId(selector, options);
+    if (!this.queries.get(collectionName))
+      throw new Error(`Collection ${collectionName} not initialized!`);
+    this.queries.get(collectionName)?.delete(id);
+  };
+  insert = async (collectionName, input) => {
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector, { limit: 1 });
-    const [item] = items;
-    const { $setOnInsert, ...rest } = modifier;
-    if (item == null)
-      return [];
-    const modified = modify(deepClone(item), rest);
-    if (item.id !== modified.id) {
-      const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
-      if (existing.length > 0)
-        throw new Error(`Item with id ${String(modified.id)} already exists`);
-    }
-    await storage.replace([modified]);
-    await this.checkQueryUpdates(collectionName, [item, modified]);
-    return [modified];
-  }
-  async updateMany(collectionName, selector, modifier) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
+    const existingItems = await this.executeQuery(collectionName, { id: { $in: input.map((i) => i[0].id) } });
+    const result = input.map(([item]) => {
+      if (item.id == null)
+        return 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`);
+      }
+      return item;
+    });
+    const newItems = result.filter((item) => !(item instanceof Error));
+    await storageAdapter.insert(newItems);
+    await this.checkQueryUpdates(collectionName, newItems);
+    return result;
+  };
+  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, ...rest } = modifier;
-    const changed = await Promise.all(items.map(async (item) => {
-      const modified = modify(deepClone(item), rest);
-      if (item.id !== modified.id) {
-        const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
-        if (existing.length > 0)
-          throw new Error(`Item with id ${String(modified.id)} already exists`);
+    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) {
+          return new Error(`Item with id ${modifiedItem.id} already exists`);
+        }
       }
-      return modified;
+      return [modifiedItem];
     }));
-    await storage.replace(changed);
-    await this.checkQueryUpdates(collectionName, [...items, ...changed]);
-    return changed;
-  }
-  async replaceOne(collectionName, selector, replacement) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
+    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;
+  };
+  updateMany = 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, { limit: 1 });
-    const [item] = items;
-    if (item == null)
-      return [];
-    const modified = { ...replacement, id: replacement.id ?? item.id };
-    if (item.id !== modified.id) {
-      const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
-      if (existing.length > 0)
-        throw new Error(`Item with id ${String(modified.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]);
     }
-    await storage.replace([modified]);
-    await this.checkQueryUpdates(collectionName, [item, modified]);
-    return [modified];
-  }
-  async removeOne(collectionName, selector) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
+    return result;
+  };
+  replaceOne = 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, { limit: 1 });
-    const [item] = items;
-    if (item == null)
-      return [];
-    await storage.remove([item]);
-    await this.checkQueryUpdates(collectionName, [item]);
-    return [item];
-  }
-  async removeMany(collectionName, selector) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
+    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]);
+    }
+    return result;
+  };
+  removeOne = 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 storage.remove(items);
-    await this.checkQueryUpdates(collectionName, items);
-    return items;
-  }
-  // ===== Upsert/merge helper for ingesting fetched items =====
-  async upsertMerged(collectionName, incoming) {
-    if (incoming.length === 0)
-      return;
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
+    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, selectors) => {
+    const storageAdapter = this.storageAdapters.get(collectionName);
+    if (!storageAdapter)
       throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const ids = incoming.map((i) => i.id);
-    const existing = await storage.readIds(ids);
-    const existingById = new Map(existing.map((it) => [it.id, it]));
-    const toInsert = [];
-    const toReplace = [];
-    const referenceMap = this.idRefCounts.get(collectionName);
-    const autoload = this.autoloadIds.get(collectionName);
-    for (const item of incoming) {
-      const previous = existingById.get(item.id);
-      if (previous) {
-        toReplace.push(this.mergeItems(previous, item));
-      } else {
-        toInsert.push(item);
-      }
-      autoload?.add(item.id);
-      referenceMap?.set(item.id, (referenceMap?.get(item.id) ?? 0) + 1);
+    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);
     }
-    if (toInsert.length > 0)
-      await storage.insert(toInsert);
-    if (toReplace.length > 0)
-      await storage.replace(toReplace);
-  }
+    return result;
+  };
+  isReady = async (collectionName) => {
+    return this.storageAdapterReady.get(collectionName);
+  };
 }
 export {
-  AutoFetchDataAdapter as default
+  WorkerDataAdapterHost as default
 };