@absolutejs/sync 1.18.0 → 1.18.2

package/dist/engine/index.js

@@ -1565,11 +1565,11 @@ var createSyncEngine = (options = {}) => {
   };
   const streamSubscribers = new Set;
   const runInTransaction = options.transaction;
-  const instanceId = globalThis.crypto?.randomUUID?.() ?? `i${Math.random()}`;
+  const instanceId = options.instanceId ?? globalThis.crypto?.randomUUID?.() ?? `i${Math.random()}`;
   let clusterBus;
-  const broadcast = (changes) => {
+  const broadcast = (changes, originVersion) => {
     if (clusterBus !== undefined && changes.length > 0) {
-      clusterBus.publish({ changes, origin: instanceId });
+      clusterBus.publish({ changes, origin: instanceId, originVersion });
     }
   };
   const subsFor = (collection) => {
@@ -1946,11 +1946,44 @@ var createSyncEngine = (options = {}) => {
       subscriber(entry);
     }
   };
+  const encodeCursor = (versions) => JSON.stringify(versions);
+  const decodeCursor = (cursor) => {
+    try {
+      const parsed = JSON.parse(cursor);
+      if (typeof parsed !== "object" || parsed === null)
+        return null;
+      const out = {};
+      for (const [k, v] of Object.entries(parsed)) {
+        if (typeof v === "number")
+          out[k] = v;
+      }
+      return out;
+    } catch {
+      return null;
+    }
+  };
+  const currentCursor = () => {
+    const versions = { [instanceId]: version };
+    for (let i = changeLog.length - 1;i >= 0; i--) {
+      const entry = changeLog[i];
+      if (versions[entry.origin] === undefined) {
+        versions[entry.origin] = entry.originVersion;
+      }
+    }
+    return encodeCursor(versions);
+  };
   const applyChange = async (table, change, shouldBroadcast = true) => {
     version += 1;
     const changeVersion = version;
     const at = Date.now();
-    logChange(changeVersion, { version: changeVersion, table, change, at });
+    logChange(changeVersion, {
+      version: changeVersion,
+      table,
+      change,
+      at,
+      origin: instanceId,
+      originVersion: changeVersion
+    });
     emitActivity({
       type: "change",
       at,
@@ -1969,14 +2002,15 @@ var createSyncEngine = (options = {}) => {
       { table, key: changedKeyFor(table, change), row: change.row }
     ]));
     emissions.push(...searchPairs([{ table, change }]));
+    const cursorForBatch = currentCursor();
     for (const [subscription, diff] of emissions) {
-      subscription.onDiff(diff, changeVersion);
+      subscription.onDiff(diff, changeVersion, cursorForBatch);
     }
     if (shouldBroadcast) {
-      broadcast([{ table, change }]);
+      broadcast([{ table, change }], changeVersion);
     }
   };
-  const applyChangeBatch = async (changes, shouldBroadcast = true) => {
+  const applyChangeBatch = async (changes, shouldBroadcast = true, peerOrigin) => {
     if (changes.length === 0) {
       return;
     }
@@ -1985,8 +2019,17 @@ var createSyncEngine = (options = {}) => {
     const perSubscription = new Map;
     const reactiveChanges = [];
     const batchAt = Date.now();
+    const batchOrigin = peerOrigin?.origin ?? instanceId;
+    const batchOriginVersion = peerOrigin?.originVersion ?? batchVersion;
     for (const { table, change } of changes) {
-      logChange(batchVersion, { version: batchVersion, table, change, at: batchAt });
+      logChange(batchVersion, {
+        version: batchVersion,
+        table,
+        change,
+        at: batchAt,
+        origin: batchOrigin,
+        originVersion: batchOriginVersion
+      });
       emitActivity({
         type: "change",
         at: batchAt,
@@ -2018,29 +2061,70 @@ var createSyncEngine = (options = {}) => {
     }
     emissions.push(...await reactivePairs(reactiveChanges));
     emissions.push(...searchPairs(changes));
+    const cursorForBatch = currentCursor();
     for (const [subscription, diff] of emissions) {
-      subscription.onDiff(diff, batchVersion);
+      subscription.onDiff(diff, batchVersion, cursorForBatch);
     }
     if (shouldBroadcast) {
-      broadcast(changes);
+      broadcast(changes, batchVersion);
+    }
+  };
+  const normalizeSince = (since) => {
+    if (typeof since === "number") {
+      return { [instanceId]: since };
     }
+    return decodeCursor(since);
   };
   const canResume = (since, incremental) => {
     if (!incremental) {
       return false;
     }
-    if (since >= version) {
-      return true;
+    const sinceVec = normalizeSince(since);
+    if (sinceVec === null) {
+      return false;
+    }
+    const oldestPerOrigin = new Map;
+    for (const entry of changeLog) {
+      const current = oldestPerOrigin.get(entry.origin);
+      if (current === undefined || entry.originVersion < current) {
+        oldestPerOrigin.set(entry.origin, entry.originVersion);
+      }
+    }
+    const oldestLogVersion = changeLog[0]?.version;
+    for (const [origin, lastSeen] of Object.entries(sinceVec)) {
+      if (origin === instanceId) {
+        if (lastSeen >= version)
+          continue;
+        const oldestLocal = oldestPerOrigin.get(instanceId);
+        if (oldestLocal !== undefined) {
+          if (oldestLocal > lastSeen + 1)
+            return false;
+          continue;
+        }
+        if (oldestLogVersion !== undefined && oldestLogVersion > lastSeen + 1) {
+          return false;
+        }
+      } else {
+        const oldestPeer = oldestPerOrigin.get(origin);
+        if (oldestPeer === undefined) {
+          if (lastSeen > 0)
+            return false;
+        } else if (oldestPeer > lastSeen + 1) {
+          return false;
+        }
+      }
     }
-    const oldest = changeLog[0];
-    return oldest !== undefined && oldest.version <= since + 1;
+    return true;
   };
   const buildCatchup = (since, tables, key, match) => {
+    const sinceVec = normalizeSince(since) ?? {};
     const latest = new Map;
     for (const entry of changeLog) {
-      if (entry.version <= since || !tables.includes(entry.table)) {
+      if (!tables.includes(entry.table))
+        continue;
+      const lastSeen = sinceVec[entry.origin];
+      if (lastSeen !== undefined && entry.originVersion <= lastSeen)
         continue;
-      }
       const row = entry.change.row;
       const present = entry.change.op !== "delete" && match(row) ? "upsert" : "remove";
       latest.set(key(row), { op: present, row });
@@ -2085,6 +2169,7 @@ var createSyncEngine = (options = {}) => {
     set.add(subscription);
     return {
       initial: op.rows(),
+      cursor: currentCursor(),
       version: atVersion,
       unsubscribe: () => {
         set.delete(subscription);
@@ -2111,6 +2196,7 @@ var createSyncEngine = (options = {}) => {
     set.add(subscription);
     return {
       initial,
+      cursor: currentCursor(),
       version: atVersion,
       unsubscribe: () => {
         set.delete(subscription);
@@ -2172,6 +2258,7 @@ var createSyncEngine = (options = {}) => {
     reactiveSubs.add(subscription);
     return {
       initial: first.rows,
+      cursor: currentCursor(),
       version: atVersion,
       unsubscribe: () => {
         set.delete(subscription);
@@ -2216,6 +2303,7 @@ var createSyncEngine = (options = {}) => {
     searchSubs.add(subscription);
     return {
       initial,
+      cursor: currentCursor(),
       version: atVersion,
       unsubscribe: () => {
         set.delete(subscription);
@@ -2317,12 +2405,14 @@ var createSyncEngine = (options = {}) => {
         return wrapReturn({
           initial: [],
           catchup: buildCatchup(since, tables, key, boundMatch),
+          cursor: currentCursor(),
           version: atVersion,
           unsubscribe
         });
       }
       return wrapReturn({
         initial: view.rows(),
+        cursor: currentCursor(),
         version: atVersion,
         unsubscribe
       });
@@ -2361,7 +2451,10 @@ var createSyncEngine = (options = {}) => {
         if (message.origin === instanceId) {
           return;
         }
-        applyChangeBatch(message.changes, false);
+        applyChangeBatch(message.changes, false, {
+          origin: message.origin,
+          originVersion: message.originVersion ?? 0
+        });
       });
       clusterBus = bus;
       return async () => {
@@ -3032,12 +3125,13 @@ var parseFrame = (raw, serializer) => {
   }
   const frame = value;
   if (frame.type === "subscribe") {
+    const since = typeof frame.since === "number" || typeof frame.since === "string" ? frame.since : undefined;
     return typeof frame.id === "string" && typeof frame.collection === "string" ? {
       type: "subscribe",
       id: frame.id,
       collection: frame.collection,
       params: frame.params,
-      since: typeof frame.since === "number" ? frame.since : undefined
+      since
     } : undefined;
   }
   if (frame.type === "unsubscribe") {
@@ -3089,6 +3183,7 @@ var createSyncConnection = ({
   };
   let pending = [];
   let pendingVersion;
+  let pendingCursor;
   let flushScheduled = false;
   const flush = () => {
     if (pending.length === 0) {
@@ -3096,8 +3191,10 @@ var createSyncConnection = ({
     }
     const diffs = pending;
     const version = pendingVersion;
+    const cursor = pendingCursor;
     pending = [];
     pendingVersion = undefined;
+    pendingCursor = undefined;
     if (diffs.length === 1) {
       const only = diffs[0];
       send({
@@ -3106,10 +3203,11 @@ var createSyncConnection = ({
         added: only.added,
         removed: only.removed,
         changed: only.changed,
-        version
+        version,
+        cursor
       });
     } else {
-      send({ type: "frame", diffs, version });
+      send({ type: "frame", diffs, version, cursor });
     }
   };
   const scheduleFlush = () => {
@@ -3122,12 +3220,14 @@ var createSyncConnection = ({
       flush();
     });
   };
-  const bufferDiff = (diff, diffVersion) => {
+  const bufferDiff = (diff, diffVersion, cursor) => {
     if (pending.length > 0 && pendingVersion !== diffVersion) {
       flush();
     }
     pending.push(diff);
     pendingVersion = diffVersion;
+    if (cursor !== undefined)
+      pendingCursor = cursor;
     scheduleFlush();
   };
   const handle = async (raw) => {
@@ -3203,13 +3303,13 @@ var createSyncConnection = ({
         params: frame.params,
         ctx,
         since: frame.since,
-        onDiff: (diff, diffVersion) => {
+        onDiff: (diff, diffVersion, cursor) => {
           bufferDiff({
             id: frame.id,
             added: diff.added,
             removed: diff.removed,
             changed: diff.changed
-          }, diffVersion);
+          }, diffVersion, cursor);
         }
       });
       subscriptions.set(frame.id, subscription);
@@ -3220,14 +3320,16 @@ var createSyncConnection = ({
           added: subscription.catchup.added,
           removed: subscription.catchup.removed,
           changed: subscription.catchup.changed,
-          version: subscription.version
+          version: subscription.version,
+          cursor: subscription.cursor
         });
       } else {
         send({
           type: "snapshot",
           id: frame.id,
           rows: subscription.initial,
-          version: subscription.version
+          version: subscription.version,
+          cursor: subscription.cursor
         });
       }
     } catch (error) {
@@ -3304,5 +3406,5 @@ export {
   CdcConsumerSlowError
 };
 
-//# debugId=2B8B686DC5E953C364756E2164756E21
+//# debugId=83816548811B9BFD64756E2164756E21
 //# sourceMappingURL=index.js.map