@signaldb/sync 1.3.1 → 2.0.0-beta.1

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 = {}) {
-  let s, n;
-  const { leading: o = !1, trailing: a = !0 } = t;
-  function r(...h) {
-    const i = o && !s, l = a && !s;
+import { isEqual as N, modify as w, randomId as S, DefaultDataAdapter as E, Collection as y } from "@signaldb/core";
+function $(l, e, t = {}) {
+  let s, o;
+  const { leading: n = !1, trailing: a = !0 } = t;
+  function r(...c) {
+    const i = n && !s, h = 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 && (o = l.apply(this, c));
+    }, e), i ? o = l.apply(this, c) : h || (o = null), o;
   }
   return r;
 }
-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
@@ -25,8 +20,8 @@ class R {
    */
   add(e) {
     return new Promise((t, s) => {
-      this.queue.push(() => e().then(t).catch((n) => {
-        throw s(n), n;
+      this.queue.push(() => e().then(t).catch((o) => {
+        throw s(o), o;
       })), this.dequeue();
     });
   }
@@ -51,150 +46,132 @@ class R {
     }));
   }
 }
-function N(c, e) {
-  const t = [], s = Object.keys(c), 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}`);
+function C(l, e) {
+  const t = [], s = Object.keys(l), o = Object.keys(e), n = /* @__PURE__ */ new Set([...s, ...o]);
+  for (const a of n)
+    if (e[a] !== l[a])
+      if (typeof e[a] == "object" && typeof l[a] == "object" && e[a] != null && l[a] != null) {
+        const r = C(l[a], e[a]);
+        for (const c of r)
+          t.push(`${a}.${c}`);
       } 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(l, e) {
+  const t = [], s = [], o = /* @__PURE__ */ new Map(), n = [], a = new Map(l.map((c) => [c.id, c])), r = new Map(e.map((c) => [c.id, c]));
+  for (const [c, i] of a) {
+    const h = r.get(c);
+    h ? N(h, i) || (o.set(h.id, C(i, h)), s.push(h)) : n.push(i);
   }
-  for (const [h, i] of r)
-    a.has(h) || t.push(i);
+  for (const [c, i] of r)
+    a.has(c) || t.push(i);
   return {
     added: t,
     modified: s,
-    modifiedFields: n,
-    removed: o
+    modifiedFields: o,
+    removed: n
   };
 }
-function P(c, e) {
+function g(l, e) {
   if (e.items != null)
     return e.items;
-  const t = c || [];
+  const t = l || [];
   return e.changes.added.forEach((s) => {
-    const n = t.findIndex((o) => o.id === s.id);
-    n === -1 ? t.push(s) : t[n] = s;
+    const o = t.findIndex((n) => n.id === s.id);
+    o === -1 ? t.push(s) : t[o] = s;
   }), e.changes.modified.forEach((s) => {
-    const n = t.findIndex((o) => o.id === s.id);
-    n === -1 ? t.push(s) : t[n] = s;
+    const o = t.findIndex((n) => n.id === s.id);
+    o === -1 ? t.push(s) : t[o] = s;
   }), e.changes.removed.forEach((s) => {
-    const n = t.findIndex((o) => o.id === s.id);
-    n !== -1 && t.splice(n, 1);
+    const o = t.findIndex((n) => n.id === s.id);
+    o !== -1 && t.splice(o, 1);
   }), t;
 }
-function v(c, e) {
-  const t = new Map(c.map((s) => [s.id, s]));
+function P(l, e) {
+  const t = new Map(l.map((s) => [s.id, s]));
   return e.forEach((s) => {
     if (s.type === "remove")
       t.delete(s.data);
     else if (s.type === "insert") {
-      const n = t.get(s.data.id);
-      t.set(s.data.id, n ? { ...n, ...s.data } : s.data);
+      const o = t.get(s.data.id);
+      t.set(s.data.id, o ? { ...o, ...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));
+      const o = t.get(s.data.id);
+      t.set(s.data.id, o ? w(o, s.data.modifier) : w({ 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(l) {
+  return l.added.length > 0 || l.modified.length > 0 || l.removed.length > 0;
 }
-function b(c, e) {
-  return O(g(c, e));
+function M(l, e) {
+  return v(f(l, 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: l, lastSnapshot: e, data: t, pull: s, push: o, insert: n, update: a, remove: r, batch: c }) {
+  let i = t, h = e || [], p = g(e, i);
+  if (l.length > 0) {
+    const u = P(h, l);
+    if (M(h, u)) {
+      const O = P(p, l), m = f(p, O);
+      v(m) && (await o(m), i = await s(), p = g(p, i)), h = 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(h, i.items) : i.changes;
+  return await c(async () => {
+    await Promise.all(d.added.map((u) => n(u))), await Promise.all(d.modified.map((u) => a(u.id, { $set: u }))), await Promise.all(d.removed.map((u) => r(u.id)));
+  }), p;
 }
-class T {
+class b {
+  options;
+  collections = /* @__PURE__ */ new Map();
+  changes;
+  snapshots;
+  syncOperations;
+  scheduledPushes = /* @__PURE__ */ new Set();
+  remoteChanges = [];
+  syncQueues = /* @__PURE__ */ new Map();
+  collectionsReady;
+  isDisposed = !1;
+  instanceId = S();
+  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.options.dataAdapter ?? new E();
+    this.changes = new y(`${this.options.id}-changes`, s, {
+      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`, s, {
+      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`, s, {
+      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.collectionsReady = 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);
-  }
-  createPersistenceAdapter(e) {
-    if (this.options.persistenceAdapter == null)
-      return;
-    let t = () => {
-    };
-    return {
-      adapter: this.options.persistenceAdapter(`${this.id}-${e}`, (n) => {
-        t = n;
-      }),
-      handler: (n) => t(n)
-    };
+    }), this.changes.setMaxListeners(1e3), this.snapshots.setMaxListeners(1e3), this.syncOperations.setMaxListeners(1e3), this.debouncedFlush = $(this.flushScheduledPushes, this.options.debounceTime ?? 100);
   }
   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,38 +218,42 @@ 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
     });
-    const s = (o) => {
+    const s = (n) => {
       for (const a of this.remoteChanges)
-        if (a != null && a.collectionName === o.collectionName && a.type === o.type && !(o.type === "remove" && a.data !== o.data) && a.data.id === o.data.id)
+        if (a != null && a.collectionName === n.collectionName && a.type === n.type && !(n.type === "remove" && a.data !== n.data) && a.data.id === n.data.id)
           return !0;
       return !1;
-    }, n = (o, a) => {
+    }, o = (n, 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));
+      for (let c = 0; c < r.length; c += 1) {
+        const i = r[c];
+        i != null && i.collectionName === n && (i.type === "remove" && i.data !== a || i.data.id === a && (r[c] = null));
       }
-      this.remoteChanges = r.filter((h) => h != null);
+      this.remoteChanges = r.filter((c) => c != null);
     };
-    e.on("added", (o) => {
-      if (s({ collectionName: t.name, type: "insert", data: o })) {
-        n(t.name, o.id);
+    e.on("added", (n) => {
+      if (s({ collectionName: t.name, type: "insert", data: n })) {
+        o(t.name, n.id);
         return;
       }
       this.changes.insert({
         collectionName: t.name,
         time: Date.now(),
         type: "insert",
-        data: o
-      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
-    }), e.on("changed", ({ id: o }, a) => {
-      const r = { id: o, modifier: a };
+        data: n
+      }).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: n }, a) => {
+      const r = { id: n, modifier: a };
       if (s({ collectionName: t.name, type: "update", data: r })) {
-        n(t.name, o);
+        o(t.name, n);
         return;
       }
       this.changes.insert({
@@ -280,20 +261,28 @@ class T {
         time: Date.now(),
         type: "update",
         data: r
-      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
-    }), e.on("removed", ({ id: o }) => {
-      if (s({ collectionName: t.name, type: "remove", data: o })) {
-        n(t.name, o);
+      }).then(() => {
+        this.getCollectionProperties(t.name).syncPaused || this.schedulePush(t.name);
+      }).catch((c) => {
+        this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, c);
+      });
+    }), e.on("removed", ({ id: n }) => {
+      if (s({ collectionName: t.name, type: "remove", data: n })) {
+        o(t.name, n);
         return;
       }
       this.changes.insert({
         collectionName: t.name,
         time: Date.now(),
         type: "remove",
-        data: o
-      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
-    }), this.options.autostart && this.startSync(t.name).catch((o) => {
-      this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, o);
+        data: n
+      }).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((n) => {
+      this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, n);
     });
   }
   flushScheduledPushes() {
@@ -322,29 +311,29 @@ class T {
     if (!t.syncPaused)
       return;
     this.schedulePush(e);
-    const s = this.options.registerRemoteChange ? await this.options.registerRemoteChange(t.options, async (n) => {
-      if (n == null)
+    const s = this.options.registerRemoteChange ? await this.options.registerRemoteChange(t.options, async (o) => {
+      if (o == null)
         await this.sync(e);
       else {
-        const o = Date.now(), a = this.syncOperations.insert({
-          start: o,
+        const n = Date.now(), a = await this.syncOperations.insert({
+          start: n,
           collectionName: e,
           instanceId: this.instanceId,
           status: "active"
         });
-        await this.syncWithData(e, n).then(() => {
-          this.syncOperations.removeMany({
+        await this.syncWithData(e, o).then(async () => {
+          await this.syncOperations.removeMany({
             id: { $ne: a },
             collectionName: e,
             $or: [
-              { end: { $lte: o } },
+              { end: { $lte: n } },
               { 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 }, {
+        }).catch(async (r) => {
+          throw this.options.onError && this.options.onError(this.getCollectionProperties(e).options, r), await this.syncOperations.updateOne({ id: a }, {
             $set: { status: "error", end: Date.now(), error: r.stack || r.message }
           }), r;
         });
@@ -396,20 +385,22 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
   /**
    * Checks if a collection is currently beeing synced
    * @param [name] Name of the collection. If not provided, it will check if any collection is currently beeing synced.
-   * @returns True if the collection is currently beeing synced, false otherwise.
+   * @param [async] If true, it will check for active syncs in the database. This is useful if you have multiple instances of the application running.
+   * @returns True if the collection is currently beeing synced, false otherwise. If async is true, it will return a promise that resolves to true or false.
    */
-  isSyncing(e) {
-    return this.syncOperations.findOne({
+  isSyncing(e, t) {
+    const s = this.syncOperations.findOne({
       ...e ? { collectionName: e } : {},
       status: "active"
-    }, { fields: { status: 1 } }) != null;
+    }, { fields: { status: 1 }, async: t });
+    return s instanceof Promise ? s.then((o) => o != null) : s != null;
   }
   /**
    * Checks if the sync manager is ready to sync.
    * @returns A promise that resolves when the sync manager is ready to sync.
    */
   async isReady() {
-    await this.persistenceReady;
+    await this.collectionsReady;
   }
   /**
    * Starts the sync process for a collection
@@ -422,59 +413,62 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
     if (this.isDisposed)
       throw new Error("SyncManager is disposed");
     await this.isReady();
-    const { options: s, readyPromise: n } = this.getCollectionProperties(e);
-    await n;
-    const o = this.syncOperations.find({
+    const { options: s, readyPromise: o } = this.getCollectionProperties(e);
+    await o;
+    const n = await this.syncOperations.find({
       collectionName: e,
       instanceId: this.instanceId,
       status: "active"
     }, {
-      reactive: !1
+      reactive: !1,
+      async: !0
     }).count() > 0, a = Date.now();
     let r = null;
     await new Promise((i) => {
       setTimeout(i, 0);
     });
-    const h = async () => {
-      const i = this.syncOperations.findOne({
+    const c = async () => {
+      const i = await this.syncOperations.findOne({
         collectionName: e,
         status: "done"
       }, {
         sort: { end: -1 },
-        reactive: !1
+        reactive: !1,
+        async: !0
       });
-      if (t != null && t.onlyWithChanges && this.changes.find({
+      if (t?.onlyWithChanges && await this.changes.find({
         collectionName: e,
         time: { $lte: a }
       }, {
         sort: { time: 1 },
-        reactive: !1
+        reactive: !1,
+        async: !0
       }).count() === 0)
         return;
-      o || (r = this.syncOperations.insert({
+      n || (r = 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
+      const h = await this.options.pull(s, {
+        lastFinishedSyncStart: i?.start,
+        lastFinishedSyncEnd: i?.end
       });
-      await this.syncWithData(e, l);
+      await this.syncWithData(e, h);
     };
-    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 ? c() : this.getSyncQueue(e).add(c)).catch(async (i) => {
+      throw r != null && (this.options.onError && this.options.onError(s, i), await this.syncOperations.updateOne({ id: r }, {
         $set: { status: "error", end: Date.now(), error: i.stack || i.message }
       })), i;
-    }), r != null && (this.syncOperations.removeMany({
+    }), r != null && (await this.syncOperations.removeMany({
       id: { $ne: r },
       collectionName: e,
       $or: [
         { end: { $lte: a } },
         { status: "active" }
       ]
-    }), this.syncOperations.updateOne({ id: r }, {
+    }), await this.syncOperations.updateOne({ id: r }, {
       $set: { status: "done", end: Date.now() }
     }));
   }
@@ -488,37 +482,40 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
     });
   }
   async syncWithData(e, t) {
-    const { collection: s, options: n } = this.getCollectionProperties(e), o = Date.now(), a = this.syncOperations.findOne({
+    const { collection: s, options: o } = this.getCollectionProperties(e), n = Date.now(), a = await this.syncOperations.findOne({
       collectionName: e,
       status: "done"
     }, {
       sort: { end: -1 },
-      reactive: !1
-    }), r = this.snapshots.findOne({
+      reactive: !1,
+      async: !0
+    }), r = await this.snapshots.findOne({
       collectionName: e
     }, {
       sort: { time: -1 },
-      reactive: !1
-    }), h = this.changes.find({
+      reactive: !1,
+      async: !0
+    }), c = await this.changes.find({
       collectionName: e,
-      time: { $lte: o }
+      time: { $lte: n }
     }, {
       sort: { time: 1 },
-      reactive: !1
+      reactive: !1,
+      async: !0
     }).fetch();
-    await I({
-      changes: h,
-      lastSnapshot: r == null ? void 0 : r.items,
+    await F({
+      changes: c,
+      lastSnapshot: r?.items,
       data: t,
-      pull: () => this.options.pull(n, {
-        lastFinishedSyncStart: a == null ? void 0 : a.start,
-        lastFinishedSyncEnd: a == null ? void 0 : a.end
+      pull: () => this.options.pull(o, {
+        lastFinishedSyncStart: a?.start,
+        lastFinishedSyncEnd: a?.end
       }),
-      push: (i) => this.options.push(n, {
+      push: (i) => this.options.push(o, {
         changes: i,
-        rawChanges: h
+        rawChanges: c
       }),
-      insert: (i) => {
+      insert: async (i) => {
         this.remoteChanges.push({
           collectionName: e,
           type: "insert",
@@ -527,65 +524,64 @@ ${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, h) => {
         this.remoteChanges.push({
           collectionName: e,
           type: "insert",
-          data: { id: i, ...l.$set }
+          data: { id: i, ...h.$set }
         }, {
           collectionName: e,
           type: "update",
-          data: { id: i, modifier: l }
-        }), s.updateOne({ id: i }, {
-          ...l,
+          data: { id: i, modifier: h }
+        }), await s.updateOne({ id: i }, {
+          ...h,
           $setOnInsert: { id: i }
         }, { upsert: !0 });
       },
-      remove: (i) => {
-        s.findOne({
+      remove: async (i) => {
+        await s.find({
           id: i
-        }, { reactive: !1 }) && (this.remoteChanges.push({
+        }, { reactive: !1, async: !0 }).count() > 0 && (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({
+        time: { $lte: n }
+      }), await this.changes.removeMany({
         collectionName: e,
-        id: { $in: h.map((d) => d.id) }
-      }), this.snapshots.insert({
-        time: o,
+        id: { $in: c.map((d) => d.id) }
+      }), await this.snapshots.insert({
+        time: n,
         collectionName: e,
         items: i
       }), await new Promise((d) => {
         setTimeout(d, 0);
-      }), this.changes.find({
+      }), await this.changes.find({
         collectionName: e
-      }, { reactive: !1 }).count() > 0) {
+      }, { reactive: !1, async: !0 }).count() > 0) {
         await this.sync(e, {
           force: !0,
           onlyWithChanges: !0
         });
         return;
       }
-      const f = s.find({
+      const p = await s.find({
         id: { $nin: i.map((d) => d.id) }
       }, {
-        reactive: !1
+        reactive: !1,
+        async: !0
       }).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 +590,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