@absolutejs/sync 1.18.2 → 1.20.0

package/dist/engine/syncEngine.d.ts

@@ -266,6 +266,36 @@ export type SyncEngine = {
      * Added in 1.13.0.
      */
     metrics: () => EngineMetrics;
+    /**
+     * Capture the engine's change log + version as a serializable
+     * {@link ChangeLogSnapshot} the host can persist (disk, S3, the cluster
+     * bus) and restore on the next boot via
+     * {@link SyncEngineOptions.initialChangeLog} or
+     * {@link SyncEngine.importChangeLog}. The receiving engine MUST share this
+     * engine's `instanceId` — otherwise the resume contract silently breaks.
+     *
+     * Cheap: the snapshot's `entries` is a shallow copy of the bounded log
+     * (capped by `changeLogSize` / `changeLogRetainMs`). Call on a timer or on
+     * graceful shutdown — both are fine; the snapshot is monotonic in commit
+     * order, so a partial roll-forward (apply entries newer than the snapshot
+     * from another source) is safe.
+     *
+     * Added in 1.19.0.
+     */
+    exportChangeLog: () => ChangeLogSnapshot;
+    /**
+     * Adopt a {@link ChangeLogSnapshot} into a running engine that has not yet
+     * committed any local changes (its `version` is 0). The snapshot's
+     * `instanceId` MUST match this engine's `instanceId`. Throws otherwise.
+     *
+     * Convenience for hosts that want to set up the engine, register surfaces,
+     * AND THEN restore. Equivalent to passing the snapshot via
+     * `createSyncEngine({ initialChangeLog })` if you have it at construction
+     * time. Returns the number of entries imported.
+     *
+     * Added in 1.19.0.
+     */
+    importChangeLog: (snapshot: ChangeLogSnapshot) => number;
     /**
      * Subscribe to the live engine activity stream (changes, mutation outcomes,
      * subscribe/unsubscribe). Returns an unsubscribe. Powers the devtools feed.
@@ -384,6 +414,46 @@ export declare class CdcConsumerSlowError extends Error {
     readonly lastDeliveredVersion: number;
     constructor(maxBuffer: number, lastDeliveredVersion: number);
 }
+/**
+ * Thrown by `runMutation` / `runMutations` when `mutationConcurrency` is
+ * saturated AND the waiting queue is already at `mutationQueueLimit`. The
+ * caller sees this immediately (no queue time) so the host can shed load
+ * with a clean 429 instead of letting the queue grow unboundedly. Added
+ * in 1.20.0.
+ */
+export declare class MutationQueueOverflowError extends Error {
+    readonly queueLimit: number;
+    constructor(queueLimit: number);
+}
+/**
+ * Serializable snapshot of an engine's change log + monotonic version, returned
+ * by {@link SyncEngine.exportChangeLog} and consumed by
+ * {@link SyncEngineOptions.initialChangeLog} or
+ * {@link SyncEngine.importChangeLog}.
+ *
+ * The PaaS host persists this on shard rotation (every N seconds or on graceful
+ * shutdown) and hands it back to the replacement engine so resume cursors
+ * referencing this `instanceId` keep working past the restart. Bounded by the
+ * receiving engine's `changeLogSize` + `changeLogRetainMs` policies — entries
+ * that exceed either cap on import are trimmed exactly as if they had been
+ * logged live.
+ *
+ * Added in 1.19.0.
+ */
+export type ChangeLogSnapshot = {
+    /** The exporting engine's `instanceId`. Receiver MUST match. */
+    instanceId: string;
+    /** The exporting engine's monotonic version at snapshot time. */
+    version: number;
+    /** Every retained log entry, in commit order (oldest first). */
+    entries: ReadonlyArray<LoggedChange>;
+    /**
+     * Optional version-stamp the host may use to compare snapshots without
+     * deserializing the entries (e.g. for incremental persistence). Set to
+     * `Date.now()` at export time. Receivers ignore this field.
+     */
+    exportedAt?: number;
+};
 export type SyncEngineOptions = {
     /**
      * Stable identifier for this engine instance. Defaults to a per-process
@@ -482,6 +552,51 @@ export type SyncEngineOptions = {
      * @see {@link BridgeFetchConfig}
      */
     bridgeFetch?: BridgeFetchConfig;
+    /**
+     * Seed the engine's change log on boot from a prior snapshot — produced by
+     * {@link SyncEngine.exportChangeLog} on the previous instance, persisted by
+     * the host across a shard reboot, then handed back here. Cursors that
+     * referenced this engine's `instanceId` stay resumable past the restart
+     * (provided their last-seen point still lives in the retained log).
+     *
+     * The snapshot's `instanceId` MUST match `options.instanceId` (otherwise
+     * `createSyncEngine` throws — a wrong-id restore would silently break the
+     * resume contract). Snapshot `version` becomes this engine's local
+     * monotonic version; entries are inserted in version order. Subscribers,
+     * permissions, schemas, schedules, packs, mutations, and the reactive
+     * cache are NOT in the snapshot — re-register them as normal after
+     * `createSyncEngine` returns. Added in 1.19.0.
+     */
+    initialChangeLog?: ChangeLogSnapshot;
+    /**
+     * Maximum concurrent in-flight mutations (`runMutation` + `runMutations`).
+     * Calls beyond the limit wait in a FIFO queue and run as slots free up;
+     * `engine.metrics().mutations.queued` surfaces the queue depth.
+     *
+     * A single tenant flooding `runMutation` can otherwise drive unbounded
+     * memory growth (per-mutation `actions` buffers, retry timers, sandbox
+     * invocations queued against the isolate pool). Set this to a value
+     * appropriate for the host's tenant tier — e.g. `32` for a free tier,
+     * `256` for paid. Without this option the engine is unbounded
+     * (matching pre-1.20 behavior).
+     *
+     * Sandboxed mutations are gated by the same semaphore. If you need
+     * finer-grained control (sandbox-only throttling), see
+     * `@absolutejs/isolated-jsc`'s pool size — that's the lower layer.
+     *
+     * Added in 1.20.0.
+     */
+    mutationConcurrency?: number;
+    /**
+     * Cap on the queue of waiting mutations once `mutationConcurrency` is
+     * saturated. Calls beyond this cap throw {@link MutationQueueOverflowError}
+     * immediately instead of queueing — the host can surface a clean 429 or
+     * apply a tenant-specific shed policy. Defaults to unbounded (queue
+     * never rejects). Only meaningful when `mutationConcurrency` is set.
+     *
+     * Added in 1.20.0.
+     */
+    mutationQueueLimit?: number;
 };
 /**
  * The Tier 3 sync engine: a registry of collections plus the view syncer. It is

package/dist/index.js

@@ -1152,6 +1152,15 @@ class CdcConsumerSlowError extends Error {
     this.lastDeliveredVersion = lastDeliveredVersion;
   }
 }
+
+class MutationQueueOverflowError extends Error {
+  queueLimit;
+  constructor(queueLimit) {
+    super(`Mutation queue overflowed (limit ${queueLimit}); the engine is at ` + `its mutationConcurrency cap and the waiting queue is full. ` + `Retry later or shed load at the gateway.`);
+    this.name = "MutationQueueOverflowError";
+    this.queueLimit = queueLimit;
+  }
+}
 var defaultKey = (row) => row.id;
 var shallowEqual3 = (a, b) => {
   if (a === b) {
@@ -1268,6 +1277,40 @@ var createSyncEngine = (options = {}) => {
   let mutationsFailed = 0;
   let mutationsRetried = 0;
   let mutationsInFlight = 0;
+  const mutationWaiters = [];
+  let mutationsQueued = 0;
+  const acquireMutationSlot = async () => {
+    const limit = options.mutationConcurrency;
+    if (limit === undefined) {
+      mutationsInFlight += 1;
+      return;
+    }
+    if (mutationsInFlight < limit && mutationWaiters.length === 0) {
+      mutationsInFlight += 1;
+      return;
+    }
+    const queueLimit = options.mutationQueueLimit;
+    if (queueLimit !== undefined && mutationsQueued >= queueLimit) {
+      throw new MutationQueueOverflowError(queueLimit);
+    }
+    mutationsQueued += 1;
+    try {
+      await new Promise((resolve) => {
+        mutationWaiters.push(resolve);
+      });
+    } finally {
+      mutationsQueued -= 1;
+    }
+    mutationsInFlight += 1;
+  };
+  const releaseMutationSlot = () => {
+    mutationsInFlight -= 1;
+    if (options.mutationConcurrency === undefined)
+      return;
+    const next = mutationWaiters.shift();
+    if (next !== undefined)
+      next();
+  };
   const reactiveCacheMax = options.reactiveCache?.max ?? 256;
   const reactiveCacheTtlMs = options.reactiveCache?.ttlMs ?? 60000;
   const cachedReruns = new Map;
@@ -1309,6 +1352,31 @@ var createSyncEngine = (options = {}) => {
   const runInTransaction = options.transaction;
   const instanceId = options.instanceId ?? globalThis.crypto?.randomUUID?.() ?? `i${Math.random()}`;
   let clusterBus;
+  const importChangeLog = (snapshot) => {
+    if (version !== 0) {
+      throw new Error(`[sync] importChangeLog: engine already has version ${version}; ` + `restore must happen before any local writes commit.`);
+    }
+    if (snapshot.instanceId !== instanceId) {
+      throw new Error(`[sync] importChangeLog: snapshot instanceId "${snapshot.instanceId}" ` + `does not match this engine's instanceId "${instanceId}". ` + `Pass options.instanceId = "${snapshot.instanceId}" to createSyncEngine.`);
+    }
+    version = snapshot.version;
+    for (const entry of snapshot.entries) {
+      changeLog.push(entry);
+    }
+    while (changeLog.length > changeLogSize) {
+      changeLog.shift();
+    }
+    if (changeLogRetainMs !== null && changeLogRetainMs > 0) {
+      const cutoff = Date.now() - changeLogRetainMs;
+      while (changeLog.length > 0 && changeLog[0].at < cutoff) {
+        changeLog.shift();
+      }
+    }
+    return snapshot.entries.length;
+  };
+  if (options.initialChangeLog !== undefined) {
+    importChangeLog(options.initialChangeLog);
+  }
   const broadcast = (changes, originVersion) => {
     if (clusterBus !== undefined && changes.length > 0) {
       clusterBus.publish({ changes, origin: instanceId, originVersion });
@@ -2270,6 +2338,7 @@ var createSyncEngine = (options = {}) => {
           throw new UnauthorizedError(`run mutation "${name}"`);
         }
       }
+      await acquireMutationSlot();
       const sandboxRunner = sandboxRunners.get(name);
       const invokeHandler = sandboxRunner !== undefined ? sandboxRunner : (a, c, actions) => Promise.resolve(mutation.handler(a, c, actions));
       const runHandler = async (tx) => {
@@ -2285,7 +2354,6 @@ var createSyncEngine = (options = {}) => {
       const startedAt = Date.now();
       let lastError;
       let attemptsMade = 0;
-      mutationsInFlight += 1;
       try {
         for (let attempt = 1;attempt <= maxAttempts; attempt++) {
           attemptsMade = attempt;
@@ -2338,7 +2406,7 @@ var createSyncEngine = (options = {}) => {
         }
         throw lastError;
       } finally {
-        mutationsInFlight -= 1;
+        releaseMutationSlot();
       }
     },
     runMutations: async (specs, ctx) => {
@@ -2351,6 +2419,7 @@ var createSyncEngine = (options = {}) => {
         }
         return { args: spec.args, mutation, name: spec.name };
       });
+      await acquireMutationSlot();
       const runBatch = async (tx) => {
         const results = [];
         const accumulated = [];
@@ -2388,6 +2457,8 @@ var createSyncEngine = (options = {}) => {
           status: "error"
         });
         throw error;
+      } finally {
+        releaseMutationSlot();
       }
     },
     registerSchedule: (schedule) => {
@@ -2578,6 +2649,13 @@ var createSyncEngine = (options = {}) => {
         }))
       };
     },
+    exportChangeLog: () => ({
+      entries: changeLog.slice(),
+      exportedAt: Date.now(),
+      instanceId,
+      version
+    }),
+    importChangeLog,
     metrics: () => {
       const now = Date.now();
       const byCollection = {};
@@ -2600,6 +2678,7 @@ var createSyncEngine = (options = {}) => {
           completed: mutationsCompleted,
           failed: mutationsFailed,
           inFlight: mutationsInFlight,
+          queued: mutationsQueued,
           retried: mutationsRetried
         },
         reactiveCache: {
@@ -2993,5 +3072,5 @@ export {
   createPresenceHub
 };
 
-//# debugId=34EB2D2EE376D7EC64756E2164756E21
+//# debugId=9DD57DF563EB9CB564756E2164756E21
 //# sourceMappingURL=index.js.map