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

package/dist/index13.mjs

@@ -1,215 +1,68 @@
-import deepClone from "./index19.mjs";
-import match from "./index23.mjs";
-import modify from "./index7.mjs";
-import queryId from "./index20.mjs";
+import createIndex from "./index22.mjs";
+import getIndexInfo from "./index23.mjs";
+import deepClone from "./index20.mjs";
+import EventEmitter from "./index9.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";
-class AsyncDataAdapter {
+import match from "./index24.mjs";
+import modify from "./index7.mjs";
+import project from "./index25.mjs";
+import queryId from "./index21.mjs";
+import serializeValue from "./index11.mjs";
+import sortItems from "./index26.mjs";
+function hasPendingUpdates(pendingUpdates) {
+  return pendingUpdates.added.length > 0 || pendingUpdates.modified.length > 0 || pendingUpdates.removed.length > 0;
+}
+class DefaultDataAdapter {
+  items = /* @__PURE__ */ new Map();
   options;
-  id;
-  onError;
-  // Per-collection resources
   storageAdapters = /* @__PURE__ */ new Map();
-  storageAdapterReady = /* @__PURE__ */ new Map();
-  collectionIndices = /* @__PURE__ */ new Map();
-  // Per-collection query registries
-  queries = /* @__PURE__ */ new Map();
+  collections = /* @__PURE__ */ new Set();
+  indices = /* @__PURE__ */ new Map();
+  activeQueries = /* @__PURE__ */ new Map();
+  queryEmitters = /* @__PURE__ */ new Map();
+  queuedQueryUpdates = /* @__PURE__ */ new Map();
+  cachedQueryResults = /* @__PURE__ */ new Map();
   constructor(options) {
-    this.options = options;
-    this.id = options.id || "async-data-adapter";
-    this.onError = options.onError ?? ((error) => {
-      console.error(error);
-    });
-  }
-  createCollectionBackend(collection, indices) {
-    this.collectionIndices.set(collection.name, indices);
-    this.queries.set(collection.name, /* @__PURE__ */ new Map());
-    this.ensureStorageAdapter(collection.name);
-    const ready = (async () => {
-      try {
-        await this.setupStorage(collection.name, indices);
-      } catch (error) {
-        this.onError(error);
-        throw error;
-      }
-    })();
-    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
-      });
-      void this.fulfillQuery(collection.name, selector, options).catch(this.onError);
-    };
-    const unregisterQuery = (selector, options) => {
-      const qid = queryId(selector, options);
-      this.queries.get(collection.name)?.delete(qid);
-    };
-    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);
-        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);
-      },
-      isReady: async () => {
-        await ready;
-      }
-    };
-  }
-  async setupStorage(collectionName, indices) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    await storage.setup();
-    await Promise.all(indices.map((index) => storage.createIndex(index)));
+    this.options = options || {};
   }
   ensureStorageAdapter(name) {
-    if (this.storageAdapters.has(name))
+    if (this.storageAdapters.get(name))
+      return;
+    if (!this.options.storage)
       return;
     const adapter = this.options.storage(name);
     if (!adapter)
       return;
     this.storageAdapters.set(name, adapter);
   }
-  /**
-   * Compute and publish the result for a specific query
-   * @param collectionName - name of the collection
-   * @param selector - query selector
-   * @param options - query options
-   */
-  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);
-    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);
-    }
+  rebuildIndices(collection) {
+    const items = this.items.get(collection.name);
+    if (!items)
+      throw new Error(`Items not found for collection ${collection.name}`);
+    const indices = this.indices.get(collection.name);
+    if (!indices)
+      throw new Error(`Indices not found for collection ${collection.name}`);
+    indices.forEach((index) => index.rebuild([...items.values()]));
   }
-  /**
-   * Notify listeners about state changes and keep the cache updated
-   * @param collectionName - name of the collection
-   * @param qid - query id
-   * @param state - new state
-   * @param error - error if state is 'error', null otherwise
-   */
-  publishState(collectionName, qid, state, error) {
-    const rec = this.queries.get(collectionName)?.get(qid);
-    if (!rec)
+  async setupStorageAdapter(collection) {
+    const storageAdapter = this.storageAdapters.get(collection.name);
+    if (!storageAdapter)
       return;
-    rec.state = state;
-    rec.error = error;
-    for (const callback of rec.listeners) {
-      try {
-        callback(state);
-      } catch (error_) {
-        this.onError(error_);
+    return storageAdapter.setup().then(async () => {
+      await this.fetchItemsFromStorage(collection);
+    }).catch((error) => {
+      if (!this.options.onError) {
+        console.error(`Error during data persistence operation in collection ${collection.name}`, error);
+        return;
       }
-    }
-  }
-  publishResult(collectionName, qid, items) {
-    const rec = this.queries.get(collectionName)?.get(qid);
-    if (!rec)
-      return;
-    rec.items = items;
+      this.options.onError(collection.name, error instanceof Error ? error : new Error(error));
+    });
   }
-  async getIndexInfo(collectionName, selector) {
-    const storageAdapter = this.storageAdapters.get(collectionName);
-    if (!storageAdapter)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
+  getIndexInfo(collection, selector) {
     if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
       return {
         matched: true,
-        ids: [selector.id].filter(Boolean),
+        ids: [serializeValue(selector.id)],
         optimizedSelector: {}
       };
     }
@@ -220,68 +73,49 @@ class AsyncDataAdapter {
         optimizedSelector: {}
       };
     }
-    const indices = this.collectionIndices.get(collectionName) ?? [];
-    return getIndexInfo(indices.map((field) => async (flatSelector) => {
-      if (!Object.hasOwnProperty.call(flatSelector, field))
-        return { matched: false };
-      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);
-      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 idSet = index.get(key);
-          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)
-              excludeIds.add(id);
-        }
-        includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
-      }
-      return { matched: true, ids: includedIds, fields: [field], keepSelector: filtersForNull };
-    }), selector);
+    return getIndexInfo((this.indices.get(collection.name) ?? []).map((i) => i.query.bind(i)), selector);
+  }
+  applyIndexDeltas(collection, changes) {
+    const indices = this.indices.get(collection.name) ?? [];
+    for (const index of indices) {
+      if (changes.modified)
+        index.update(changes.modified);
+      if (changes.added && changes.added.length > 0)
+        index.insert(changes.added);
+      if (changes.removed && changes.removed.length > 0)
+        index.remove(changes.removed);
+    }
+  }
+  getItem(collection, selector) {
+    const memory = this.items.get(collection.name) ?? /* @__PURE__ */ new Map();
+    const indexInfo = this.getIndexInfo(collection, selector);
+    const items = indexInfo.matched ? indexInfo.ids.map((id) => memory.get(serializeValue(id))).filter((i) => i != null) : [...memory.values()];
+    const item = items.find((document) => match(document, selector));
+    return item;
   }
-  async queryItems(collectionName, selector) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const index = await this.getIndexInfo(collectionName, selector);
+  queryItems(collection, selector) {
+    const indexInfo = this.getIndexInfo(collection, 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, {}))
-        return items;
-      return items.filter(matchItems);
-    } else {
-      const allItems = await storage.readAll();
+    const items = this.items.get(collection.name);
+    if (!indexInfo.matched) {
       if (isEqual(selector, {}))
-        return allItems;
-      return allItems.filter(matchItems);
+        return [...items.values()];
+      return [...items.values()].filter(matchItems);
     }
+    const foundItems = indexInfo.ids.map((ids) => items.get(serializeValue(ids))).filter((i) => i != null);
+    if (isEqual(indexInfo.optimizedSelector, {}))
+      return foundItems;
+    return foundItems.filter(matchItems);
   }
-  async executeQuery(collectionName, selector, options) {
-    const items = await this.queryItems(collectionName, selector || {});
+  executeQuery(collection, selector, options) {
+    const items = this.queryItems(collection, selector || {});
     const { sort, skip, limit, fields } = options || {};
     const sorted = sort ? sortItems(items, sort) : items;
     const skipped = skip ? sorted.slice(skip) : sorted;
@@ -290,131 +124,243 @@ class AsyncDataAdapter {
     return limited.map((item) => {
       if (!fields)
         return item;
-      return { ...idExcluded ? {} : { id: item.id }, ...project(item, fields) };
+      return {
+        ...idExcluded ? {} : { id: item.id },
+        ...project(item, fields)
+      };
     });
   }
-  /**
-   * After mutations, recompute and push updates for affected active queries
-   * @param collectionName - name of the collection
-   * @param changedItems - items that were inserted/updated/replaced/removed
-   */
-  async checkQueryUpdates(collectionName, changedItems) {
-    const registry = this.queries.get(collectionName);
-    if (!registry)
-      throw new Error(`Collection ${collectionName} not initialized!`);
-    if (registry.size === 0)
+  flushQueuedQueryUpdates(collection) {
+    if (!this.queuedQueryUpdates.get(collection.name))
       return;
-    const affected = [...registry.values()].filter(({ selector }) => changedItems.some((item) => match(item, selector)));
-    if (affected.length === 0)
+    const changes = this.queuedQueryUpdates.get(collection.name);
+    if (!changes || !hasPendingUpdates(changes))
       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.queuedQueryUpdates.set(collection.name, { added: [], modified: [], removed: [] });
+    const flatItems = [...changes.added, ...changes.modified, ...changes.removed];
+    const itemIds = new Set(flatItems.map((i) => i.id));
+    const queries = [
+      ...this.activeQueries.get(collection.name)?.values() ?? []
+    ].filter(({ selector, options }) => {
+      const idsInQuery = this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options))?.map((i) => i.id) ?? [];
+      if (idsInQuery.some((id) => itemIds.has(id)))
+        return true;
+      return flatItems.some((item) => match(item, selector));
+    });
+    queries.forEach(({ selector, options }) => {
+      this.executeAndCacheQuery(collection, selector, options);
+    });
   }
-  async insert(collectionName, newItem) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const existingItems = await storage.readIds([newItem.id]);
-    if (existingItems.length > 0)
-      throw new Error(`Item with id ${String(newItem.id)} already exists`);
-    await storage.insert([newItem]);
-    await this.checkQueryUpdates(collectionName, [newItem]);
-    return newItem;
+  executeAndCacheQuery(collection, selector, options) {
+    const result = this.executeQuery(collection, selector, options);
+    this.cachedQueryResults.set(collection.name, this.cachedQueryResults.get(collection.name) || /* @__PURE__ */ new Map());
+    this.cachedQueryResults.get(collection.name)?.set(queryId(selector, options), result);
+    const emitter = this.queryEmitters.get(collection.name);
+    if (!emitter)
+      return;
+    emitter.emit("change", selector, options, "complete");
   }
-  async updateOne(collectionName, selector, modifier) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      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, [modified]);
-    return [modified];
+  updateQueries(collection, changes) {
+    this.queuedQueryUpdates.set(collection.name, this.queuedQueryUpdates.get(collection.name) || { added: [], modified: [], removed: [] });
+    this.queuedQueryUpdates.get(collection.name)?.added.push(...changes.added);
+    this.queuedQueryUpdates.get(collection.name)?.modified.push(...changes.modified);
+    this.queuedQueryUpdates.get(collection.name)?.removed.push(...changes.removed);
+    this.flushQueuedQueryUpdates(collection);
   }
-  async updateMany(collectionName, selector, modifier) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      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`);
-      }
-      return modified;
-    }));
-    await storage.replace(changed);
-    await this.checkQueryUpdates(collectionName, changed);
-    return changed;
+  createCollectionBackend(collection, indices) {
+    this.collections.add(collection);
+    this.ensureStorageAdapter(collection.name);
+    this.items.set(collection.name, this.items.get(collection.name) ?? /* @__PURE__ */ new Map());
+    this.queryEmitters.set(collection.name, this.queryEmitters.get(collection.name) ?? new EventEmitter());
+    this.queryEmitters.get(collection.name)?.setMaxListeners(Infinity);
+    this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
+    this.indices.set(collection.name, indices.map((field) => createIndex(field)));
+    this.rebuildIndices(collection);
+    const persistenceReadyPromise = this.setupStorageAdapter(collection);
+    const backend = {
+      // CRUD operations
+      insert: async (newItem) => {
+        const items = this.items.get(collection.name);
+        if (!items)
+          throw new Error(`Items not found for collection ${collection.name}`);
+        if (items.has(serializeValue(newItem.id))) {
+          throw new Error(`Item with id '${newItem.id}' already exists`);
+        }
+        this.items.get(collection.name)?.set(serializeValue(newItem.id), newItem);
+        await this.storageAdapters.get(collection.name)?.insert([newItem]);
+        this.applyIndexDeltas(collection, { added: [newItem] });
+        this.updateQueries(collection, {
+          added: [],
+          modified: [newItem],
+          removed: []
+        });
+        return newItem;
+      },
+      updateOne: async (selector, modifier) => {
+        const { $setOnInsert, ...restModifier } = modifier;
+        const item = this.getItem(collection, selector);
+        if (item == null)
+          return [];
+        const modifiedItem = modify(deepClone(item), restModifier);
+        const hasItemWithSameId = item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null;
+        if (hasItemWithSameId) {
+          throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+        }
+        this.items.get(collection.name)?.set(serializeValue(modifiedItem.id), modifiedItem);
+        await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
+        this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
+        this.updateQueries(collection, {
+          added: [],
+          modified: [modifiedItem],
+          removed: []
+        });
+        return [modifiedItem];
+      },
+      updateMany: async (selector, modifier) => {
+        const { $setOnInsert, ...restModifier } = modifier;
+        const items = this.executeQuery(collection, selector, {});
+        const changedItems = items.map((item) => {
+          const modifiedItem = modify(deepClone(item), restModifier);
+          const hasItemWithSameId = item.id !== modifiedItem.id && this.getItem(collection, { id: modifiedItem.id }) != null;
+          if (hasItemWithSameId) {
+            throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+          }
+          return modifiedItem;
+        });
+        changedItems.forEach((item) => {
+          this.items.get(collection.name)?.set(serializeValue(item.id), item);
+        });
+        await this.storageAdapters.get(collection.name)?.replace(changedItems);
+        const pairs = items.map((oldItem, index) => ({ oldItem, newItem: changedItems[index] }));
+        this.applyIndexDeltas(collection, { modified: pairs });
+        this.updateQueries(collection, {
+          added: [],
+          modified: changedItems,
+          removed: []
+        });
+        return changedItems;
+      },
+      replaceOne: async (selector, replacement) => {
+        const item = this.getItem(collection, selector);
+        if (item == null)
+          return [];
+        const hasItemWithSameId = item.id !== replacement.id && replacement.id != null && this.getItem(collection, { id: replacement.id }) != null;
+        if (hasItemWithSameId) {
+          throw new Error(`Item with id '${replacement.id}' already exists`);
+        }
+        const modifiedItem = { id: item.id, ...replacement };
+        this.items.get(collection.name)?.set(serializeValue(modifiedItem.id), modifiedItem);
+        await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
+        this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
+        this.updateQueries(collection, {
+          added: [],
+          modified: [modifiedItem],
+          removed: []
+        });
+        return [modifiedItem];
+      },
+      removeOne: async (selector) => {
+        const item = this.getItem(collection, selector);
+        if (item == null)
+          return [];
+        this.items.get(collection.name)?.delete(serializeValue(item.id));
+        await this.storageAdapters.get(collection.name)?.remove([item]);
+        this.applyIndexDeltas(collection, { removed: [item] });
+        this.updateQueries(collection, {
+          added: [],
+          modified: [],
+          removed: [item]
+        });
+        return [item];
+      },
+      removeMany: async (selector) => {
+        const items = backend.getQueryResult(selector, {});
+        items.forEach((item) => {
+          this.items.get(collection.name)?.delete(serializeValue(item.id));
+        });
+        await this.storageAdapters.get(collection.name)?.remove(items);
+        this.applyIndexDeltas(collection, { removed: items });
+        this.updateQueries(collection, {
+          added: [],
+          modified: [],
+          removed: items
+        });
+        return items;
+      },
+      // methods for registering and unregistering queries that will be called from the collection during find/findOne
+      registerQuery: (selector, options) => {
+        this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || /* @__PURE__ */ new Map());
+        this.activeQueries.get(collection.name)?.set(queryId(selector, options), {
+          selector,
+          options
+        });
+        this.executeAndCacheQuery(collection, selector, options);
+      },
+      unregisterQuery: (selector, options) => {
+        if (!this.activeQueries.get(collection.name))
+          return;
+        this.activeQueries.get(collection.name)?.delete(queryId(selector, options));
+      },
+      getQueryState: () => "complete",
+      onQueryStateChange: (selector, options, callback) => {
+        const emitter = this.queryEmitters.get(collection.name);
+        if (!emitter)
+          throw new Error(`Query emitter not found for collection ${collection.name}`);
+        const handler = (querySelector, queryOptions, state) => {
+          if (queryId(querySelector, queryOptions) !== queryId(selector, options))
+            return;
+          callback(state);
+        };
+        emitter.on("change", handler);
+        return () => {
+          emitter.off("change", handler);
+        };
+      },
+      getQueryError: () => null,
+      getQueryResult: (selector, options) => {
+        const isQueryActive = this.activeQueries.get(collection.name)?.has(queryId(selector, options));
+        if (isQueryActive) {
+          const results = this.cachedQueryResults.get(collection.name)?.get(queryId(selector, options));
+          if (!results)
+            throw new Error("Cached query results are not defined!");
+          return results;
+        }
+        return this.executeQuery(collection, selector, options);
+      },
+      executeQuery: (selector, options) => Promise.resolve(this.executeQuery(collection, selector, options)),
+      // lifecycle methods
+      dispose: async () => {
+        const adapter = this.storageAdapters.get(collection.name);
+        if (adapter?.teardown)
+          await adapter.teardown();
+        this.storageAdapters.delete(collection.name);
+        this.items.delete(collection.name);
+        this.indices.delete(collection.name);
+        this.activeQueries.delete(collection.name);
+        this.queryEmitters.delete(collection.name);
+        this.queuedQueryUpdates.delete(collection.name);
+        this.cachedQueryResults.delete(collection.name);
+      },
+      isReady: () => persistenceReadyPromise
+    };
+    return backend;
   }
-  async replaceOne(collectionName, selector, replacement) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      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`);
+  async fetchItemsFromStorage(collection) {
+    if (!collection) {
+      await Promise.all([...this.collections].map((currentCollection) => this.fetchItemsFromStorage(currentCollection)));
+      return;
     }
-    await storage.replace([modified]);
-    await this.checkQueryUpdates(collectionName, [modified]);
-    return [modified];
-  }
-  async removeOne(collectionName, selector) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      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)
-      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;
+    const storageAdapter = this.storageAdapters.get(collection.name);
+    if (!storageAdapter)
+      return;
+    const items = await storageAdapter.readAll();
+    this.items.set(collection.name, items.reduce((map, item) => {
+      map.set(serializeValue(item.id), item);
+      return map;
+    }, /* @__PURE__ */ new Map()));
+    this.rebuildIndices(collection);
   }
 }
 export {
-  AsyncDataAdapter as default
+  DefaultDataAdapter as default
 };