@signaldb/sync 1.3.1 → 2.0.0-beta.0

package/dist/SyncManager.d.ts

@@ -1,7 +1,7 @@
-import type { BaseItem, PersistenceAdapter, ReactivityAdapter, Changeset, LoadResponse } from '@signaldb/core';
+import type { BaseItem, StorageAdapter, ReactivityAdapter, Changeset } from '@signaldb/core';
 import { Collection } from '@signaldb/core';
 import PromiseQueue from './utils/PromiseQueue';
-import type { Change, Snapshot, SyncOperation } from './types';
+import type { Change, LoadResponse, Snapshot, SyncOperation } from './types';
 type SyncOptions<T extends Record<string, any>> = {
     name: string;
 } & T;
@@ -19,7 +19,7 @@ interface Options<CollectionOptions extends Record<string, any>, ItemType extend
     }) => Promise<void>;
     registerRemoteChange?: (collectionOptions: SyncOptions<CollectionOptions>, onChange: (data?: LoadResponse<ItemType>) => Promise<void>) => CleanupFunction | Promise<CleanupFunction>;
     id?: string;
-    persistenceAdapter?: (id: string, registerErrorHandler: (handler: (error: Error) => void) => void) => PersistenceAdapter<any, any>;
+    storageAdapter?: (id: string, registerErrorHandler: (handler: (error: Error) => void) => void) => StorageAdapter<any, any>;
     reactivity?: ReactivityAdapter;
     onError?: (collectionOptions: SyncOptions<CollectionOptions>, error: Error) => void;
     autostart?: boolean;
@@ -77,15 +77,15 @@ export default class SyncManager<CollectionOptions extends Record<string, any>,
      * @param options.push Function to push data to remote source.
      * @param [options.registerRemoteChange] Function to register a callback for remote changes.
      * @param [options.id] Unique identifier for this sync manager. Only nessesary if you have multiple sync managers.
-     * @param [options.persistenceAdapter] Persistence adapter to use for storing changes, snapshots and sync operations.
+     * @param [options.storageAdapter] Storage adapter to use for storing changes, snapshots and sync operations.
      * @param [options.reactivity] Reactivity adapter to use for reactivity.
      * @param [options.onError] Function to handle errors that occur async during syncing.
      * @param [options.autostart] Whether to automatically start syncing new collections.
      * @param [options.debounceTime] The time in milliseconds to debounce push operations.
      */
     constructor(options: Options<CollectionOptions, ItemType, IdType>);
-    protected createPersistenceAdapter(name: string): {
-        adapter: PersistenceAdapter<any, any>;
+    protected createStorageAdapter(name: string): {
+        adapter: StorageAdapter<any, any>;
         handler: (error: Error) => void;
     } | undefined;
     protected getSyncQueue(name: string): PromiseQueue;

package/dist/getSnapshot.d.ts

@@ -1,4 +1,5 @@
-import type { BaseItem, LoadResponse } from '@signaldb/core';
+import type { BaseItem } from '@signaldb/core';
+import type { LoadResponse } from './types';
 /**
  * Gets the snapshot of items from the last snapshot and the changes.
  * @param lastSnapshot The last snapshot of items

package/dist/index.mjs

@@ -1,23 +1,18 @@
-var E = Object.defineProperty;
-var M = (c, e, t) => e in c ? E(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
-var u = (c, e, t) => M(c, typeof e != "symbol" ? e + "" : e, t);
-import { isEqual as S, modify as C, randomId as D, Collection as m, createIndex as y } from "@signaldb/core";
-function x(c, e, t = {}) {
+import { isEqual as O, modify as g, randomId as $, DefaultDataAdapter as N, Collection as y } from "@signaldb/core";
+function E(h, e, t = {}) {
   let s, n;
   const { leading: o = !1, trailing: a = !0 } = t;
-  function r(...h) {
+  function c(...r) {
     const i = o && !s, l = a && !s;
     return s && clearTimeout(s), s = setTimeout(() => {
-      s = null, a && !i && (n = c.apply(this, h));
-    }, e), i ? n = c.apply(this, h) : l || (n = null), n;
+      s = null, a && !i && (n = h.apply(this, r));
+    }, e), i ? n = h.apply(this, r) : l || (n = null), n;
   }
-  return r;
+  return c;
 }
-class R {
-  constructor() {
-    u(this, "queue", []);
-    u(this, "pendingPromise", !1);
-  }
+class D {
+  queue = [];
+  pendingPromise = !1;
   /**
    * Method to add a new promise to the queue and returns a promise that resolves when this task is done
    * @param task Function that returns a promise that will be added to the queue
@@ -51,26 +46,26 @@ class R {
     }));
   }
 }
-function N(c, e) {
-  const t = [], s = Object.keys(c), n = Object.keys(e), o = /* @__PURE__ */ new Set([...s, ...n]);
+function C(h, e) {
+  const t = [], s = Object.keys(h), n = Object.keys(e), o = /* @__PURE__ */ new Set([...s, ...n]);
   for (const a of o)
-    if (e[a] !== c[a])
-      if (typeof e[a] == "object" && typeof c[a] == "object" && e[a] != null && c[a] != null) {
-        const r = N(c[a], e[a]);
-        for (const h of r)
-          t.push(`${a}.${h}`);
+    if (e[a] !== h[a])
+      if (typeof e[a] == "object" && typeof h[a] == "object" && e[a] != null && h[a] != null) {
+        const c = C(h[a], e[a]);
+        for (const r of c)
+          t.push(`${a}.${r}`);
       } else
         t.push(a);
   return t;
 }
-function g(c, e) {
-  const t = [], s = [], n = /* @__PURE__ */ new Map(), o = [], a = new Map(c.map((h) => [h.id, h])), r = new Map(e.map((h) => [h.id, h]));
-  for (const [h, i] of a) {
-    const l = r.get(h);
-    l ? S(l, i) || (n.set(l.id, N(i, l)), s.push(l)) : o.push(i);
+function f(h, e) {
+  const t = [], s = [], n = /* @__PURE__ */ new Map(), o = [], a = new Map(h.map((r) => [r.id, r])), c = new Map(e.map((r) => [r.id, r]));
+  for (const [r, i] of a) {
+    const l = c.get(r);
+    l ? O(l, i) || (n.set(l.id, C(i, l)), s.push(l)) : o.push(i);
   }
-  for (const [h, i] of r)
-    a.has(h) || t.push(i);
+  for (const [r, i] of c)
+    a.has(r) || t.push(i);
   return {
     added: t,
     modified: s,
@@ -78,10 +73,10 @@ function g(c, e) {
     removed: o
   };
 }
-function P(c, e) {
+function w(h, e) {
   if (e.items != null)
     return e.items;
-  const t = c || [];
+  const t = h || [];
   return e.changes.added.forEach((s) => {
     const n = t.findIndex((o) => o.id === s.id);
     n === -1 ? t.push(s) : t[n] = s;
@@ -93,8 +88,8 @@ function P(c, e) {
     n !== -1 && t.splice(n, 1);
   }), t;
 }
-function v(c, e) {
-  const t = new Map(c.map((s) => [s.id, s]));
+function P(h, e) {
+  const t = new Map(h.map((s) => [s.id, s]));
   return e.forEach((s) => {
     if (s.type === "remove")
       t.delete(s.data);
@@ -103,98 +98,111 @@ function v(c, e) {
       t.set(s.data.id, n ? { ...n, ...s.data } : s.data);
     } else {
       const n = t.get(s.data.id);
-      t.set(s.data.id, n ? C(n, s.data.modifier) : C({ id: s.data.id }, s.data.modifier));
+      t.set(s.data.id, n ? g(n, s.data.modifier) : g({ id: s.data.id }, s.data.modifier));
     }
   }), [...t.values()];
 }
-function O(c) {
-  return c.added.length > 0 || c.modified.length > 0 || c.removed.length > 0;
+function v(h) {
+  return h.added.length > 0 || h.modified.length > 0 || h.removed.length > 0;
 }
-function b(c, e) {
-  return O(g(c, e));
+function M(h, e) {
+  return v(f(h, e));
 }
-async function I({ changes: c, lastSnapshot: e, data: t, pull: s, push: n, insert: o, update: a, remove: r, batch: h }) {
-  let i = t, l = e || [], f = P(e, i);
-  if (c.length > 0) {
-    const p = v(l, c);
-    if (b(l, p)) {
-      const $ = v(f, c), w = g(f, $);
-      O(w) && (await n(w), i = await s(), f = P(f, i)), l = p;
+async function F({ changes: h, lastSnapshot: e, data: t, pull: s, push: n, insert: o, update: a, remove: c, batch: r }) {
+  let i = t, l = e || [], p = w(e, i);
+  if (h.length > 0) {
+    const u = P(l, h);
+    if (M(l, u)) {
+      const S = P(p, h), m = f(p, S);
+      v(m) && (await n(m), i = await s(), p = w(p, i)), l = u;
     }
   }
-  const d = i.changes == null ? g(l, i.items) : i.changes;
-  return h(() => {
-    d.added.forEach((p) => o(p)), d.modified.forEach((p) => a(p.id, { $set: p })), d.removed.forEach((p) => r(p.id));
-  }), f;
+  const d = i.changes == null ? f(l, i.items) : i.changes;
+  return await r(async () => {
+    await Promise.all(d.added.map((u) => o(u))), await Promise.all(d.modified.map((u) => a(u.id, { $set: u }))), await Promise.all(d.removed.map((u) => c(u.id)));
+  }), p;
 }
-class T {
+class b {
+  options;
+  collections = /* @__PURE__ */ new Map();
+  changes;
+  snapshots;
+  syncOperations;
+  scheduledPushes = /* @__PURE__ */ new Set();
+  remoteChanges = [];
+  syncQueues = /* @__PURE__ */ new Map();
+  persistenceReady;
+  isDisposed = !1;
+  instanceId = $();
+  id;
+  debouncedFlush;
   /**
    * @param options Collection options
    * @param options.pull Function to pull data from remote source.
    * @param options.push Function to push data to remote source.
    * @param [options.registerRemoteChange] Function to register a callback for remote changes.
    * @param [options.id] Unique identifier for this sync manager. Only nessesary if you have multiple sync managers.
-   * @param [options.persistenceAdapter] Persistence adapter to use for storing changes, snapshots and sync operations.
+   * @param [options.storageAdapter] Storage adapter to use for storing changes, snapshots and sync operations.
    * @param [options.reactivity] Reactivity adapter to use for reactivity.
    * @param [options.onError] Function to handle errors that occur async during syncing.
    * @param [options.autostart] Whether to automatically start syncing new collections.
    * @param [options.debounceTime] The time in milliseconds to debounce push operations.
    */
   constructor(e) {
-    u(this, "options");
-    u(this, "collections", /* @__PURE__ */ new Map());
-    u(this, "changes");
-    u(this, "snapshots");
-    u(this, "syncOperations");
-    u(this, "scheduledPushes", /* @__PURE__ */ new Set());
-    u(this, "remoteChanges", []);
-    u(this, "syncQueues", /* @__PURE__ */ new Map());
-    u(this, "persistenceReady");
-    u(this, "isDisposed", !1);
-    u(this, "instanceId", D());
-    u(this, "id");
-    u(this, "debouncedFlush");
     this.options = {
       autostart: !0,
       ...e
     }, this.id = this.options.id || "default-sync-manager";
-    const { reactivity: t } = this.options, s = this.createPersistenceAdapter("changes"), n = this.createPersistenceAdapter("snapshots"), o = this.createPersistenceAdapter("sync-operations");
-    this.changes = new m({
-      name: `${this.options.id}-changes`,
-      persistence: s == null ? void 0 : s.adapter,
-      indices: [y("collectionName")],
+    const { reactivity: t } = this.options, s = this.createStorageAdapter("changes"), n = this.createStorageAdapter("snapshots"), o = this.createStorageAdapter("sync-operations"), a = new N({
+      storage: (c) => {
+        if (c === `${this.options.id}-changes`)
+          return s?.adapter;
+        if (c === `${this.options.id}-snapshots`)
+          return n?.adapter;
+        if (c === `${this.options.id}-sync-operations`)
+          return o?.adapter;
+        throw new Error(`Unknown storage name: ${c}`);
+      },
+      onError: (c, r) => {
+        if (c === "changes")
+          return s?.handler(r);
+        if (c === "snapshots")
+          return n?.handler(r);
+        if (c === "sync-operations")
+          return o?.handler(r);
+        throw new Error(`Error in unknown storage name: ${c}`, { cause: r });
+      }
+    });
+    this.changes = new y(`${this.options.id}-changes`, a, {
+      indices: ["collectionName"],
       reactivity: t
-    }), this.snapshots = new m({
-      name: `${this.options.id}-snapshots`,
-      persistence: n == null ? void 0 : n.adapter,
-      indices: [y("collectionName")],
+    }), this.snapshots = new y(`${this.options.id}-snapshots`, a, {
+      indices: ["collectionName"],
       reactivity: t
-    }), this.syncOperations = new m({
-      name: `${this.options.id}-sync-operations`,
-      persistence: o == null ? void 0 : o.adapter,
-      indices: [y("collectionName"), y("status")],
+    }), this.syncOperations = new y(`${this.options.id}-sync-operations`, a, {
+      indices: ["collectionName", "status"],
       reactivity: t
-    }), this.changes.on("persistence.error", (a) => s == null ? void 0 : s.handler(a)), this.snapshots.on("persistence.error", (a) => n == null ? void 0 : n.handler(a)), this.syncOperations.on("persistence.error", (a) => o == null ? void 0 : o.handler(a)), this.persistenceReady = Promise.all([
+    }), this.persistenceReady = Promise.all([
       this.syncOperations.isReady(),
       this.changes.isReady(),
       this.snapshots.isReady()
     ]).then(() => {
-    }), this.changes.setMaxListeners(1e3), this.snapshots.setMaxListeners(1e3), this.syncOperations.setMaxListeners(1e3), this.debouncedFlush = x(this.flushScheduledPushes, this.options.debounceTime ?? 100);
+    }), this.changes.setMaxListeners(1e3), this.snapshots.setMaxListeners(1e3), this.syncOperations.setMaxListeners(1e3), this.debouncedFlush = E(this.flushScheduledPushes, this.options.debounceTime ?? 100);
   }
-  createPersistenceAdapter(e) {
-    if (this.options.persistenceAdapter == null)
+  createStorageAdapter(e) {
+    if (this.options.storageAdapter == null)
       return;
     let t = () => {
     };
     return {
-      adapter: this.options.persistenceAdapter(`${this.id}-${e}`, (n) => {
+      adapter: this.options.storageAdapter(`${this.id}-${e}`, (n) => {
         t = n;
       }),
       handler: (n) => t(n)
     };
   }
   getSyncQueue(e) {
-    return this.syncQueues.get(e) == null && this.syncQueues.set(e, new R()), this.syncQueues.get(e);
+    return this.syncQueues.get(e) == null && this.syncQueues.set(e, new D()), this.syncQueues.get(e);
   }
   /**
    * Clears all internal data structures
@@ -241,7 +249,7 @@ class T {
     this.collections.set(t.name, {
       collection: e,
       options: t,
-      readyPromise: e.isReady(),
+      readyPromise: e.ready(),
       syncPaused: !0
       // always start paused as the autostart will start it
     });
@@ -251,12 +259,12 @@ class T {
           return !0;
       return !1;
     }, n = (o, a) => {
-      const r = [...this.remoteChanges];
-      for (let h = 0; h < r.length; h += 1) {
-        const i = r[h];
-        i != null && i.collectionName === o && (i.type === "remove" && i.data !== a || i.data.id === a && (r[h] = null));
+      const c = [...this.remoteChanges];
+      for (let r = 0; r < c.length; r += 1) {
+        const i = c[r];
+        i != null && i.collectionName === o && (i.type === "remove" && i.data !== a || i.data.id === a && (c[r] = null));
       }
-      this.remoteChanges = r.filter((h) => h != null);
+      this.remoteChanges = c.filter((r) => r != null);
     };
     e.on("added", (o) => {
       if (s({ collectionName: t.name, type: "insert", data: o })) {
@@ -268,10 +276,14 @@ class T {
         time: Date.now(),
         type: "insert",
         data: o
-      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
+      }).then(() => {
+        this.getCollectionProperties(t.name).syncPaused || this.schedulePush(t.name);
+      }).catch((a) => {
+        this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, a);
+      });
     }), e.on("changed", ({ id: o }, a) => {
-      const r = { id: o, modifier: a };
-      if (s({ collectionName: t.name, type: "update", data: r })) {
+      const c = { id: o, modifier: a };
+      if (s({ collectionName: t.name, type: "update", data: c })) {
         n(t.name, o);
         return;
       }
@@ -279,8 +291,12 @@ class T {
         collectionName: t.name,
         time: Date.now(),
         type: "update",
-        data: r
-      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
+        data: c
+      }).then(() => {
+        this.getCollectionProperties(t.name).syncPaused || this.schedulePush(t.name);
+      }).catch((r) => {
+        this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, r);
+      });
     }), e.on("removed", ({ id: o }) => {
       if (s({ collectionName: t.name, type: "remove", data: o })) {
         n(t.name, o);
@@ -291,7 +307,11 @@ class T {
         time: Date.now(),
         type: "remove",
         data: o
-      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
+      }).then(() => {
+        this.getCollectionProperties(t.name).syncPaused || this.schedulePush(t.name);
+      }).catch((a) => {
+        this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, a);
+      });
     }), this.options.autostart && this.startSync(t.name).catch((o) => {
       this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, o);
     });
@@ -326,27 +346,27 @@ class T {
       if (n == null)
         await this.sync(e);
       else {
-        const o = Date.now(), a = this.syncOperations.insert({
+        const o = Date.now(), a = await this.syncOperations.insert({
           start: o,
           collectionName: e,
           instanceId: this.instanceId,
           status: "active"
         });
-        await this.syncWithData(e, n).then(() => {
-          this.syncOperations.removeMany({
+        await this.syncWithData(e, n).then(async () => {
+          await this.syncOperations.removeMany({
             id: { $ne: a },
             collectionName: e,
             $or: [
               { end: { $lte: o } },
               { status: "active" }
             ]
-          }), this.syncOperations.updateOne({ id: a }, {
+          }), await this.syncOperations.updateOne({ id: a }, {
             $set: { status: "done", end: Date.now() }
           });
-        }).catch((r) => {
-          throw this.options.onError && this.options.onError(this.getCollectionProperties(e).options, r), this.syncOperations.updateOne({ id: a }, {
-            $set: { status: "error", end: Date.now(), error: r.stack || r.message }
-          }), r;
+        }).catch(async (c) => {
+          throw this.options.onError && this.options.onError(this.getCollectionProperties(e).options, c), await this.syncOperations.updateOne({ id: a }, {
+            $set: { status: "error", end: Date.now(), error: c.stack || c.message }
+          }), c;
         });
       }
     }) : void 0;
@@ -431,11 +451,11 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
     }, {
       reactive: !1
     }).count() > 0, a = Date.now();
-    let r = null;
+    let c = null;
     await new Promise((i) => {
       setTimeout(i, 0);
     });
-    const h = async () => {
+    const r = async () => {
       const i = this.syncOperations.findOne({
         collectionName: e,
         status: "done"
@@ -443,7 +463,7 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
         sort: { end: -1 },
         reactive: !1
       });
-      if (t != null && t.onlyWithChanges && this.changes.find({
+      if (t?.onlyWithChanges && this.changes.find({
         collectionName: e,
         time: { $lte: a }
       }, {
@@ -451,30 +471,30 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
         reactive: !1
       }).count() === 0)
         return;
-      o || (r = this.syncOperations.insert({
+      o || (c = await this.syncOperations.insert({
         start: a,
         collectionName: e,
         instanceId: this.instanceId,
         status: "active"
       }));
       const l = await this.options.pull(s, {
-        lastFinishedSyncStart: i == null ? void 0 : i.start,
-        lastFinishedSyncEnd: i == null ? void 0 : i.end
+        lastFinishedSyncStart: i?.start,
+        lastFinishedSyncEnd: i?.end
       });
       await this.syncWithData(e, l);
     };
-    await (t != null && t.force ? h() : this.getSyncQueue(e).add(h)).catch((i) => {
-      throw r != null && (this.options.onError && this.options.onError(s, i), this.syncOperations.updateOne({ id: r }, {
+    await (t?.force ? r() : this.getSyncQueue(e).add(r)).catch(async (i) => {
+      throw c != null && (this.options.onError && this.options.onError(s, i), await this.syncOperations.updateOne({ id: c }, {
         $set: { status: "error", end: Date.now(), error: i.stack || i.message }
       })), i;
-    }), r != null && (this.syncOperations.removeMany({
-      id: { $ne: r },
+    }), c != null && (await this.syncOperations.removeMany({
+      id: { $ne: c },
       collectionName: e,
       $or: [
         { end: { $lte: a } },
         { status: "active" }
       ]
-    }), this.syncOperations.updateOne({ id: r }, {
+    }), await this.syncOperations.updateOne({ id: c }, {
       $set: { status: "done", end: Date.now() }
     }));
   }
@@ -494,31 +514,31 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
     }, {
       sort: { end: -1 },
       reactive: !1
-    }), r = this.snapshots.findOne({
+    }), c = this.snapshots.findOne({
       collectionName: e
     }, {
       sort: { time: -1 },
       reactive: !1
-    }), h = this.changes.find({
+    }), r = this.changes.find({
       collectionName: e,
       time: { $lte: o }
     }, {
       sort: { time: 1 },
       reactive: !1
     }).fetch();
-    await I({
-      changes: h,
-      lastSnapshot: r == null ? void 0 : r.items,
+    await F({
+      changes: r,
+      lastSnapshot: c?.items,
       data: t,
       pull: () => this.options.pull(n, {
-        lastFinishedSyncStart: a == null ? void 0 : a.start,
-        lastFinishedSyncEnd: a == null ? void 0 : a.end
+        lastFinishedSyncStart: a?.start,
+        lastFinishedSyncEnd: a?.end
       }),
       push: (i) => this.options.push(n, {
         changes: i,
-        rawChanges: h
+        rawChanges: r
       }),
-      insert: (i) => {
+      insert: async (i) => {
         this.remoteChanges.push({
           collectionName: e,
           type: "insert",
@@ -527,9 +547,9 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
           collectionName: e,
           type: "update",
           data: { id: i.id, modifier: { $set: i } }
-        }), s.replaceOne({ id: i.id }, i, { upsert: !0 });
+        }), await s.replaceOne({ id: i.id }, i, { upsert: !0 });
       },
-      update: (i, l) => {
+      update: async (i, l) => {
         this.remoteChanges.push({
           collectionName: e,
           type: "insert",
@@ -538,33 +558,31 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
           collectionName: e,
           type: "update",
           data: { id: i, modifier: l }
-        }), s.updateOne({ id: i }, {
+        }), await s.updateOne({ id: i }, {
           ...l,
           $setOnInsert: { id: i }
         }, { upsert: !0 });
       },
-      remove: (i) => {
+      remove: async (i) => {
         s.findOne({
           id: i
         }, { reactive: !1 }) && (this.remoteChanges.push({
           collectionName: e,
           type: "remove",
           data: i
-        }), s.removeOne({ id: i }));
+        }), await s.removeOne({ id: i }));
       },
-      batch: (i) => {
-        s.batch(() => {
-          i();
-        });
-      }
+      batch: async (i) => s.batch(async () => {
+        await i();
+      })
     }).then(async (i) => {
-      if (this.snapshots.removeMany({
+      if (await this.snapshots.removeMany({
         collectionName: e,
         time: { $lte: o }
-      }), this.changes.removeMany({
+      }), await this.changes.removeMany({
         collectionName: e,
-        id: { $in: h.map((d) => d.id) }
-      }), this.snapshots.insert({
+        id: { $in: r.map((d) => d.id) }
+      }), await this.snapshots.insert({
         time: o,
         collectionName: e,
         items: i
@@ -579,13 +597,13 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
         });
         return;
       }
-      const f = s.find({
+      const p = s.find({
         id: { $nin: i.map((d) => d.id) }
       }, {
         reactive: !1
       }).map((d) => d.id);
-      s.batch(() => {
-        i.forEach((d) => {
+      await s.batch(async () => {
+        await Promise.all(i.map(async (d) => {
           this.remoteChanges.push({
             collectionName: e,
             type: "insert",
@@ -594,15 +612,15 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
             collectionName: e,
             type: "update",
             data: { id: d.id, modifier: { $set: d } }
-          }), s.replaceOne({ id: d.id }, d, { upsert: !0 });
-        }), f.forEach((d) => {
-          s.removeOne({ id: d });
-        });
+          }), await s.replaceOne({ id: d.id }, d, { upsert: !0 });
+        })), await Promise.all(p.map(async (d) => {
+          await s.removeOne({ id: d });
+        }));
       });
     });
   }
 }
 export {
-  T as SyncManager
+  b as SyncManager
 };
 //# sourceMappingURL=index.mjs.map