@signaldb/sync 2.0.0-beta.0 → 2.0.0-beta.1

package/dist/SyncManager.d.ts

@@ -1,4 +1,4 @@
-import type { BaseItem, StorageAdapter, ReactivityAdapter, Changeset } from '@signaldb/core';
+import type { BaseItem, DataAdapter, ReactivityAdapter, Changeset } from '@signaldb/core';
 import { Collection } from '@signaldb/core';
 import PromiseQueue from './utils/PromiseQueue';
 import type { Change, LoadResponse, Snapshot, SyncOperation } from './types';
@@ -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;
-    storageAdapter?: (id: string, registerErrorHandler: (handler: (error: Error) => void) => void) => StorageAdapter<any, any>;
+    dataAdapter?: DataAdapter;
     reactivity?: ReactivityAdapter;
     onError?: (collectionOptions: SyncOptions<CollectionOptions>, error: Error) => void;
     autostart?: boolean;
@@ -66,7 +66,7 @@ export default class SyncManager<CollectionOptions extends Record<string, any>,
     protected scheduledPushes: Set<string>;
     protected remoteChanges: Omit<Change, 'id' | 'time'>[];
     protected syncQueues: Map<string, PromiseQueue>;
-    protected persistenceReady: Promise<void>;
+    protected collectionsReady: Promise<void>;
     protected isDisposed: boolean;
     protected instanceId: string;
     protected id: string;
@@ -84,10 +84,6 @@ export default class SyncManager<CollectionOptions extends Record<string, any>,
      * @param [options.debounceTime] The time in milliseconds to debounce push operations.
      */
     constructor(options: Options<CollectionOptions, ItemType, IdType>);
-    protected createStorageAdapter(name: string): {
-        adapter: StorageAdapter<any, any>;
-        handler: (error: Error) => void;
-    } | undefined;
     protected getSyncQueue(name: string): PromiseQueue;
     /**
      * Clears all internal data structures
@@ -154,9 +150,10 @@ export default class SyncManager<CollectionOptions extends Record<string, any>,
     /**
      * 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(name?: string): boolean;
+    isSyncing<Async extends boolean = false>(name?: string, async?: Async): Async extends true ? Promise<boolean> : boolean;
     /**
      * Checks if the sync manager is ready to sync.
      * @returns A promise that resolves when the sync manager is ready to sync.

package/dist/index.mjs

@@ -1,14 +1,14 @@
-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 c(...r) {
-    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 = h.apply(this, r));
-    }, e), i ? n = h.apply(this, r) : 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 c;
+  return r;
 }
 class D {
   queue = [];
@@ -20,8 +20,8 @@ class D {
    */
   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();
     });
   }
@@ -46,80 +46,80 @@ class D {
     }));
   }
 }
-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] !== 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}`);
+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 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);
+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 [r, i] of c)
-    a.has(r) || 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 w(h, e) {
+function g(l, e) {
   if (e.items != null)
     return e.items;
-  const t = h || [];
+  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 P(h, e) {
-  const t = new Map(h.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 ? g(n, s.data.modifier) : g({ 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 v(h) {
-  return h.added.length > 0 || h.modified.length > 0 || h.removed.length > 0;
+function v(l) {
+  return l.added.length > 0 || l.modified.length > 0 || l.removed.length > 0;
 }
-function M(h, e) {
-  return v(f(h, e));
+function M(l, e) {
+  return v(f(l, e));
 }
-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;
+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 ? 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)));
+  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 b {
@@ -131,9 +131,9 @@ class b {
   scheduledPushes = /* @__PURE__ */ new Set();
   remoteChanges = [];
   syncQueues = /* @__PURE__ */ new Map();
-  persistenceReady;
+  collectionsReady;
   isDisposed = !1;
-  instanceId = $();
+  instanceId = S();
   id;
   debouncedFlush;
   /**
@@ -153,53 +153,22 @@ class b {
       autostart: !0,
       ...e
     }, this.id = this.options.id || "default-sync-manager";
-    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, {
+    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 y(`${this.options.id}-snapshots`, a, {
+    }), this.snapshots = new y(`${this.options.id}-snapshots`, s, {
       indices: ["collectionName"],
       reactivity: t
-    }), this.syncOperations = new y(`${this.options.id}-sync-operations`, a, {
+    }), this.syncOperations = new y(`${this.options.id}-sync-operations`, s, {
       indices: ["collectionName", "status"],
       reactivity: t
-    }), 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 = E(this.flushScheduledPushes, this.options.debounceTime ?? 100);
-  }
-  createStorageAdapter(e) {
-    if (this.options.storageAdapter == null)
-      return;
-    let t = () => {
-    };
-    return {
-      adapter: this.options.storageAdapter(`${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 D()), this.syncQueues.get(e);
@@ -253,67 +222,67 @@ class b {
       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) => {
-      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));
+    }, o = (n, a) => {
+      const r = [...this.remoteChanges];
+      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 = c.filter((r) => r != 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
+        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: o }, a) => {
-      const c = { id: o, modifier: a };
-      if (s({ collectionName: t.name, type: "update", data: c })) {
-        n(t.name, o);
+    }), e.on("changed", ({ id: n }, a) => {
+      const r = { id: n, modifier: a };
+      if (s({ collectionName: t.name, type: "update", data: r })) {
+        o(t.name, n);
         return;
       }
       this.changes.insert({
         collectionName: t.name,
         time: Date.now(),
         type: "update",
-        data: c
+        data: r
       }).then(() => {
         this.getCollectionProperties(t.name).syncPaused || this.schedulePush(t.name);
-      }).catch((r) => {
-        this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, r);
+      }).catch((c) => {
+        this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, c);
       });
-    }), e.on("removed", ({ id: o }) => {
-      if (s({ collectionName: t.name, type: "remove", data: o })) {
-        n(t.name, o);
+    }), 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
+        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((o) => {
-      this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, o);
+    }), this.options.autostart && this.startSync(t.name).catch((n) => {
+      this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, n);
     });
   }
   flushScheduledPushes() {
@@ -342,31 +311,31 @@ class b {
     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 = await 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(async () => {
+        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" }
             ]
           }), await this.syncOperations.updateOne({ id: a }, {
             $set: { status: "done", end: Date.now() }
           });
-        }).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;
+        }).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;
         });
       }
     }) : void 0;
@@ -416,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
@@ -442,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 c = null;
+    let r = null;
     await new Promise((i) => {
       setTimeout(i, 0);
     });
-    const r = 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?.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 || (c = await 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, {
+      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?.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 }, {
+    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;
-    }), c != null && (await this.syncOperations.removeMany({
-      id: { $ne: c },
+    }), r != null && (await this.syncOperations.removeMany({
+      id: { $ne: r },
       collectionName: e,
       $or: [
         { end: { $lte: a } },
         { status: "active" }
       ]
-    }), await this.syncOperations.updateOne({ id: c }, {
+    }), await this.syncOperations.updateOne({ id: r }, {
       $set: { status: "done", end: Date.now() }
     }));
   }
@@ -508,35 +482,38 @@ ${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
-    }), c = this.snapshots.findOne({
+      reactive: !1,
+      async: !0
+    }), r = await this.snapshots.findOne({
       collectionName: e
     }, {
       sort: { time: -1 },
-      reactive: !1
-    }), r = 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 F({
-      changes: r,
-      lastSnapshot: c?.items,
+      changes: c,
+      lastSnapshot: r?.items,
       data: t,
-      pull: () => this.options.pull(n, {
+      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: r
+        rawChanges: c
       }),
       insert: async (i) => {
         this.remoteChanges.push({
@@ -549,24 +526,24 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
           data: { id: i.id, modifier: { $set: i } }
         }), await s.replaceOne({ id: i.id }, i, { upsert: !0 });
       },
-      update: async (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 }
+          data: { id: i, modifier: h }
         }), await s.updateOne({ id: i }, {
-          ...l,
+          ...h,
           $setOnInsert: { id: i }
         }, { upsert: !0 });
       },
       remove: async (i) => {
-        s.findOne({
+        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
@@ -578,29 +555,30 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
     }).then(async (i) => {
       if (await this.snapshots.removeMany({
         collectionName: e,
-        time: { $lte: o }
+        time: { $lte: n }
       }), await this.changes.removeMany({
         collectionName: e,
-        id: { $in: r.map((d) => d.id) }
+        id: { $in: c.map((d) => d.id) }
       }), await this.snapshots.insert({
-        time: o,
+        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 p = s.find({
+      const p = await s.find({
         id: { $nin: i.map((d) => d.id) }
       }, {
-        reactive: !1
+        reactive: !1,
+        async: !0
       }).map((d) => d.id);
       await s.batch(async () => {
         await Promise.all(i.map(async (d) => {