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

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 = {}) {
+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, n;
-  const { leading: o = !1, trailing: a = !0 } = t;
-  function c(...r) {
-    const i = o && !s, l = a && !s;
+  const { leading: a = !1, trailing: o = !0 } = t;
+  function r(...c) {
+    const i = a && !s, h = o && !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, o && !i && (n = l.apply(this, c));
+    }, e), i ? n = l.apply(this, c) : h || (n = null), n;
   }
-  return c;
+  return r;
 }
 class D {
   queue = [];
@@ -46,50 +46,50 @@ 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), n = Object.keys(e), a = /* @__PURE__ */ new Set([...s, ...n]);
+  for (const o of a)
+    if (e[o] !== l[o])
+      if (typeof e[o] == "object" && typeof l[o] == "object" && e[o] != null && l[o] != null) {
+        const r = C(l[o], e[o]);
+        for (const c of r)
+          t.push(`${o}.${c}`);
       } else
-        t.push(a);
+        t.push(o);
   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 = [], n = /* @__PURE__ */ new Map(), a = [], o = new Map(l.map((c) => [c.id, c])), r = new Map(e.map((c) => [c.id, c]));
+  for (const [c, i] of o) {
+    const h = r.get(c);
+    h ? N(h, i) || (n.set(h.id, C(i, h)), s.push(h)) : a.push(i);
   }
-  for (const [r, i] of c)
-    a.has(r) || t.push(i);
+  for (const [c, i] of r)
+    o.has(c) || t.push(i);
   return {
     added: t,
     modified: s,
     modifiedFields: n,
-    removed: o
+    removed: a
   };
 }
-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);
+    const n = t.findIndex((a) => a.id === s.id);
     n === -1 ? t.push(s) : t[n] = s;
   }), e.changes.modified.forEach((s) => {
-    const n = t.findIndex((o) => o.id === s.id);
+    const n = t.findIndex((a) => a.id === s.id);
     n === -1 ? t.push(s) : t[n] = s;
   }), e.changes.removed.forEach((s) => {
-    const n = t.findIndex((o) => o.id === s.id);
+    const n = t.findIndex((a) => a.id === s.id);
     n !== -1 && t.splice(n, 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);
@@ -98,28 +98,28 @@ function P(h, 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 ? g(n, s.data.modifier) : g({ id: s.data.id }, s.data.modifier));
+      t.set(s.data.id, n ? w(n, 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: n, insert: a, update: o, 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 n(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) => a(u))), await Promise.all(d.modified.map((u) => o(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,24 @@ 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.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)
-    };
+    });
+    const n = [
+      Promise.resolve(this.syncOperations.isReady()),
+      Promise.resolve(this.changes.isReady()),
+      Promise.resolve(this.snapshots.isReady())
+    ];
+    this.collectionsReady = Promise.all(n).then(() => {
+    }), 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);
@@ -218,7 +189,7 @@ class b {
    * Gets a collection with it's options by name
    * @deprecated Use getCollectionProperties instead.
    * @param name Name of the collection
-   * @throws Will throw an error if the name wasn't found
+   * @throws {Error} Will throw an error if the name wasn't found
    * @returns Tuple of collection and options
    */
   getCollection(e) {
@@ -228,7 +199,7 @@ class b {
   /**
    * Gets collection options by name
    * @param name Name of the collection
-   * @throws Will throw an error if the name wasn't found
+   * @throws {Error} Will throw an error if the name wasn't found
    * @returns An object of all properties of the collection
    */
   getCollectionProperties(e) {
@@ -253,67 +224,67 @@ class b {
       syncPaused: !0
       // always start paused as the autostart will start it
     });
-    const s = (o) => {
-      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)
+    const s = (a) => {
+      for (const o of this.remoteChanges)
+        if (o != null && o.collectionName === a.collectionName && o.type === a.type && !(a.type === "remove" && o.data !== a.data) && o.data.id === a.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));
+    }, n = (a, o) => {
+      const r = [...this.remoteChanges];
+      for (let c = 0; c < r.length; c += 1) {
+        const i = r[c];
+        i != null && i.collectionName === a && (i.type === "remove" && i.data !== o || i.data.id === o && (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", (a) => {
+      if (s({ collectionName: t.name, type: "insert", data: a })) {
+        n(t.name, a.id);
         return;
       }
       this.changes.insert({
         collectionName: t.name,
         time: Date.now(),
         type: "insert",
-        data: o
+        data: a
       }).then(() => {
         this.getCollectionProperties(t.name).syncPaused || this.schedulePush(t.name);
-      }).catch((a) => {
-        this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, a);
+      }).catch((o) => {
+        this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, o);
       });
-    }), 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: a }, o) => {
+      const r = { id: a, modifier: o };
+      if (s({ collectionName: t.name, type: "update", data: r })) {
+        n(t.name, a);
         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: a }) => {
+      if (s({ collectionName: t.name, type: "remove", data: a })) {
+        n(t.name, a);
         return;
       }
       this.changes.insert({
         collectionName: t.name,
         time: Date.now(),
         type: "remove",
-        data: o
+        data: a
       }).then(() => {
         this.getCollectionProperties(t.name).syncPaused || this.schedulePush(t.name);
-      }).catch((a) => {
-        this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, a);
+      }).catch((o) => {
+        this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, o);
       });
-    }), 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((a) => {
+      this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, a);
     });
   }
   flushScheduledPushes() {
@@ -346,27 +317,27 @@ class b {
       if (n == null)
         await this.sync(e);
       else {
-        const o = Date.now(), a = await this.syncOperations.insert({
-          start: o,
+        const a = Date.now(), o = await this.syncOperations.insert({
+          start: a,
           collectionName: e,
           instanceId: this.instanceId,
           status: "active"
         });
         await this.syncWithData(e, n).then(async () => {
           await this.syncOperations.removeMany({
-            id: { $ne: a },
+            id: { $ne: o },
             collectionName: e,
             $or: [
-              { end: { $lte: o } },
+              { end: { $lte: a } },
               { status: "active" }
             ]
-          }), await this.syncOperations.updateOne({ id: a }, {
+          }), await this.syncOperations.updateOne({ id: o }, {
             $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: o }, {
+            $set: { status: "error", end: Date.now(), error: r.stack || r.message }
+          }), r;
         });
       }
     }) : void 0;
@@ -416,20 +387,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((n) => n != 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
@@ -444,57 +417,60 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
     await this.isReady();
     const { options: s, readyPromise: n } = this.getCollectionProperties(e);
     await n;
-    const o = this.syncOperations.find({
+    const a = await this.syncOperations.find({
       collectionName: e,
       instanceId: this.instanceId,
       status: "active"
     }, {
-      reactive: !1
-    }).count() > 0, a = Date.now();
-    let c = null;
+      reactive: !1,
+      async: !0
+    }).count() > 0, o = Date.now();
+    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 }
+        time: { $lte: o }
       }, {
         sort: { time: 1 },
-        reactive: !1
+        reactive: !1,
+        async: !0
       }).count() === 0)
         return;
-      o || (c = await this.syncOperations.insert({
-        start: a,
+      a || (r = await this.syncOperations.insert({
+        start: o,
         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 } },
+        { end: { $lte: o } },
         { status: "active" }
       ]
-    }), await this.syncOperations.updateOne({ id: c }, {
+    }), await this.syncOperations.updateOne({ id: r }, {
       $set: { status: "done", end: Date.now() }
     }));
   }
@@ -508,35 +484,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: n } = this.getCollectionProperties(e), a = Date.now(), o = 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: a }
     }, {
       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, {
-        lastFinishedSyncStart: a?.start,
-        lastFinishedSyncEnd: a?.end
+        lastFinishedSyncStart: o?.start,
+        lastFinishedSyncEnd: o?.end
       }),
       push: (i) => this.options.push(n, {
         changes: i,
-        rawChanges: r
+        rawChanges: c
       }),
       insert: async (i) => {
         this.remoteChanges.push({
@@ -549,24 +528,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 +557,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: a }
       }), 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: a,
         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) => {