@rivetkit/workflow-engine 2.1.7 → 2.1.8

package/dist/tsup/{chunk-MMWB37UG.js → chunk-4ME2JBMC.js}

@@ -248,6 +248,13 @@ function parseNameKey(key) {
   }
   return elements[1];
 }
+function parseEntryMetadataKey(key) {
+  const elements = unpack2(key);
+  if (elements.length !== 2 || elements[0] !== KEY_PREFIX.ENTRY_METADATA) {
+    throw new Error("Invalid entry metadata key");
+  }
+  return elements[1];
+}
 function keyStartsWith(key, prefix) {
   if (key.length < prefix.length) {
     return false;
@@ -1472,6 +1479,13 @@ async function loadStorage(driver) {
     const key = locationToKey(storage, parsed.location);
     storage.history.entries.set(key, parsed);
   }
+  const metadataEntries = await driver.list(buildEntryMetadataPrefix());
+  for (const entry of metadataEntries) {
+    const entryId = parseEntryMetadataKey(entry.key);
+    const metadata = deserializeEntryMetadata(entry.value);
+    metadata.dirty = false;
+    storage.entryMetadata.set(entryId, metadata);
+  }
   const stateValue = await driver.get(buildWorkflowStateKey());
   if (stateValue) {
     storage.state = deserializeWorkflowState(stateValue);
@@ -2033,16 +2047,11 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
           retryBackoffMax
         );
         const retryAt = metadata.lastAttemptAt + retryDelay;
-        await this.notifyStepError(
-          config2,
-          metadata.attempts,
-          error,
-          {
-            willRetry: true,
-            retryDelay,
-            retryAt
-          }
-        );
+        await this.notifyStepError(config2, metadata.attempts, error, {
+          willRetry: true,
+          retryDelay,
+          retryAt
+        });
         throw new StepFailedError(
           config2.name,
           error,
@@ -2053,12 +2062,9 @@ var WorkflowContextImpl = class _WorkflowContextImpl {
       const exhaustedError = markErrorReported(
         new StepExhaustedError(config2.name, String(error))
       );
-      await this.notifyStepError(
-        config2,
-        metadata.attempts,
-        error,
-        { willRetry: false }
-      );
+      await this.notifyStepError(config2, metadata.attempts, error, {
+        willRetry: false
+      });
       throw exhaustedError;
     }
   }
@@ -3501,6 +3507,91 @@ function runWorkflow(workflowId, workflowFn, input, driver, options = {}) {
     }
   };
 }
+async function replayWorkflowFromStep(workflowId, driver, entryId, options) {
+  const storage = await loadStorage(driver);
+  const entries = await Promise.all(
+    Array.from(storage.history.entries.entries()).map(
+      async ([key, entry]) => ({
+        key,
+        entry,
+        metadata: await loadMetadata(storage, driver, entry.id)
+      })
+    )
+  );
+  const ordered = [...entries].sort((a, b) => {
+    if (a.metadata.createdAt !== b.metadata.createdAt) {
+      return a.metadata.createdAt - b.metadata.createdAt;
+    }
+    return a.key.localeCompare(b.key);
+  });
+  let entriesToDelete = ordered;
+  if (entryId !== void 0) {
+    const target = entries.find(({ entry }) => entry.id === entryId);
+    if (!target) {
+      throw new Error(`Workflow step not found: ${entryId}`);
+    }
+    if (target.entry.kind.type !== "step") {
+      throw new Error("Workflow replay target must be a step");
+    }
+    const replayBoundary = findReplayBoundaryEntry(entries, target);
+    const targetIndex = ordered.findIndex(
+      ({ entry }) => entry.id === replayBoundary.entry.id
+    );
+    entriesToDelete = ordered.slice(targetIndex);
+  }
+  const entryIdsToDelete = new Set(
+    entriesToDelete.map(({ entry }) => entry.id)
+  );
+  if (entries.some(
+    ({ entry, metadata }) => metadata.status === "running" && !entryIdsToDelete.has(entry.id)
+  )) {
+    throw new Error(
+      "Cannot replay a workflow while a step is currently running"
+    );
+  }
+  await Promise.all(
+    entriesToDelete.flatMap(({ entry }) => [
+      driver.delete(buildHistoryKey(entry.location)),
+      driver.delete(buildEntryMetadataKey(entry.id))
+    ])
+  );
+  for (const { key, entry } of entriesToDelete) {
+    storage.history.entries.delete(key);
+    storage.entryMetadata.delete(entry.id);
+  }
+  storage.output = void 0;
+  storage.flushedOutput = void 0;
+  storage.error = void 0;
+  storage.flushedError = void 0;
+  storage.state = "sleeping";
+  storage.flushedState = "sleeping";
+  await Promise.all([
+    driver.delete(buildWorkflowOutputKey()),
+    driver.delete(buildWorkflowErrorKey()),
+    driver.set(buildWorkflowStateKey(), serializeWorkflowState("sleeping"))
+  ]);
+  if ((options == null ? void 0 : options.scheduleAlarm) ?? true) {
+    await driver.setAlarm(workflowId, Date.now());
+  }
+  return createHistorySnapshot(storage);
+}
+function findReplayBoundaryEntry(entries, target) {
+  let boundary = target;
+  let boundaryDepth = -1;
+  for (const candidate of entries) {
+    if (candidate.entry.kind.type !== "loop") {
+      continue;
+    }
+    if (candidate.entry.location.length >= target.entry.location.length || !isLocationPrefix(candidate.entry.location, target.entry.location)) {
+      continue;
+    }
+    if (candidate.entry.location.length > boundaryDepth) {
+      boundary = candidate;
+      boundaryDepth = candidate.entry.location.length;
+    }
+  }
+  return boundary;
+}
 async function executeWorkflow(workflowId, workflowFn, input, driver, messageDriver, abortController, onHistoryUpdated, onError, logger) {
   var _a;
   const storage = await loadStorage(driver);
@@ -3711,6 +3802,7 @@ export {
   DEFAULT_STEP_TIMEOUT,
   WorkflowContextImpl,
   Loop,
-  runWorkflow
+  runWorkflow,
+  replayWorkflowFromStep
 };
-//# sourceMappingURL=chunk-MMWB37UG.js.map
+//# sourceMappingURL=chunk-4ME2JBMC.js.map