@dudousxd/nestjs-durable-core 0.68.0 → 0.69.1

package/dist/index.cjs

@@ -32,6 +32,7 @@ __export(index_exports, {
   DURABLE_STEP_CONFIG: () => DURABLE_STEP_CONFIG,
   DURABLE_STEP_NAME: () => DURABLE_STEP_NAME,
   DurableWorkflow: () => DurableWorkflow,
+  ENGINE_MINTED_TAG_PREFIXES: () => ENGINE_MINTED_TAG_PREFIXES,
   EVENT_BUFFER_SCAN_LIMIT: () => EVENT_BUFFER_SCAN_LIMIT,
   EVENT_TOKEN_PREFIX: () => EVENT_TOKEN_PREFIX,
   Entities: () => Entities,
@@ -98,6 +99,7 @@ __export(index_exports, {
   heartbeatStatus: () => heartbeatStatus,
   indexWaitersByRun: () => indexWaitersByRun,
   info: () => info,
+  isEngineMintedTag: () => isEngineMintedTag,
   isEventToken: () => isEventToken,
   isLegacyDescriptor: () => isLegacyDescriptor,
   isWorkflowControlFlowSignal: () => isWorkflowControlFlowSignal,
@@ -4028,6 +4030,15 @@ var WorkflowEngine = class {
   /**
   * Resume each run only if this instance can acquire its recovery lease — so when several
   * replicas recover or poll at once, each run is picked up by exactly one of them.
+  *
+  * A run this instance cannot resume is SKIPPED, not allowed to abort the batch. The canonical
+  * case is skew protection: mid-rolling-deploy a pod leases a run whose workflow it does not have
+  * and `resume` throws by design — but the rest of the batch is runs it can drive perfectly well,
+  * and every caller here is a recovery sweep. Letting the first such run end the loop means one
+  * row stops recovery for the whole deployment, and (since the callers are pollers) sends the
+  * rejection into a lifecycle hook. Skipping leaves the run locked only until its lease expires,
+  * for a pod that does have the workflow — which is exactly what the skew-protection error asks
+  * for. Same posture as `publishEvent`'s per-subscriber isolation.
   */
   async resumeLeased(runs, nowMs = this.clock(), onLocked) {
     if (this.draining) return [];
@@ -4035,8 +4046,12 @@ var WorkflowEngine = class {
     for (const run of runs) {
       const acquired = await this.store.tryLockRun(run.id, this.instanceId, nowMs + this.leaseMs, nowMs);
       if (!acquired) continue;
-      const settled = onLocked ? await onLocked(run) : void 0;
-      results.push(settled ?? await this.resume(run.id));
+      try {
+        const settled = onLocked ? await onLocked(run) : void 0;
+        results.push(settled ?? await this.resume(run.id));
+      } catch (error2) {
+        console.error(`[nestjs-durable] could not resume run ${run.id} (${run.workflow}@${run.workflowVersion}); leaving it for another instance:`, error2);
+      }
     }
     return results;
   }
@@ -6142,6 +6157,13 @@ __name(mergeRunFacetRows, "mergeRunFacetRows");
 // src/run-value-facets.ts
 var RUN_VALUE_FACET_LIMIT = 100;
 var RUN_VALUE_FACET_SCAN = 5e3;
+var ENGINE_MINTED_TAG_PREFIXES = [
+  "singleton:"
+];
+function isEngineMintedTag(value) {
+  return value !== null && ENGINE_MINTED_TAG_PREFIXES.some((prefix) => value.startsWith(prefix));
+}
+__name(isEngineMintedTag, "isEngineMintedTag");
 function axisIsRunColumn(axis) {
   return axis.field === "workflow" || axis.field === "status" || axis.field === "origin" || axis.field === "namespace";
 }
@@ -6189,6 +6211,9 @@ function mergeRunValueFacetRows(rows, opts) {
     value,
     count
   })).filter((row) => row.count > 0).sort((a, b) => {
+    const engineA = isEngineMintedTag(a.value);
+    const engineB = isEngineMintedTag(b.value);
+    if (engineA !== engineB) return engineA ? 1 : -1;
     if (b.count !== a.count) return b.count - a.count;
     if (a.value === null) return 1;
     if (b.value === null) return -1;
@@ -7117,6 +7142,7 @@ var InMemoryTransport = class {
   DURABLE_STEP_CONFIG,
   DURABLE_STEP_NAME,
   DurableWorkflow,
+  ENGINE_MINTED_TAG_PREFIXES,
   EVENT_BUFFER_SCAN_LIMIT,
   EVENT_TOKEN_PREFIX,
   Entities,
@@ -7183,6 +7209,7 @@ var InMemoryTransport = class {
   heartbeatStatus,
   indexWaitersByRun,
   info,
+  isEngineMintedTag,
   isEventToken,
   isLegacyDescriptor,
   isWorkflowControlFlowSignal,