@signaldb/sync 1.0.0 → 1.1.0

package/dist/index.mjs

@@ -1,28 +1,32 @@
-import { isEqual as m, Collection as f, modify as P, randomId as N } from "@signaldb/core";
-function $(l, t, e = {}) {
-  let n, s;
-  const { leading: a = !1, trailing: i = !0 } = e;
-  function o(...d) {
-    const r = a && !n, c = i && !n;
-    return n && clearTimeout(n), n = setTimeout(() => {
-      n = null, i && !r && (s = l.apply(this, d));
-    }, t), r ? s = l.apply(this, d) : c || (s = null), s;
+var N = Object.defineProperty;
+var v = (c, e, t) => e in c ? N(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var l = (c, e, t) => v(c, typeof e != "symbol" ? e + "" : e, t);
+import { isEqual as m, Collection as y, modify as E, randomId as D } from "@signaldb/core";
+function S(c, e, t = {}) {
+  let s, n;
+  const { leading: a = !1, trailing: o = !0 } = t;
+  function r(...d) {
+    const i = a && !s, u = o && !s;
+    return s && clearTimeout(s), s = setTimeout(() => {
+      s = null, o && !i && (n = c.apply(this, d));
+    }, e), i ? n = c.apply(this, d) : u || (n = null), n;
   }
-  return o;
+  return r;
 }
-class E {
+class M {
   constructor() {
-    this.queue = [], this.pendingPromise = !1;
+    l(this, "queue", []);
+    l(this, "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
    * @returns Promise that resolves when the task is done
    */
-  add(t) {
-    return new Promise((e, n) => {
-      this.queue.push(() => t().then(e).catch((s) => {
-        throw n(s), s;
+  add(e) {
+    return new Promise((t, s) => {
+      this.queue.push(() => e().then(t).catch((n) => {
+        throw s(n), n;
       })), this.dequeue();
     });
   }
@@ -39,77 +43,79 @@ class E {
   dequeue() {
     if (this.pendingPromise || this.queue.length === 0)
       return;
-    const t = this.queue.shift();
-    t && (this.pendingPromise = !0, t().then(() => {
+    const e = this.queue.shift();
+    e && (this.pendingPromise = !0, e().then(() => {
       this.pendingPromise = !1, this.dequeue();
     }).catch(() => {
       this.pendingPromise = !1, this.dequeue();
     }));
   }
 }
-function g(l, t) {
-  const e = [], n = [], s = [], a = new Map(l.map((o) => [o.id, o])), i = new Map(t.map((o) => [o.id, o]));
-  for (const [o, d] of a) {
-    const r = i.get(o);
-    r ? m(r, d) || n.push(r) : s.push(d);
+function g(c, e) {
+  const t = [], s = [], n = [], a = new Map(c.map((r) => [r.id, r])), o = new Map(e.map((r) => [r.id, r]));
+  for (const [r, d] of a) {
+    const i = o.get(r);
+    i ? m(i, d) || s.push(i) : n.push(d);
   }
-  for (const [o, d] of i)
-    a.has(o) || e.push(d);
-  return { added: e, modified: n, removed: s };
+  for (const [r, d] of o)
+    a.has(r) || t.push(d);
+  return { added: t, modified: s, removed: n };
 }
-function v(l, t) {
-  if (t.items != null)
-    return t.items;
-  const e = l || [];
-  return t.changes.added.forEach((n) => {
-    const s = e.findIndex((a) => a.id === n.id);
-    s !== -1 ? e[s] = n : e.push(n);
-  }), t.changes.modified.forEach((n) => {
-    const s = e.findIndex((a) => a.id === n.id);
-    s !== -1 ? e[s] = n : e.push(n);
-  }), t.changes.removed.forEach((n) => {
-    const s = e.findIndex((a) => a.id === n.id);
-    s !== -1 && e.splice(s, 1);
-  }), e;
+function C(c, e) {
+  if (e.items != null)
+    return e.items;
+  const t = c || [];
+  return e.changes.added.forEach((s) => {
+    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((a) => a.id === s.id);
+    n === -1 ? t.push(s) : t[n] = s;
+  }), e.changes.removed.forEach((s) => {
+    const n = t.findIndex((a) => a.id === s.id);
+    n !== -1 && t.splice(n, 1);
+  }), t;
 }
-function O(l, t) {
-  const e = new f();
-  return e.batch(() => {
-    l.forEach((n) => e.insert(n)), t.forEach((n) => {
+async function P(c, e) {
+  const t = new y();
+  t.batch(() => {
+    c.forEach((n) => t.insert(n)), e.forEach((n) => {
       if (n.type === "remove") {
-        e.removeOne({ id: n.data });
+        t.removeOne({ id: n.data });
         return;
       }
-      const s = { id: n.data.id }, a = e.findOne(s);
+      const a = { id: n.data.id }, o = t.findOne(a);
       if (n.type === "insert") {
-        a ? e.updateOne(s, { $set: n.data }) : e.insert(n.data);
+        o ? t.updateOne(a, { $set: n.data }) : t.insert(n.data);
         return;
       }
-      a ? e.updateOne(s, n.data.modifier) : e.insert(P(s, n.data.modifier));
+      o ? t.updateOne(a, n.data.modifier) : t.insert(E(a, n.data.modifier));
     });
-  }), e.find().fetch();
+  });
+  const s = t.find().fetch();
+  return await t.dispose(), s;
 }
-function C(l) {
-  return l.added.length > 0 || l.modified.length > 0 || l.removed.length > 0;
+function O(c) {
+  return c.added.length > 0 || c.modified.length > 0 || c.removed.length > 0;
 }
-function S(l, t) {
-  return C(g(l, t));
+function I(c, e) {
+  return O(g(c, e));
 }
-async function D({ changes: l, lastSnapshot: t, data: e, pull: n, push: s, insert: a, update: i, remove: o, batch: d }) {
-  let r = e, c = t || [], u = v(t, r);
-  if (l.length > 0) {
-    const h = O(c, l);
-    if (S(c, h)) {
-      const y = O(u, l), w = g(u, y);
-      C(w) && (await s(w), r = await n(), u = v(u, r)), c = h;
+async function x({ changes: c, lastSnapshot: e, data: t, pull: s, push: n, insert: a, update: o, remove: r, batch: d }) {
+  let i = t, u = e || [], p = C(e, i);
+  if (c.length > 0) {
+    const f = await P(u, c);
+    if (I(u, f)) {
+      const $ = await P(p, c), w = g(p, $);
+      O(w) && (await n(w), i = await s(), p = C(p, i)), u = f;
     }
   }
-  const p = r.changes == null ? g(c, r.items) : r.changes;
+  const h = i.changes == null ? g(u, i.items) : i.changes;
   return d(() => {
-    p.added.forEach((h) => a(h)), p.modified.forEach((h) => i(h.id, { $set: h })), p.removed.forEach((h) => o(h.id));
-  }), u;
+    h.added.forEach((f) => a(f)), h.modified.forEach((f) => o(f.id, { $set: f })), h.removed.forEach((f) => r(f.id));
+  }), p;
 }
-class I {
+class q {
   /**
    * @param options Collection options
    * @param options.pull Function to pull data from remote source.
@@ -120,62 +126,60 @@ class I {
    * @param [options.reactivity] Reactivity adapter to use for reactivity.
    * @param [options.onError] Function to handle errors that occur async during syncing.
    */
-  constructor(t) {
-    this.collections = /* @__PURE__ */ new Map(), this.remoteChanges = [], this.syncQueues = /* @__PURE__ */ new Map(), this.isDisposed = !1, this.instanceId = N(), this.deboucedPush = $((i) => {
-      this.pushChanges(i).catch(() => {
+  constructor(e) {
+    l(this, "options");
+    l(this, "collections", /* @__PURE__ */ new Map());
+    l(this, "changes");
+    l(this, "snapshots");
+    l(this, "syncOperations");
+    l(this, "remoteChanges", []);
+    l(this, "syncQueues", /* @__PURE__ */ new Map());
+    l(this, "persistenceReady");
+    l(this, "isDisposed", !1);
+    l(this, "instanceId", D());
+    l(this, "id");
+    l(this, "deboucedPush", S((e) => {
+      this.pushChanges(e).catch(() => {
       });
-    }, 100), this.options = t;
-    const { reactivity: e } = this.options, n = this.createPersistenceAdapter("changes"), s = this.createPersistenceAdapter("snapshots"), a = this.createPersistenceAdapter("sync-operations");
-    this.changes = new f({
-      persistence: n == null ? void 0 : n.adapter,
-      reactivity: e
-    }), this.snapshots = new f({
+    }, 100));
+    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"), a = this.createPersistenceAdapter("sync-operations");
+    this.changes = new y({
+      name: `${this.options.id}-changes`,
       persistence: s == null ? void 0 : s.adapter,
-      reactivity: e
-    }), this.syncOperations = new f({
+      reactivity: t
+    }), this.snapshots = new y({
+      name: `${this.options.id}-snapshots`,
+      persistence: n == null ? void 0 : n.adapter,
+      reactivity: t
+    }), this.syncOperations = new y({
+      name: `${this.options.id}-sync-operations`,
       persistence: a == null ? void 0 : a.adapter,
-      reactivity: e
-    }), this.changes.on("persistence.error", (i) => n == null ? void 0 : n.handler(i)), this.snapshots.on("persistence.error", (i) => s == null ? void 0 : s.handler(i)), this.syncOperations.on("persistence.error", (i) => a == null ? void 0 : a.handler(i)), this.persistenceReady = Promise.all([
-      new Promise((i, o) => {
-        if (!n) {
-          i();
-          return;
-        }
-        this.syncOperations.once("persistence.error", o), this.syncOperations.once("persistence.init", i);
-      }),
-      new Promise((i, o) => {
-        if (!s) {
-          i();
-          return;
-        }
-        this.changes.once("persistence.error", o), this.changes.once("persistence.init", i);
-      }),
-      new Promise((i, o) => {
-        if (!a) {
-          i();
-          return;
-        }
-        this.snapshots.once("persistence.error", o), this.snapshots.once("persistence.init", i);
-      })
+      reactivity: t
+    }), this.changes.on("persistence.error", (o) => s == null ? void 0 : s.handler(o)), this.snapshots.on("persistence.error", (o) => n == null ? void 0 : n.handler(o)), this.syncOperations.on("persistence.error", (o) => a == null ? void 0 : a.handler(o)), 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);
   }
-  createPersistenceAdapter(t) {
-    var e;
+  createPersistenceAdapter(e) {
     if (this.options.persistenceAdapter == null)
       return;
-    const n = (e = this.options.id) !== null && e !== void 0 ? e : "default-sync-manager";
-    let s = () => {
+    let t = () => {
     };
     return {
-      adapter: this.options.persistenceAdapter(`${n}-${t}`, (i) => {
-        s = i;
+      adapter: this.options.persistenceAdapter(`${this.id}-${e}`, (n) => {
+        t = n;
       }),
-      handler: (i) => s(i)
+      handler: (n) => t(n)
     };
   }
-  getSyncQueue(t) {
-    return this.syncQueues.get(t) == null && this.syncQueues.set(t, new E()), this.syncQueues.get(t);
+  getSyncQueue(e) {
+    return this.syncQueues.get(e) == null && this.syncQueues.set(e, new M()), this.syncQueues.get(e);
   }
   /**
    * Clears all internal data structures
@@ -189,15 +193,26 @@ class I {
   }
   /**
    * 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
    * @returns Tuple of collection and options
    */
-  getCollection(t) {
-    const e = this.collections.get(t);
-    if (e == null)
-      throw new Error(`Collection with id '${t}' not found`);
-    return e;
+  getCollection(e) {
+    const { collection: t, options: s } = this.getCollectionProperties(e);
+    return [t, s];
+  }
+  /**
+   * Gets collection options by name
+   * @param name Name of the collection
+   * @throws Will throw an error if the name wasn't found
+   * @returns An object of all properties of the collection
+   */
+  getCollectionProperties(e) {
+    const t = this.collections.get(e);
+    if (t == null)
+      throw new Error(`Collection with id '${e}' not found`);
+    return t;
   }
   /**
    * Adds a collection to the sync manager.
@@ -205,87 +220,141 @@ class I {
    * @param options Options for the collection. The object needs at least a `name` property.
    * @param options.name Unique name of the collection
    */
-  addCollection(t, e) {
+  addCollection(e, t) {
     if (this.isDisposed)
       throw new Error("SyncManager is disposed");
-    this.options.registerRemoteChange && this.options.registerRemoteChange(e, async (a) => {
-      if (a == null)
-        await this.sync(e.name);
-      else {
-        const i = Date.now(), o = this.syncOperations.insert({
-          start: i,
-          collectionName: e.name,
-          instanceId: this.instanceId,
-          status: "active"
-        });
-        await this.syncWithData(e.name, a).then(() => {
-          this.syncOperations.removeMany({
-            id: { $ne: o },
-            collectionName: e.name,
-            $or: [
-              { end: { $lte: i } },
-              { status: "active" }
-            ]
-          }), this.syncOperations.updateOne({ id: o }, {
-            $set: { status: "done", end: Date.now() }
-          });
-        }).catch((d) => {
-          throw this.options.onError && this.options.onError(e, d), this.syncOperations.updateOne({ id: o }, {
-            $set: { status: "error", end: Date.now(), error: d.stack || d.message }
-          }), d;
-        });
-      }
-    }), this.collections.set(e.name, [t, e]);
-    const n = (a) => {
-      for (const i of this.remoteChanges)
-        if (m(i, a))
+    this.collections.set(t.name, {
+      collection: e,
+      options: t,
+      readyPromise: e.isReady(),
+      syncPaused: !0
+      // always start paused as the autostart will start it
+    });
+    const s = (a) => {
+      for (const o of this.remoteChanges)
+        if (m(o, a))
           return !0;
       return !1;
-    }, s = (a) => {
-      for (let i = 0; i < this.remoteChanges.length; i += 1)
-        if (m(this.remoteChanges[i], a)) {
-          this.remoteChanges.splice(i, 1);
+    }, n = (a) => {
+      for (let o = 0; o < this.remoteChanges.length; o += 1)
+        if (m(this.remoteChanges[o], a)) {
+          this.remoteChanges.splice(o, 1);
           return;
         }
     };
-    t.on("added", (a) => {
-      if (n({ collectionName: e.name, type: "insert", data: a })) {
-        s({ collectionName: e.name, type: "insert", data: a });
+    e.on("added", (a) => {
+      if (s({ collectionName: t.name, type: "insert", data: a })) {
+        n({ collectionName: t.name, type: "insert", data: a });
         return;
       }
       this.changes.insert({
-        collectionName: e.name,
+        collectionName: t.name,
         time: Date.now(),
         type: "insert",
         data: a
-      }), this.schedulePush(e.name);
-    }), t.on("changed", ({ id: a }, i) => {
-      const o = { id: a, modifier: i };
-      if (n({ collectionName: e.name, type: "update", data: o })) {
-        s({ collectionName: e.name, type: "update", data: o });
+      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
+    }), e.on("changed", ({ id: a }, o) => {
+      const r = { id: a, modifier: o };
+      if (s({ collectionName: t.name, type: "update", data: r })) {
+        n({ collectionName: t.name, type: "update", data: r });
         return;
       }
       this.changes.insert({
-        collectionName: e.name,
+        collectionName: t.name,
         time: Date.now(),
         type: "update",
-        data: o
-      }), this.schedulePush(e.name);
-    }), t.on("removed", ({ id: a }) => {
-      if (n({ collectionName: e.name, type: "remove", data: a })) {
-        s({ collectionName: e.name, type: "remove", data: a });
+        data: r
+      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
+    }), e.on("removed", ({ id: a }) => {
+      if (s({ collectionName: t.name, type: "remove", data: a })) {
+        n({ collectionName: t.name, type: "remove", data: a });
         return;
       }
       this.changes.insert({
-        collectionName: e.name,
+        collectionName: t.name,
         time: Date.now(),
         type: "remove",
         data: a
-      }), this.schedulePush(e.name);
+      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
+    }), this.options.autostart && this.startSync(t.name).catch((a) => {
+      this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, a);
     });
   }
-  schedulePush(t) {
-    this.deboucedPush(t);
+  schedulePush(e) {
+    this.deboucedPush(e);
+  }
+  /**
+   * Setup all collections to be synced with remote changes
+   * and enable automatic pushing changes to the remote source.
+   */
+  async startAll() {
+    await Promise.all([...this.collections.keys()].map((e) => this.startSync(e)));
+  }
+  /**
+   * Setup a collection to be synced with remote changes
+   * and enable automatic pushing changes to the remote source.
+   * @param name Name of the collection
+   */
+  async startSync(e) {
+    const t = this.getCollectionProperties(e);
+    if (!t.syncPaused)
+      return;
+    this.schedulePush(e);
+    const s = this.options.registerRemoteChange ? await this.options.registerRemoteChange(t.options, async (n) => {
+      if (n == null)
+        await this.sync(e);
+      else {
+        const a = Date.now(), o = this.syncOperations.insert({
+          start: a,
+          collectionName: e,
+          instanceId: this.instanceId,
+          status: "active"
+        });
+        await this.syncWithData(e, n).then(() => {
+          this.syncOperations.removeMany({
+            id: { $ne: o },
+            collectionName: e,
+            $or: [
+              { end: { $lte: a } },
+              { status: "active" }
+            ]
+          }), this.syncOperations.updateOne({ id: o }, {
+            $set: { status: "done", end: Date.now() }
+          });
+        }).catch((r) => {
+          throw this.options.onError && this.options.onError(this.getCollectionProperties(e).options, r), this.syncOperations.updateOne({ id: o }, {
+            $set: { status: "error", end: Date.now(), error: r.stack || r.message }
+          }), r;
+        });
+      }
+    }) : void 0;
+    this.collections.set(e, {
+      ...t,
+      syncPaused: !1,
+      cleanupFunction: s
+    });
+  }
+  /**
+   * Pauses the sync process for all collections.
+   * This means that the collections will not be synced with remote changes
+   * and changes will not automatically be pushed to the remote source.
+   */
+  async pauseAll() {
+    await Promise.all([...this.collections.keys()].map((e) => this.pauseSync(e)));
+  }
+  /**
+   * Pauses the sync process for a collection.
+   * This means that the collection will not be synced with remote changes
+   * and changes will not automatically be pushed to the remote source.
+   * @param name Name of the collection
+   */
+  async pauseSync(e) {
+    const t = this.getCollectionProperties(e);
+    t.syncPaused || (t.cleanupFunction && await t.cleanupFunction(), this.collections.set(e, {
+      ...t,
+      cleanupFunction: void 0,
+      syncPaused: !0
+    }));
   }
   /**
    * Starts the sync process for all collections
@@ -293,12 +362,12 @@ class I {
   async syncAll() {
     if (this.isDisposed)
       throw new Error("SyncManager is disposed");
-    const t = [];
-    if (await Promise.all([...this.collections.keys()].map((e) => this.sync(e).catch((n) => {
-      t.push({ id: e, error: n });
-    }))), t.length > 0)
+    const e = [];
+    if (await Promise.all([...this.collections.keys()].map((t) => this.sync(t).catch((s) => {
+      e.push({ id: t, error: s });
+    }))), e.length > 0)
       throw new Error(`Error while syncing collections:
-${t.map((e) => `${e.id}: ${e.error.message}`).join(`
+${e.map((t) => `${t.id}: ${t.error.message}`).join(`
 
 `)}`);
   }
@@ -307,8 +376,11 @@ ${t.map((e) => `${e.id}: ${e.error.message}`).join(`
    * @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.
    */
-  isSyncing(t) {
-    return this.syncOperations.findOne(Object.assign(Object.assign({}, t ? { collectionName: t } : {}), { status: "active" }), { fields: { status: 1 } }) != null;
+  isSyncing(e) {
+    return this.syncOperations.findOne({
+      ...e ? { collectionName: e } : {},
+      status: "active"
+    }, { fields: { status: 1 } }) != null;
   }
   /**
    * Checks if the sync manager is ready to sync.
@@ -324,52 +396,54 @@ ${t.map((e) => `${e.id}: ${e.error.message}`).join(`
    * @param options.force If true, the sync process will be started even if there are no changes and onlyWithChanges is true.
    * @param options.onlyWithChanges If true, the sync process will only be started if there are changes.
    */
-  async sync(t, e = {}) {
+  async sync(e, t = {}) {
     if (this.isDisposed)
       throw new Error("SyncManager is disposed");
     await this.isReady();
-    const s = this.getCollection(t)[1], a = this.syncOperations.find({
-      collectionName: t,
+    const { options: s, readyPromise: n } = this.getCollectionProperties(e);
+    await n;
+    const a = this.syncOperations.find({
+      collectionName: e,
       instanceId: this.instanceId,
       status: "active"
-    }).count() > 0, i = Date.now();
-    let o = null;
-    await new Promise((r) => {
-      setTimeout(r, 0);
+    }).count() > 0, o = Date.now();
+    let r = null;
+    await new Promise((i) => {
+      setTimeout(i, 0);
     });
     const d = async () => {
-      const r = this.syncOperations.findOne({ collectionName: t, status: "done" }, { sort: { end: -1 } });
-      if (e != null && e.onlyWithChanges && this.changes.find({
-        collectionName: t,
+      const i = this.syncOperations.findOne({ collectionName: e, status: "done" }, { sort: { end: -1 } });
+      if (t != null && t.onlyWithChanges && this.changes.find({
+        collectionName: e,
         $and: [
-          { time: { $lte: i } }
+          { time: { $lte: o } }
         ]
       }, { sort: { time: 1 } }).count() === 0)
         return;
-      a || (o = this.syncOperations.insert({
-        start: i,
-        collectionName: t,
+      a || (r = this.syncOperations.insert({
+        start: o,
+        collectionName: e,
         instanceId: this.instanceId,
         status: "active"
       }));
-      const c = await this.options.pull(s, {
-        lastFinishedSyncStart: r == null ? void 0 : r.start,
-        lastFinishedSyncEnd: r == null ? void 0 : r.end
+      const u = await this.options.pull(s, {
+        lastFinishedSyncStart: i == null ? void 0 : i.start,
+        lastFinishedSyncEnd: i == null ? void 0 : i.end
       });
-      await this.syncWithData(t, c);
+      await this.syncWithData(e, u);
     };
-    await (e != null && e.force ? d() : this.getSyncQueue(t).add(d)).catch((r) => {
-      throw o != null && (this.options.onError && this.options.onError(s, r), this.syncOperations.updateOne({ id: o }, {
-        $set: { status: "error", end: Date.now(), error: r.stack || r.message }
-      })), r;
-    }), o != null && (this.syncOperations.removeMany({
-      id: { $ne: o },
-      collectionName: t,
+    await (t != null && t.force ? d() : this.getSyncQueue(e).add(d)).catch((i) => {
+      throw r != null && (this.options.onError && this.options.onError(s, i), this.syncOperations.updateOne({ id: r }, {
+        $set: { status: "error", end: Date.now(), error: i.stack || i.message }
+      })), i;
+    }), r != null && (this.syncOperations.removeMany({
+      id: { $ne: r },
+      collectionName: e,
       $or: [
-        { end: { $lte: i } },
+        { end: { $lte: o } },
         { status: "active" }
       ]
-    }), this.syncOperations.updateOne({ id: o }, {
+    }), this.syncOperations.updateOne({ id: r }, {
       $set: { status: "done", end: Date.now() }
     }));
   }
@@ -377,102 +451,102 @@ ${t.map((e) => `${e.id}: ${e.error.message}`).join(`
    * Starts the push process for a collection (sync process but only if there are changes)
    * @param name Name of the collection
    */
-  async pushChanges(t) {
-    await this.sync(t, {
+  async pushChanges(e) {
+    await this.sync(e, {
       onlyWithChanges: !0
     });
   }
-  async syncWithData(t, e) {
-    const n = this.getCollection(t), [s, a] = n, i = Date.now(), o = this.syncOperations.findOne({ collectionName: t, status: "done" }, { sort: { end: -1 } }), d = this.snapshots.findOne({ collectionName: t }, { sort: { time: -1 } }), r = this.changes.find({
-      collectionName: t,
+  async syncWithData(e, t) {
+    const { collection: s, options: n } = this.getCollectionProperties(e), a = Date.now(), o = this.syncOperations.findOne({ collectionName: e, status: "done" }, { sort: { end: -1 } }), r = this.snapshots.findOne({ collectionName: e }, { sort: { time: -1 } }), d = this.changes.find({
+      collectionName: e,
       $and: [
-        { time: { $lte: i } }
+        { time: { $lte: a } }
       ]
     }, { sort: { time: 1 } }).fetch();
-    await D({
-      changes: r,
-      lastSnapshot: d == null ? void 0 : d.items,
-      data: e,
-      pull: () => this.options.pull(a, {
+    await x({
+      changes: d,
+      lastSnapshot: r == null ? void 0 : r.items,
+      data: t,
+      pull: () => this.options.pull(n, {
         lastFinishedSyncStart: o == null ? void 0 : o.start,
         lastFinishedSyncEnd: o == null ? void 0 : o.end
       }),
-      push: (c) => this.options.push(a, { changes: c }),
-      insert: (c) => {
-        if (c.id && s.findOne({ id: c.id })) {
+      push: (i) => this.options.push(n, { changes: i }),
+      insert: (i) => {
+        if (i.id && s.findOne({ id: i.id })) {
           this.remoteChanges.push({
-            collectionName: t,
+            collectionName: e,
             type: "update",
-            data: { id: c.id, modifier: { $set: c } }
-          }), s.updateOne({ id: c.id }, { $set: c });
+            data: { id: i.id, modifier: { $set: i } }
+          }), s.updateOne({ id: i.id }, { $set: i });
           return;
         }
         this.remoteChanges.push({
-          collectionName: t,
+          collectionName: e,
           type: "insert",
-          data: c
-        }), s.insert(c);
+          data: i
+        }), s.insert(i);
       },
-      update: (c, u) => {
-        if (c && !s.findOne({ id: c })) {
-          const p = Object.assign(Object.assign({}, u.$set), { id: c });
+      update: (i, u) => {
+        if (i && !s.findOne({ id: i })) {
+          const p = { ...u.$set, id: i };
           this.remoteChanges.push({
-            collectionName: t,
+            collectionName: e,
             type: "insert",
             data: p
           }), s.insert(p);
           return;
         }
         this.remoteChanges.push({
-          collectionName: t,
+          collectionName: e,
           type: "update",
-          data: { id: c, modifier: u }
-        }), s.updateOne({ id: c }, u);
+          data: { id: i, modifier: u }
+        }), s.updateOne({ id: i }, u);
       },
-      remove: (c) => {
-        s.findOne({ id: c }) && (this.remoteChanges.push({
-          collectionName: t,
+      remove: (i) => {
+        s.findOne({ id: i }) && (this.remoteChanges.push({
+          collectionName: e,
           type: "remove",
-          data: c
-        }), s.removeOne({ id: c }));
+          data: i
+        }), s.removeOne({ id: i }));
       },
-      batch: (c) => {
+      batch: (i) => {
         s.batch(() => {
-          c();
+          i();
         });
       }
-    }).then(async (c) => {
-      if (this.snapshots.removeMany({ collectionName: t, time: { $lte: i } }), this.changes.removeMany({
-        collectionName: t,
-        id: { $in: r.map((h) => h.id) }
+    }).then(async (i) => {
+      if (this.snapshots.removeMany({ collectionName: e, time: { $lte: a } }), this.changes.removeMany({
+        collectionName: e,
+        id: { $in: d.map((h) => h.id) }
       }), this.snapshots.insert({
-        time: i,
-        collectionName: t,
-        items: c
+        time: a,
+        collectionName: e,
+        items: i
       }), await new Promise((h) => {
         setTimeout(h, 0);
       }), this.changes.find({
-        collectionName: t
+        collectionName: e
       }).count() > 0) {
-        await this.sync(t, {
+        await this.sync(e, {
           force: !0,
           onlyWithChanges: !0
         });
         return;
       }
       const p = s.find({
-        id: { $nin: c.map((h) => h.id) }
+        id: { $nin: i.map((h) => h.id) }
       }).map((h) => h.id);
       s.batch(() => {
-        c.forEach((h) => {
-          const y = !!s.findOne({ id: h.id });
+        i.forEach((h) => {
+          const f = !!s.findOne({ id: h.id });
           /* istanbul ignore else -- @preserve */
-          y ? (this.remoteChanges.push({
-            collectionName: t,
+          f ? (this.remoteChanges.push({
+            collectionName: e,
             type: "update",
             data: { id: h.id, modifier: { $set: h } }
           }), s.updateOne({ id: h.id }, { $set: h })) : (this.remoteChanges.push({
-            collectionName: t,
+            collectionName: e,
             type: "insert",
             data: h
           }), s.insert(h));
@@ -484,6 +558,6 @@ ${t.map((e) => `${e.id}: ${e.error.message}`).join(`
   }
 }
 export {
-  I as SyncManager
+  q as SyncManager
 };
 //# sourceMappingURL=index.mjs.map