@absolutejs/sync 1.4.0 → 1.6.0

package/dist/engine/index.js

@@ -569,6 +569,7 @@ var createPollingChangeSource = (options) => {
   const onError = options.onError ?? ((error) => {
     console.warn("[sync] polling change source error:", error);
   });
+  const onSkip = options.onSkip;
   let cursor = options.startSeq ?? 0;
   let running = false;
   let timer;
@@ -580,7 +581,9 @@ var createPollingChangeSource = (options) => {
       const rows = await options.poll(cursor);
       for (const row of rows) {
         const parsed = parse(row);
-        if (parsed !== undefined) {
+        if (parsed === undefined) {
+          onSkip?.(row, "parse-failed");
+        } else {
           await emit(parsed.table, parsed.change);
         }
         if (typeof row.seq === "number" && row.seq > cursor) {
@@ -1041,6 +1044,42 @@ var createVectorIndex = (options) => {
 var defineSchedule = (definition) => definition;
 // src/engine/mutation.ts
 var defineMutation = (definition) => definition;
+// src/engine/retry.ts
+var PG_RETRY_CODES = new Set(["40001", "40P01"]);
+var isSerializationFailure = (error) => {
+  if (error === null || typeof error !== "object")
+    return false;
+  const code = error.code;
+  if (typeof code === "string" && PG_RETRY_CODES.has(code))
+    return true;
+  const cause = error.cause;
+  if (cause !== undefined)
+    return isSerializationFailure(cause);
+  return false;
+};
+var exponentialBackoff = (options = {}) => (attempt) => {
+  const base = options.baseMs ?? 25;
+  const factor = options.factor ?? 2;
+  const max = options.maxMs ?? 1000;
+  const jitter = options.jitter ?? 0.2;
+  const raw = Math.min(max, base * factor ** Math.max(0, attempt - 1));
+  const spread = raw * jitter;
+  return raw + (Math.random() * 2 - 1) * spread;
+};
+
+class RetriesExhaustedError extends Error {
+  attempts;
+  elapsedMs;
+  cause;
+  constructor(attempts, elapsedMs, cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    super(`retries exhausted after ${attempts} attempts (${elapsedMs}ms): ${message}`);
+    this.name = "RetriesExhaustedError";
+    this.attempts = attempts;
+    this.elapsedMs = elapsedMs;
+    this.cause = cause;
+  }
+}
 // src/engine/sandbox.ts
 var isolatedJscModule;
 var loadIsolatedJsc = async () => {
@@ -1125,6 +1164,28 @@ class SchemaError extends Error {
     this.name = "SchemaError";
   }
 }
+
+class MissedChangesError extends Error {
+  requestedSince;
+  availableSince;
+  constructor(requestedSince, availableSince) {
+    super(`Change log no longer covers version ${requestedSince}; oldest available is ${availableSince}. ` + `Re-bootstrap and resume from ${availableSince}.`);
+    this.name = "MissedChangesError";
+    this.requestedSince = requestedSince;
+    this.availableSince = availableSince;
+  }
+}
+
+class CdcConsumerSlowError extends Error {
+  maxBuffer;
+  lastDeliveredVersion;
+  constructor(maxBuffer, lastDeliveredVersion) {
+    super(`CDC stream buffer overflowed (max ${maxBuffer}); consumer fell behind. ` + `Last delivered version: ${lastDeliveredVersion}. Resubscribe with since=${lastDeliveredVersion}.`);
+    this.name = "CdcConsumerSlowError";
+    this.maxBuffer = maxBuffer;
+    this.lastDeliveredVersion = lastDeliveredVersion;
+  }
+}
 var defaultKey = (row) => row.id;
 var shallowEqual4 = (a, b) => {
   if (a === b) {
@@ -1270,6 +1331,7 @@ var createSyncEngine = (options = {}) => {
       listener(event);
     }
   };
+  const streamSubscribers = new Set;
   const runInTransaction = options.transaction;
   const instanceId = globalThis.crypto?.randomUUID?.() ?? `i${Math.random()}`;
   let clusterBus;
@@ -1641,6 +1703,9 @@ var createSyncEngine = (options = {}) => {
     if (changeLog.length > changeLogSize) {
       changeLog.shift();
     }
+    for (const subscriber of streamSubscribers) {
+      subscriber(entry);
+    }
   };
   const applyChange = async (table, change, shouldBroadcast = true) => {
     version += 1;
@@ -2120,25 +2185,61 @@ var createSyncEngine = (options = {}) => {
         const result = await invokeHandler(args, ctx, actions);
         return { buffered, result };
       };
-      try {
-        const { buffered, result } = runInTransaction !== undefined ? await runInTransaction((tx) => runHandler(tx)) : await runHandler(undefined);
-        await applyChangeBatch(buffered);
-        emitActivity({
-          type: "mutation",
-          at: Date.now(),
-          name,
-          status: "ok"
-        });
-        return result;
-      } catch (error) {
-        emitActivity({
-          type: "mutation",
-          at: Date.now(),
-          name,
-          status: "error"
-        });
-        throw error;
+      const retry = mutation.retry;
+      const maxAttempts = retry === undefined ? 1 : retry.maxAttempts ?? 5;
+      const isRetryable = retry?.isRetryable ?? isSerializationFailure;
+      const computeDelay = retry?.backoff ?? exponentialBackoff();
+      const maxElapsedMs = retry?.maxElapsedMs ?? 30000;
+      const startedAt = Date.now();
+      let lastError;
+      let attemptsMade = 0;
+      for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+        attemptsMade = attempt;
+        try {
+          const { buffered, result } = runInTransaction !== undefined ? await runInTransaction((tx) => runHandler(tx)) : await runHandler(undefined);
+          await applyChangeBatch(buffered);
+          emitActivity({
+            type: "mutation",
+            at: Date.now(),
+            name,
+            status: "ok"
+          });
+          return result;
+        } catch (error) {
+          lastError = error;
+          const elapsedMs = Date.now() - startedAt;
+          const canRetry = attempt < maxAttempts && isRetryable(error) && elapsedMs < maxElapsedMs;
+          if (!canRetry)
+            break;
+          const rawDelay = computeDelay(attempt);
+          const remaining = maxElapsedMs - elapsedMs;
+          if (remaining <= 0)
+            break;
+          const delayMs = Math.max(0, Math.min(rawDelay, remaining));
+          emitActivity({
+            type: "mutationRetry",
+            at: Date.now(),
+            name,
+            attempt,
+            delayMs,
+            errorName: error instanceof Error ? error.name : "Error",
+            errorMessage: error instanceof Error ? error.message : String(error)
+          });
+          if (delayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+          }
+        }
+      }
+      emitActivity({
+        type: "mutation",
+        at: Date.now(),
+        name,
+        status: "error"
+      });
+      if (attemptsMade > 1) {
+        throw new RetriesExhaustedError(attemptsMade, Date.now() - startedAt, lastError);
       }
+      throw lastError;
     },
     registerSchedule: (schedule) => {
       schedules.set(schedule.name, schedule);
@@ -2204,9 +2305,170 @@ var createSyncEngine = (options = {}) => {
       return () => {
         activityListeners.delete(listener);
       };
+    },
+    streamChanges: ({
+      since = 0,
+      signal,
+      maxBuffer = 1e4
+    } = {}) => {
+      const oldest = changeLog[0];
+      if (since > 0 && oldest !== undefined && oldest.version > since + 1) {
+        const err = new MissedChangesError(since, oldest.version);
+        return {
+          [Symbol.asyncIterator]() {
+            return {
+              next: () => Promise.reject(err)
+            };
+          }
+        };
+      }
+      const buffer = [];
+      let waiter = null;
+      let overflow = false;
+      const wake = () => {
+        if (waiter !== null) {
+          const resume = waiter;
+          waiter = null;
+          resume();
+        }
+      };
+      const subscriber = (entry) => {
+        if (buffer.length >= maxBuffer) {
+          overflow = true;
+          wake();
+          return;
+        }
+        buffer.push(entry);
+        wake();
+      };
+      streamSubscribers.add(subscriber);
+      const onAbort = () => wake();
+      signal?.addEventListener("abort", onAbort, { once: true });
+      let lastDelivered = since;
+      return {
+        async* [Symbol.asyncIterator]() {
+          try {
+            const history = [...changeLog];
+            const headVersion = history.length > 0 ? history[history.length - 1].version : since;
+            for (const entry of history) {
+              if (signal?.aborted)
+                return;
+              if (entry.version > since) {
+                lastDelivered = entry.version;
+                yield entry;
+              }
+            }
+            while (!signal?.aborted) {
+              while (buffer.length > 0) {
+                const entry = buffer.shift();
+                if (entry.version > headVersion) {
+                  lastDelivered = entry.version;
+                  yield entry;
+                }
+              }
+              if (overflow) {
+                throw new CdcConsumerSlowError(maxBuffer, lastDelivered);
+              }
+              if (signal?.aborted)
+                return;
+              await new Promise((resolve) => {
+                waiter = resolve;
+              });
+            }
+          } finally {
+            streamSubscribers.delete(subscriber);
+            signal?.removeEventListener("abort", onAbort);
+          }
+        }
+      };
     }
   };
 };
+// src/engine/cdc.ts
+import { Elysia } from "elysia";
+var parseSince = (query2, lastEventId) => {
+  const raw = query2.since ?? lastEventId ?? "0";
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : 0;
+};
+var encodeEvent = (event, id, data) => {
+  const parts = [];
+  if (id !== null)
+    parts.push(`id: ${id}`);
+  parts.push(`event: ${event}`);
+  parts.push(`data: ${JSON.stringify(data)}`);
+  return `${parts.join(`
+`)}
+
+`;
+};
+var syncCdc = ({
+  engine,
+  path = "/sync/cdc",
+  heartbeatMs = 25000,
+  maxBuffer = 1e4
+}) => new Elysia({ name: "@absolutejs/sync/cdc" }).get(path, (context) => {
+  const lastEventId = context.request.headers.get("last-event-id");
+  const since = parseSince(context.query, lastEventId);
+  const encoder = new TextEncoder;
+  const stream = new ReadableStream({
+    async start(controller) {
+      const write = (chunk) => {
+        try {
+          controller.enqueue(encoder.encode(chunk));
+        } catch {}
+      };
+      write(encodeEvent("open", null, {
+        since,
+        at: Date.now()
+      }));
+      const heartbeat = setInterval(() => write(`: ping
+
+`), heartbeatMs);
+      try {
+        for await (const entry of engine.streamChanges({
+          since,
+          signal: context.request.signal,
+          maxBuffer
+        })) {
+          write(encodeEvent("change", entry.version, entry));
+        }
+      } catch (error) {
+        if (error instanceof MissedChangesError) {
+          write(encodeEvent("error", null, {
+            name: "MissedChangesError",
+            message: error.message,
+            requestedSince: error.requestedSince,
+            availableSince: error.availableSince
+          }));
+        } else if (error instanceof CdcConsumerSlowError) {
+          write(encodeEvent("error", null, {
+            name: "CdcConsumerSlowError",
+            message: error.message,
+            lastDeliveredVersion: error.lastDeliveredVersion
+          }));
+        } else {
+          write(encodeEvent("error", null, {
+            name: error instanceof Error ? error.name : "Error",
+            message: error instanceof Error ? error.message : String(error)
+          }));
+        }
+      } finally {
+        clearInterval(heartbeat);
+        try {
+          controller.close();
+        } catch {}
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "cache-control": "no-cache, no-transform",
+      connection: "keep-alive",
+      "content-type": "text/event-stream"
+    }
+  });
+});
 // src/engine/schema.ts
 var defineSchema = (schemas) => schemas;
 var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
@@ -2455,6 +2717,7 @@ var createSyncConnection = ({
   return { handle, close };
 };
 export {
+  syncCdc,
   query,
   parseOutboxRow,
   orderByOp,
@@ -2462,11 +2725,13 @@ export {
   materialize,
   mapOp,
   joinNode,
+  isSerializationFailure,
   isEmptyViewDiff,
   hydrateRoute,
   fromRowChange,
   filterOp,
   field,
+  exponentialBackoff,
   defineSearchCollection,
   defineSchema,
   defineSchedule,
@@ -2490,8 +2755,11 @@ export {
   aggregateOp,
   UnauthorizedError,
   SchemaError,
-  SEARCH_SCORE_FIELD
+  SEARCH_SCORE_FIELD,
+  RetriesExhaustedError,
+  MissedChangesError,
+  CdcConsumerSlowError
 };
 
-//# debugId=03508BC44A5CF91064756E2164756E21
+//# debugId=3FBF66DA7F03006864756E2164756E21
 //# sourceMappingURL=index.js.map