@signaldb/core 1.7.1 → 2.0.0-beta.0

package/dist/index3.mjs

@@ -1,37 +1,10 @@
-import EventEmitter from "./index13.mjs";
-import match from "./index18.mjs";
-import modify from "./index11.mjs";
-import isEqual from "./index10.mjs";
-import randomId from "./index12.mjs";
+import EventEmitter from "./index9.mjs";
+import createSignal from "./index18.mjs";
+import randomId from "./index8.mjs";
+import DefaultDataAdapter from "./index12.mjs";
+import modify from "./index7.mjs";
 import deepClone from "./index19.mjs";
-import serializeValue from "./index20.mjs";
-import createSignal from "./index21.mjs";
 import Cursor from "./index2.mjs";
-import getIndexInfo from "./index22.mjs";
-import { createExternalIndex } from "./index14.mjs";
-import { default as default2 } from "./index14.mjs";
-function hasPendingUpdates(pendingUpdates) {
-  return pendingUpdates.added.length > 0 || pendingUpdates.modified.length > 0 || pendingUpdates.removed.length > 0;
-}
-function applyUpdates(currentItems, { added, modified, removed }) {
-  const items = [...currentItems];
-  added.forEach((item) => {
-    items.push(item);
-  });
-  modified.forEach((item) => {
-    const index = items.findIndex(({ id }) => id === item.id);
-    if (index === -1)
-      return;
-    items[index] = item;
-  });
-  removed.forEach((item) => {
-    const index = items.findIndex(({ id }) => id === item.id);
-    if (index === -1)
-      return;
-    items.splice(index, 1);
-  });
-  return items;
-}
 class Collection extends EventEmitter {
   static collections = [];
   static debugMode = false;
@@ -67,210 +40,58 @@ class Collection extends EventEmitter {
       collection.setFieldTracking(enable);
     });
   };
-  /**
-   * Executes a batch operation, allowing multiple modifications to the collection
-   * while deferring index rebuilding until all operations in the batch are completed.
-   * This improves performance by avoiding repetitive index recalculations and
-   * provides atomicity for the batch of operations.
-   * @param callback - The batch operation to execute.
-   */
   static batch(callback) {
     Collection.batchOperationInProgress = true;
-    Collection.collections.reduce((memo, collection) => () => collection.batch(() => memo()), callback)();
-    Collection.batchOperationInProgress = false;
+    const execute = () => Collection.collections.reduce((memo, collection) => () => {
+      return collection.batch(memo);
+    }, callback)();
+    const maybePromise = execute();
+    const afterBatch = () => {
+      Collection.batchOperationInProgress = false;
+    };
+    if (maybePromise && typeof maybePromise.then === "function") {
+      return maybePromise.then(() => afterBatch());
+    } else {
+      afterBatch();
+    }
   }
   name;
+  backend;
   options;
-  persistenceAdapter = null;
   isPullingSignal;
   isPushingSignal;
-  indexProviders = [];
-  indicesOutdated = false;
-  idIndex = /* @__PURE__ */ new Map();
+  readySignal;
   debugMode;
   batchOperationInProgress = false;
   isDisposed = false;
   postBatchCallbacks = /* @__PURE__ */ new Set();
   fieldTracking = false;
-  persistenceReadyPromise;
-  /**
-   * Initializes a new instance of the `Collection` class with optional configuration.
-   * Sets up memory, persistence, reactivity, and indices as specified in the options.
-   * @template T - The type of the items stored in the collection.
-   * @template I - The type of the unique identifier for the items.
-   * @template U - The transformed item type after applying transformations (default is T).
-   * @param options - Optional configuration for the collection.
-   * @param options.name - An optional name for the collection.
-   * @param options.memory - The in-memory adapter for storing items.
-   * @param options.reactivity - The reactivity adapter for observing changes in the collection.
-   * @param options.transform - A transformation function to apply to items when retrieving them.
-   * @param options.persistence - The persistence adapter for saving and loading items.
-   * @param options.indices - An array of index providers for optimized querying.
-   * @param options.enableDebugMode - A boolean to enable or disable debug mode.
-   * @param options.fieldTracking - A boolean to enable or disable field tracking by default.
-   */
-  constructor(options) {
+  constructor(nameOrOptions, maybeDataAdapter, maybeOptions) {
     super();
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name || `${this.constructor.name}-${randomId()}`;
+    const options = typeof nameOrOptions === "string" ? maybeOptions || {} : nameOrOptions || {};
+    const persistence = options.persistence;
+    const dataAdapter = maybeDataAdapter || new DefaultDataAdapter({
+      ...persistence ? { storage: () => persistence } : {}
+    });
     Collection.collections.push(this);
-    this.name = options?.name ?? `${this.constructor.name}-${randomId()}`;
-    this.options = {
-      memory: [],
-      ...options
-    };
+    this.name = name;
+    this.options = { ...options };
     this.fieldTracking = this.options.fieldTracking ?? Collection.fieldTracking;
     this.debugMode = this.options.enableDebugMode ?? Collection.debugMode;
-    this.indexProviders = [
-      createExternalIndex("id", this.idIndex),
-      ...this.options.indices || []
-    ];
-    this.rebuildIndices();
-    this.isPullingSignal = createSignal(this.options.reactivity, !!options?.persistence);
+    this.isPullingSignal = createSignal(this.options.reactivity, false);
     this.isPushingSignal = createSignal(this.options.reactivity, false);
-    this.on("persistence.pullStarted", () => {
-      this.isPullingSignal.set(true);
-    });
-    this.on("persistence.pullCompleted", () => {
-      this.isPullingSignal.set(false);
-    });
-    this.on("persistence.pushStarted", () => {
-      this.isPushingSignal.set(true);
-    });
-    this.on("persistence.pushCompleted", () => {
-      this.isPushingSignal.set(false);
-    });
-    this.persistenceAdapter = this.options.persistence ?? null;
-    if (this.persistenceAdapter) {
-      let ongoingSaves = 0;
-      let isInitialized = false;
-      const pendingUpdates = { added: [], modified: [], removed: [] };
-      const loadPersistentData = async (data) => {
-        if (!this.persistenceAdapter)
-          throw new Error("Persistence adapter not found");
-        this.emit("persistence.pullStarted");
-        const { items, changes } = data ?? await this.persistenceAdapter.load();
-        if (items) {
-          if (ongoingSaves > 0)
-            return;
-          this.memory().splice(0, this.memoryArray().length, ...items);
-          this.idIndex.clear();
-          this.memory().map((item, index) => {
-            this.idIndex.set(serializeValue(item.id), /* @__PURE__ */ new Set([index]));
-          });
-        } else if (changes) {
-          changes.added.forEach((item) => {
-            const index = this.memory().findIndex((document) => document.id === item.id);
-            if (index !== -1) {
-              this.memory().splice(index, 1, item);
-              return;
-            }
-            this.memory().push(item);
-            const itemIndex = this.memory().findIndex((document) => document === item);
-            this.idIndex.set(serializeValue(item.id), /* @__PURE__ */ new Set([itemIndex]));
-          });
-          changes.modified.forEach((item) => {
-            const index = this.memory().findIndex((document) => document.id === item.id);
-            if (index === -1)
-              throw new Error("Cannot resolve index for item");
-            this.memory().splice(index, 1, item);
-          });
-          changes.removed.forEach((item) => {
-            const index = this.memory().findIndex((document) => document.id === item.id);
-            if (index === -1)
-              throw new Error("Cannot resolve index for item");
-            this.memory().splice(index, 1);
-          });
-        }
-        this.rebuildIndices();
-        this.emit("persistence.received");
-        setTimeout(() => this.emit("persistence.pullCompleted"), 0);
-      };
-      const saveQueue = {
-        added: [],
-        modified: [],
-        removed: []
-      };
-      let isFlushing = false;
-      const flushQueue = () => {
-        if (!this.persistenceAdapter)
-          throw new Error("Persistence adapter not found");
-        if (ongoingSaves <= 0)
-          this.emit("persistence.pushStarted");
-        if (isFlushing)
-          return;
-        if (!hasPendingUpdates(saveQueue))
-          return;
-        isFlushing = true;
-        ongoingSaves += 1;
-        const currentItems = this.memoryArray();
-        const changes = { ...saveQueue };
-        saveQueue.added = [];
-        saveQueue.modified = [];
-        saveQueue.removed = [];
-        this.persistenceAdapter.save(currentItems, changes).then(() => {
-          this.emit("persistence.transmitted");
-        }).catch((error) => {
-          this.emit("persistence.error", error instanceof Error ? error : new Error(error));
-        }).finally(() => {
-          ongoingSaves -= 1;
-          isFlushing = false;
-          flushQueue();
-          if (ongoingSaves <= 0)
-            this.emit("persistence.pushCompleted");
-        });
-      };
-      this.on("added", (item) => {
-        if (!isInitialized) {
-          pendingUpdates.added.push(item);
-          return;
-        }
-        saveQueue.added.push(item);
-        flushQueue();
-      });
-      this.on("changed", (item) => {
-        if (!isInitialized) {
-          pendingUpdates.modified.push(item);
-          return;
-        }
-        saveQueue.modified.push(item);
-        flushQueue();
-      });
-      this.on("removed", (item) => {
-        if (!isInitialized) {
-          pendingUpdates.removed.push(item);
-          return;
-        }
-        saveQueue.removed.push(item);
-        flushQueue();
-      });
-      this.persistenceAdapter.register((data) => loadPersistentData(data)).then(async () => {
-        if (!this.persistenceAdapter)
-          throw new Error("Persistence adapter not found");
-        let currentItems = this.memoryArray();
-        await loadPersistentData();
-        while (hasPendingUpdates(pendingUpdates)) {
-          const added = pendingUpdates.added.splice(0);
-          const modified = pendingUpdates.modified.splice(0);
-          const removed = pendingUpdates.removed.splice(0);
-          currentItems = applyUpdates(this.memoryArray(), { added, modified, removed });
-          await this.persistenceAdapter.save(currentItems, { added, modified, removed }).then(() => {
-            this.emit("persistence.transmitted");
-          });
-        }
-        await loadPersistentData();
-        isInitialized = true;
-        setTimeout(() => this.emit("persistence.init"), 0);
-      }).catch((error) => {
-        this.emit("persistence.error", error instanceof Error ? error : new Error(error));
-      });
-    }
-    this.persistenceReadyPromise = new Promise((resolve, reject) => {
-      if (!this.persistenceAdapter)
-        return resolve();
-      this.once("persistence.init", resolve);
-      this.once("persistence.error", reject);
+    this.readySignal = createSignal(this.options.reactivity, false);
+    this.backend = dataAdapter.createCollectionBackend(this, this.options.indices ?? []);
+    void this.backend.isReady().then(() => {
+      this.readySignal.set(true);
+    }).catch(() => {
     });
     Collection.onCreationCallbacks.forEach((callback) => callback(this));
   }
+  isBatchOperationInProgress() {
+    return Collection.batchOperationInProgress || this.batchOperationInProgress;
+  }
   /**
    * Checks whether the collection is currently performing a pull operation
    * ⚡️ this function is reactive!
@@ -335,17 +156,28 @@ class Collection extends EventEmitter {
    *
    * collection.insert({ name: 'Item 1' })
    */
-  async isReady() {
-    return this.persistenceReadyPromise;
+  async ready() {
+    return this.backend.isReady();
+  }
+  /**
+   * Checks if the collection is ready.
+   * ⚡️ this function is reactive!
+   * @returns A boolean indicating whether the collection is ready.
+   */
+  isReady() {
+    return this.readySignal.get() ?? false;
   }
   profile(fn, measureFunction) {
     if (!this.debugMode)
       return fn();
     const startTime = performance.now();
-    const result = fn();
-    const endTime = performance.now();
-    measureFunction(endTime - startTime);
-    return result;
+    const handleProfileEnd = (result) => {
+      const endTime = performance.now();
+      measureFunction(endTime - startTime);
+      return result;
+    };
+    const maybePromise = fn();
+    return maybePromise instanceof Promise ? maybePromise.then(handleProfileEnd) : handleProfileEnd(maybePromise);
   }
   executeInDebugMode(fn) {
     if (!this.debugMode)
@@ -353,114 +185,58 @@ class Collection extends EventEmitter {
     const callstack = new Error().stack || "";
     fn(callstack);
   }
-  rebuildIndices() {
-    this.indicesOutdated = true;
-    if (this.batchOperationInProgress)
-      return;
-    this.rebuildAllIndices();
-  }
-  rebuildAllIndices() {
-    this.idIndex.clear();
-    this.memory().map((item, index) => {
-      this.idIndex.set(serializeValue(item.id), /* @__PURE__ */ new Set([index]));
-    });
-    this.indexProviders.forEach((index) => index.rebuild(this.memoryArray()));
-    this.indicesOutdated = false;
-  }
-  getIndexInfo(selector) {
-    if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
-      return {
-        matched: true,
-        positions: [...this.idIndex.get(serializeValue(selector.id)) || []],
-        optimizedSelector: {}
-      };
-    }
-    if (selector == null) {
-      return {
-        matched: false,
-        positions: [],
-        optimizedSelector: {}
-      };
-    }
-    if (this.indicesOutdated) {
-      return {
-        matched: false,
-        positions: [],
-        optimizedSelector: selector
-      };
-    }
-    return getIndexInfo(this.indexProviders, selector);
-  }
-  getItemAndIndex(selector) {
-    const memory = this.memoryArray();
-    const indexInfo = this.getIndexInfo(selector);
-    const items = indexInfo.matched ? indexInfo.positions.map((index2) => memory[index2]) : memory;
-    const item = items.find((document) => match(document, selector));
-    const foundInIndex = indexInfo.matched && indexInfo.positions.find((itemIndex) => memory[itemIndex] === item);
-    const index = foundInIndex || memory.findIndex((document) => document === item);
-    if (item == null)
-      return { item: null, index: -1 };
-    if (index === -1)
-      throw new Error("Cannot resolve index for item");
-    return { item, index };
-  }
-  deleteFromIdIndex(id, index) {
-    this.idIndex.delete(serializeValue(id));
-    if (!this.batchOperationInProgress)
-      return;
-    this.idIndex.forEach(([currenIndex], key) => {
-      if (currenIndex > index) {
-        this.idIndex.set(key, /* @__PURE__ */ new Set([currenIndex - 1]));
-      }
-    });
-  }
-  memory() {
-    return this.options.memory;
-  }
-  memoryArray() {
-    return this.memory().map((item) => item);
-  }
   transform(item) {
     if (!this.options.transform)
       return item;
     return this.options.transform(item);
   }
-  getItems(selector) {
+  getItem(selector, options) {
+    const itemsOrPromise = this.getItems(selector, { ...options, limit: 1 });
+    if (itemsOrPromise instanceof Promise) {
+      return itemsOrPromise.then((items) => {
+        return items[0] || void 0;
+      });
+    }
+    return itemsOrPromise[0];
+  }
+  getItems(selector, options) {
+    this.emit("getItems", selector);
     return this.profile(() => {
-      const indexInfo = this.getIndexInfo(selector);
-      const matchItems = (item) => {
-        if (indexInfo.optimizedSelector == null)
-          return true;
-        if (Object.keys(indexInfo.optimizedSelector).length <= 0)
-          return true;
-        const matches = match(item, indexInfo.optimizedSelector);
-        return matches;
-      };
-      this.emit("getItems", selector);
-      const memory = this.memoryArray();
-      if (!indexInfo.matched) {
-        if (isEqual(selector, {}))
-          return memory;
-        return memory.filter(matchItems);
-      }
-      const items = indexInfo.positions.map((index) => memory[index]);
-      if (isEqual(indexInfo.optimizedSelector, {}))
-        return items;
-      return items.filter(matchItems);
+      if (!options?.async)
+        return this.backend.getQueryResult(selector, options);
+      return new Promise((resolve, reject) => {
+        this.isPullingSignal.set(true);
+        const cleanup = this.backend.onQueryStateChange(selector, options, (state) => {
+          if (state === "error") {
+            cleanup();
+            reject(this.backend.getQueryError(selector, options) || new Error("Unknown error"));
+          } else if (state === "complete") {
+            cleanup();
+            resolve(this.backend.getQueryResult(selector, options) || []);
+          }
+        });
+        this.backend.registerQuery(selector, options);
+      }).finally(() => {
+        this.isPullingSignal.set(false);
+        this.backend.unregisterQuery(selector, options);
+      });
     }, (measuredTime) => this.executeInDebugMode((callstack) => this.emit("_debug.getItems", callstack, selector, measuredTime)));
   }
+  async withPushState(asyncFunction) {
+    this.isPushingSignal.set(true);
+    try {
+      return await asyncFunction();
+    } finally {
+      this.isPushingSignal.set(false);
+    }
+  }
   /**
    * Disposes the collection, unregisters persistence adapters, clears memory, and
    * cleans up all resources used by the collection.
    * @returns A promise that resolves when the collection is disposed.
    */
   async dispose() {
-    if (this.persistenceAdapter?.unregister)
-      await this.persistenceAdapter.unregister();
-    this.persistenceAdapter = null;
-    this.memory().map(() => this.memory().pop());
-    this.idIndex.clear();
-    this.indexProviders = [];
+    await this.backend.dispose();
     this.isDisposed = true;
     this.removeAllListeners();
     Collection.collections = Collection.collections.filter((collection) => collection !== this);
@@ -474,12 +250,12 @@ class Collection extends EventEmitter {
    * @param [options] - Options for the find operation, such as limit and sort.
    * @returns A cursor to fetch and observe the matching items.
    */
-  find(selector, options) {
+  find(selector = {}, options) {
     if (this.isDisposed)
       throw new Error("Collection is disposed");
     if (selector !== void 0 && (!selector || typeof selector !== "object"))
       throw new Error("Invalid selector");
-    const cursor = new Cursor(() => this.getItems(selector), {
+    const cursor = new Cursor((() => this.getItems(selector, options || {})), {
       reactive: this.options.reactivity,
       fieldTracking: this.fieldTracking,
       ...options,
@@ -492,16 +268,16 @@ class Collection extends EventEmitter {
           }
           requery();
         };
-        this.addListener("persistence.received", handleRequery);
-        this.addListener("added", handleRequery);
-        this.addListener("changed", handleRequery);
-        this.addListener("removed", handleRequery);
+        this.backend.registerQuery(selector, options);
+        const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options, (state) => {
+          if (state !== "complete")
+            return;
+          handleRequery();
+        });
         this.emit("observer.created", selector, options);
         return () => {
-          this.removeListener("persistence.received", handleRequery);
-          this.removeListener("added", handleRequery);
-          this.removeListener("changed", handleRequery);
-          this.removeListener("removed", handleRequery);
+          this.backend.unregisterQuery(selector, options);
+          queryStateChangeCleanup();
           this.emit("observer.disposed", selector, options);
         };
       }
@@ -514,6 +290,7 @@ class Collection extends EventEmitter {
    * Finds a single item in the collection based on a selector and optional options.
    * ⚡️ this function is reactive!
    * Returns the found item or undefined if no item matches.
+   * @template Async - Whether to perform the operation asynchronously.
    * @template O - The options type for the find operation.
    * @param selector - The criteria to select the item.
    * @param [options] - Options for the find operation, such as projection.
@@ -526,23 +303,39 @@ class Collection extends EventEmitter {
       limit: 1,
       ...options
     });
-    const returnValue = cursor.fetch()[0] || void 0;
-    this.emit("findOne", selector, options, returnValue);
-    this.executeInDebugMode((callstack) => this.emit("_debug.findOne", callstack, selector, options, returnValue));
-    return returnValue;
+    const handleItems = (items) => {
+      const returnValue = items[0] || void 0;
+      this.emit("findOne", selector, options, returnValue);
+      this.executeInDebugMode((callstack) => this.emit("_debug.findOne", callstack, selector, options, returnValue));
+      return returnValue;
+    };
+    const maybePromise = cursor.fetch();
+    return maybePromise instanceof Promise ? maybePromise.then(handleItems) : handleItems(maybePromise);
   }
-  /**
-   * Performs a batch operation, deferring index rebuilds and allowing multiple
-   * modifications to be made atomically. Executes any post-batch callbacks afterwards.
-   * @param callback - The batch operation to execute.
-   */
   batch(callback) {
+    if (this.batchOperationInProgress)
+      return callback();
     this.batchOperationInProgress = true;
-    callback();
-    this.batchOperationInProgress = false;
-    this.rebuildAllIndices();
-    this.postBatchCallbacks.forEach((callback_) => callback_());
-    this.postBatchCallbacks.clear();
+    const maybePromise = callback();
+    const afterBatch = () => {
+      this.batchOperationInProgress = false;
+      this.postBatchCallbacks.forEach((callback_) => callback_());
+      this.postBatchCallbacks.clear();
+    };
+    if (maybePromise && typeof maybePromise.then === "function") {
+      return maybePromise.then(() => afterBatch());
+    } else {
+      afterBatch();
+    }
+  }
+  onPostBatch(callback) {
+    if (this.isDisposed)
+      throw new Error("Collection is disposed");
+    if (this.batchOperationInProgress) {
+      this.postBatchCallbacks.add(callback);
+      return;
+    }
+    return callback();
   }
   /**
    * Inserts a single item into the collection. Generates a unique ID if not provided.
@@ -550,20 +343,18 @@ class Collection extends EventEmitter {
    * @returns The ID of the inserted item.
    * @throws {Error} If the collection is disposed or the item has an invalid ID.
    */
-  insert(item) {
+  async insert(item) {
     if (this.isDisposed)
       throw new Error("Collection is disposed");
     if (!item)
       throw new Error("Invalid item");
     const primaryKeyGenerator = this.options.primaryKeyGenerator ?? randomId;
-    const newItem = { id: primaryKeyGenerator(item), ...item };
-    this.emit("validate", newItem);
-    if (this.idIndex.has(serializeValue(newItem.id)))
-      throw new Error("Item with same id already exists");
-    this.memory().push(newItem);
-    const itemIndex = this.memory().findIndex((document) => document === newItem);
-    this.idIndex.set(serializeValue(newItem.id), /* @__PURE__ */ new Set([itemIndex]));
-    this.rebuildIndices();
+    const itemWithId = {
+      id: primaryKeyGenerator(item),
+      ...item
+    };
+    this.emit("validate", itemWithId);
+    const newItem = await this.withPushState(() => this.backend.insert(itemWithId));
     this.emit("added", newItem);
     this.emit("insert", newItem);
     this.executeInDebugMode((callstack) => this.emit("_debug.insert", callstack, newItem));
@@ -575,7 +366,7 @@ class Collection extends EventEmitter {
    * @returns An array of IDs of the inserted items.
    * @throws {Error} If the collection is disposed or the items are invalid.
    */
-  insertMany(items) {
+  async insertMany(items) {
     if (this.isDisposed)
       throw new Error("Collection is disposed");
     if (!items)
@@ -584,10 +375,10 @@ class Collection extends EventEmitter {
       return [];
     }
     const ids = [];
-    this.batch(() => {
-      items.forEach((item) => {
-        ids.push(this.insert(item));
-      });
+    await this.batch(async () => {
+      await Promise.all(items.map(async (item) => {
+        ids.push(await this.insert(item));
+      }));
     });
     return ids;
   }
@@ -600,7 +391,7 @@ class Collection extends EventEmitter {
    * @returns The number of items updated (0 or 1).
    * @throws {Error} If the collection is disposed or invalid arguments are provided.
    */
-  updateOne(selector, modifier, options) {
+  async updateOne(selector, modifier, options) {
     if (this.isDisposed)
       throw new Error("Collection is disposed");
     if (!selector)
@@ -608,7 +399,7 @@ class Collection extends EventEmitter {
     if (!modifier)
       throw new Error("Invalid modifier");
     const { $setOnInsert, ...restModifier } = modifier;
-    const { item, index } = this.getItemAndIndex(selector);
+    const item = await this.getItem(selector, { async: true });
     if (item == null) {
       if (options?.upsert) {
         const newItem = modify({}, {
@@ -618,26 +409,18 @@ class Collection extends EventEmitter {
             ...restModifier.$set
           }
         });
-        if (newItem.id != null && this.getItemAndIndex({ id: newItem.id }).item != null) {
-          throw new Error("Item with same id already exists");
-        }
-        this.insert(newItem);
-      }
-    } else {
-      const modifiedItem = modify(deepClone(item), restModifier);
-      if (item.id !== modifiedItem.id && this.getItemAndIndex({ id: modifiedItem.id }).item != null) {
-        throw new Error("Item with same id already exists");
+        await this.insert(newItem);
+        return 1;
       }
-      this.emit("validate", modifiedItem);
-      this.memory().splice(index, 1, modifiedItem);
-      this.rebuildIndices();
-      this.emit("changed", modifiedItem, restModifier);
+      return 0;
     }
+    const modifiedItem = modify(deepClone(item), restModifier);
+    this.emit("validate", modifiedItem);
+    const changes = await this.withPushState(() => this.backend.updateOne(selector, modifier));
+    this.emit("changed", modifiedItem, restModifier);
     this.emit("updateOne", selector, modifier);
     this.executeInDebugMode((callstack) => this.emit("_debug.updateOne", callstack, selector, modifier));
-    if (item == null && !options?.upsert)
-      return 0;
-    return 1;
+    return changes.length;
   }
   /**
    * Updates multiple items in the collection that match the given selector.
@@ -648,7 +431,7 @@ class Collection extends EventEmitter {
    * @returns The number of items updated.
    * @throws {Error} If the collection is disposed or invalid arguments are provided.
    */
-  updateMany(selector, modifier, options) {
+  async updateMany(selector, modifier, options) {
     if (this.isDisposed)
       throw new Error("Collection is disposed");
     if (!selector)
@@ -656,44 +439,32 @@ class Collection extends EventEmitter {
     if (!modifier)
       throw new Error("Invalid modifier");
     const { $setOnInsert, ...restModifier } = modifier;
-    const items = this.getItems(selector);
-    if (items.length === 0 && options?.upsert) {
-      const newItem = modify({}, {
-        ...restModifier,
-        $set: {
-          ...$setOnInsert,
-          ...restModifier.$set
-        }
-      });
-      if (newItem.id != null && this.getItemAndIndex({ id: newItem.id }).item != null) {
-        throw new Error("Item with same id already exists");
+    const items = await this.getItems(selector, { async: true });
+    if (items.length === 0) {
+      if (options?.upsert) {
+        const newItem = modify({}, {
+          ...restModifier,
+          $set: {
+            ...$setOnInsert,
+            ...restModifier.$set
+          }
+        });
+        await this.insert(newItem);
+        return 1;
       }
-      this.insert(newItem);
+      return 0;
     }
-    const changes = items.map((item) => {
-      const { index } = this.getItemAndIndex({ id: item.id });
-      if (index === -1)
-        throw new Error(`Cannot resolve index for item with id '${item.id}'`);
+    items.forEach((item) => {
       const modifiedItem = modify(deepClone(item), restModifier);
-      if (item.id !== modifiedItem.id && this.getItemAndIndex({ id: modifiedItem.id }).item != null) {
-        throw new Error(`Item with same id '${modifiedItem.id}' already exists`);
-      }
       this.emit("validate", modifiedItem);
-      return {
-        item: modifiedItem,
-        index
-      };
-    });
-    changes.forEach(({ item, index }) => {
-      this.memory().splice(index, 1, item);
     });
-    this.rebuildIndices();
-    changes.forEach(({ item }) => {
+    const changes = await this.withPushState(() => this.backend.updateMany(selector, modifier));
+    changes.forEach((item) => {
       this.emit("changed", item, restModifier);
     });
     this.emit("updateMany", selector, modifier);
     this.executeInDebugMode((callstack) => this.emit("_debug.updateMany", callstack, selector, modifier));
-    return changes.length === 0 && options?.upsert ? 1 : changes.length;
+    return changes.length;
   }
   /**
    * Replaces a single item in the collection that matches the given selector.
@@ -704,34 +475,26 @@ class Collection extends EventEmitter {
    * @returns The number of items replaced (0 or 1).
    * @throws {Error} If the collection is disposed or invalid arguments are provided.
    */
-  replaceOne(selector, replacement, options) {
+  async replaceOne(selector, replacement, options) {
     if (this.isDisposed)
       throw new Error("Collection is disposed");
     if (!selector)
       throw new Error("Invalid selector");
-    const { item, index } = this.getItemAndIndex(selector);
+    const item = await this.getItem(selector, { async: true });
     if (item == null) {
       if (options?.upsert) {
-        if (replacement.id != null && this.getItemAndIndex({ id: replacement.id }).item != null) {
-          throw new Error("Item with same id already exists");
-        }
-        this.insert(replacement);
-      }
-    } else {
-      if (item.id !== replacement.id && this.getItemAndIndex({ id: replacement.id }).item != null) {
-        throw new Error("Item with same id already exists");
+        await this.insert(replacement);
+        return 1;
       }
-      const modifiedItem = { id: item.id, ...replacement };
-      this.emit("validate", modifiedItem);
-      this.memory().splice(index, 1, modifiedItem);
-      this.rebuildIndices();
-      this.emit("changed", modifiedItem, replacement);
+      return 0;
     }
+    const modifiedItem = { id: item.id, ...replacement };
+    this.emit("validate", modifiedItem);
+    const changes = await this.withPushState(() => this.backend.replaceOne(selector, replacement));
+    this.emit("changed", modifiedItem, replacement);
     this.emit("replaceOne", selector, replacement);
     this.executeInDebugMode((callstack) => this.emit("_debug.replaceOne", callstack, selector, replacement));
-    if (item == null && !options?.upsert)
-      return 0;
-    return 1;
+    return changes.length;
   }
   /**
    * Removes a single item from the collection that matches the given selector.
@@ -739,21 +502,16 @@ class Collection extends EventEmitter {
    * @returns The number of items removed (0 or 1).
    * @throws {Error} If the collection is disposed or invalid arguments are provided.
    */
-  removeOne(selector) {
+  async removeOne(selector) {
     if (this.isDisposed)
       throw new Error("Collection is disposed");
     if (!selector)
       throw new Error("Invalid selector");
-    const { item, index } = this.getItemAndIndex(selector);
-    if (item != null) {
-      this.memory().splice(index, 1);
-      this.deleteFromIdIndex(item.id, index);
-      this.rebuildIndices();
-      this.emit("removed", item);
-    }
+    const removedItems = await this.withPushState(() => this.backend.removeOne(selector));
+    this.emit("removed", removedItems[0]);
     this.emit("removeOne", selector);
     this.executeInDebugMode((callstack) => this.emit("_debug.removeOne", callstack, selector));
-    return item == null ? 0 : 1;
+    return removedItems.length;
   }
   /**
    * Removes multiple items from the collection that match the given selector.
@@ -761,29 +519,20 @@ class Collection extends EventEmitter {
    * @returns The number of items removed.
    * @throws {Error} If the collection is disposed or invalid arguments are provided.
    */
-  removeMany(selector) {
+  async removeMany(selector) {
     if (this.isDisposed)
       throw new Error("Collection is disposed");
     if (!selector)
       throw new Error("Invalid selector");
-    const items = this.getItems(selector);
-    items.forEach((item) => {
-      const index = this.memory().findIndex((document) => document === item);
-      if (index === -1)
-        throw new Error("Cannot resolve index for item");
-      this.memory().splice(index, 1);
-      this.deleteFromIdIndex(item.id, index);
-      this.rebuildIndices();
-    });
-    items.forEach((item) => {
+    const removedItems = await this.withPushState(() => this.backend.removeMany(selector));
+    removedItems.forEach((item) => {
       this.emit("removed", item);
     });
     this.emit("removeMany", selector);
     this.executeInDebugMode((callstack) => this.emit("_debug.removeMany", callstack, selector));
-    return items.length;
+    return removedItems.length;
   }
 }
 export {
-  default2 as createIndex,
   Collection as default
 };