@dudousxd/nestjs-durable-testing 0.20.0 → 0.21.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { AdmissionBackend, StateStore, RunStatus, WorkflowEngine, InMemoryStateStore, InMemoryTransport, RunResult, WorkflowRef, StartOptions, WorkflowRun, StepCheckpoint, Transport } from '@dudousxd/nestjs-durable-core';
+export { RUN_HISTORY_FIXTURE_VERSION } from '@dudousxd/nestjs-durable-core';
 
 /**
  * Builds an {@link AdmissionBackend} bound to the given test clock. Implementations that hold their
@@ -184,6 +185,34 @@ interface RunHistory {
     run: WorkflowRun;
     checkpoints: StepCheckpoint[];
 }
+
+/**
+ * Capture a run's replayable history (the run row + its full checkpoint timeline) from anything with
+ * the read API: a `WorkflowEngine`, or a bare `StateStore` (the CLI's `durable export` uses the
+ * store). The fixture half of the {@link assertReplayable} loop: capture a representative run,
+ * commit it with {@link serializeRunHistory}, and assert it in CI via {@link parseRunHistory}.
+ * Returns `null` for an unknown run.
+ */
+declare function captureHistory(source: {
+    getRun(runId: string): Promise<WorkflowRun | null | undefined>;
+    listCheckpoints(runId: string): Promise<StepCheckpoint[]>;
+}, runId: string): Promise<RunHistory | null>;
+/**
+ * Serialize a captured history as a pretty-printed JSON fixture (with a trailing newline, so it
+ * commits cleanly). Read it back with {@link parseRunHistory}.
+ */
+declare function serializeRunHistory(history: RunHistory): string;
+/**
+ * Parse a committed fixture (what {@link serializeRunHistory} / `durable export` writes) back into a
+ * {@link RunHistory}, reviving the `Date` fields JSON flattened to ISO strings, so
+ * `assertReplayable(register, parseRunHistory(readFileSync('fixture.json', 'utf8')))` just works.
+ *
+ * Throws on a fixture whose `version` is not {@link RUN_HISTORY_FIXTURE_VERSION}: a fixture written
+ * in another format would otherwise replay against the wrong shape. A fixture with NO `version` (a
+ * hand-built `{ run, checkpoints }`, the shape these docs showed before the marker existed) is read
+ * as version 1.
+ */
+declare function parseRunHistory(json: string): RunHistory;
 /**
  * Replay a recorded run's history against the CURRENT workflow code and throw if they diverged.
  *
@@ -288,4 +317,4 @@ declare function aggregationFixture(): StepCheckpoint[];
  */
 declare function registerCheckpointAggregationCases(t: (label: string, fn: () => Promise<void>) => void, getStore: () => StateStore, run: (over?: Partial<WorkflowRun>) => WorkflowRun): void;
 
-export { type AdmissionBackendFactory, DURABLE_CANONICAL_COLUMNS, type DurableColumnMap, type DurableColumnMismatch, type HandleableTransport, MutableClock, type RunHistory, type StateStoreContext, type StateStoreFactory, StateStoreUnavailableError, type TestEngine, aggregationFixture, assertDurableColumns, assertOutput, assertReplayable, assertRunStatus, assertStepAttempts, assertStepsRan, assertTransportConformance, createTestEngine, failOnce, failTimes, preserveColumnExpectation, recordedSteps, registerCheckpointAggregationCases, runAdmissionBackendContract, runStateStoreContract };
+export { type AdmissionBackendFactory, DURABLE_CANONICAL_COLUMNS, type DurableColumnMap, type DurableColumnMismatch, type HandleableTransport, MutableClock, type RunHistory, type StateStoreContext, type StateStoreFactory, StateStoreUnavailableError, type TestEngine, aggregationFixture, assertDurableColumns, assertOutput, assertReplayable, assertRunStatus, assertStepAttempts, assertStepsRan, assertTransportConformance, captureHistory, createTestEngine, failOnce, failTimes, parseRunHistory, preserveColumnExpectation, recordedSteps, registerCheckpointAggregationCases, runAdmissionBackendContract, runStateStoreContract, serializeRunHistory };

package/dist/index.js

@@ -375,7 +375,50 @@ function createTestEngine() {
 __name(createTestEngine, "createTestEngine");
 
 // src/replay.ts
-import { InMemoryStateStore as InMemoryStateStore2, WorkflowEngine as WorkflowEngine2 } from "@dudousxd/nestjs-durable-core";
+import { InMemoryStateStore as InMemoryStateStore2, RUN_HISTORY_FIXTURE_VERSION, WorkflowEngine as WorkflowEngine2 } from "@dudousxd/nestjs-durable-core";
+async function captureHistory(source, runId) {
+  const run2 = await source.getRun(runId);
+  if (!run2) return null;
+  return {
+    run: run2,
+    checkpoints: await source.listCheckpoints(runId)
+  };
+}
+__name(captureHistory, "captureHistory");
+function serializeRunHistory(history) {
+  return `${JSON.stringify({
+    version: RUN_HISTORY_FIXTURE_VERSION,
+    ...history
+  }, null, 2)}
+`;
+}
+__name(serializeRunHistory, "serializeRunHistory");
+function parseRunHistory(json) {
+  const raw = JSON.parse(json);
+  if (!raw || typeof raw !== "object" || !raw.run || !Array.isArray(raw.checkpoints)) {
+    throw new Error("not a run history fixture: expected { run, checkpoints }");
+  }
+  if (raw.version !== void 0 && raw.version !== RUN_HISTORY_FIXTURE_VERSION) {
+    throw new Error(`unsupported run history fixture version ${JSON.stringify(raw.version)} (this kit reads version ${RUN_HISTORY_FIXTURE_VERSION}); re-export the fixture or upgrade @dudousxd/nestjs-durable-testing`);
+  }
+  const date = /* @__PURE__ */ __name((v) => new Date(v), "date");
+  const run2 = {
+    ...raw.run,
+    createdAt: date(raw.run.createdAt),
+    updatedAt: date(raw.run.updatedAt)
+  };
+  const checkpoints = raw.checkpoints.map((cp2) => ({
+    ...cp2,
+    enqueuedAt: date(cp2.enqueuedAt),
+    startedAt: date(cp2.startedAt),
+    finishedAt: date(cp2.finishedAt)
+  }));
+  return {
+    run: run2,
+    checkpoints
+  };
+}
+__name(parseRunHistory, "parseRunHistory");
 async function assertReplayable(register, history) {
   const store = new InMemoryStateStore2();
   await store.createRun({
@@ -2314,6 +2357,18 @@ function runStateStoreContract(name, makeStore) {
       await store.releaseRunLock("r1");
       expect3(await store.tryLockRun("r1", "C", 9e3, 2600)).toBe(true);
     });
+    t("releaseRunLock with an owner clears only a lease that owner still holds", async () => {
+      await store.createRun(run({
+        id: "r1"
+      }));
+      expect3(await store.tryLockRun("r1", "A", 2e3, 1e3)).toBe(true);
+      expect3(await store.tryLockRun("r1", "B", 4e3, 2500)).toBe(true);
+      await store.releaseRunLock("r1", "A");
+      expect3(await store.tryLockRun("r1", "C", 9e3, 3e3)).toBe(false);
+      expect3((await store.getRun("r1"))?.lockedBy).toBe("B");
+      await store.releaseRunLock("r1", "B");
+      expect3(await store.tryLockRun("r1", "C", 9e3, 3e3)).toBe(true);
+    });
     t("renewRunLock only succeeds for the current owner", async () => {
       await store.createRun(run({
         id: "r1"
@@ -4239,6 +4294,7 @@ __name(assertTransportConformance, "assertTransportConformance");
 export {
   DURABLE_CANONICAL_COLUMNS,
   MutableClock,
+  RUN_HISTORY_FIXTURE_VERSION,
   StateStoreUnavailableError,
   aggregationFixture,
   assertDurableColumns,
@@ -4248,13 +4304,16 @@ export {
   assertStepAttempts,
   assertStepsRan,
   assertTransportConformance,
+  captureHistory,
   createTestEngine,
   failOnce,
   failTimes,
+  parseRunHistory,
   preserveColumnExpectation,
   recordedSteps,
   registerCheckpointAggregationCases,
   runAdmissionBackendContract,
-  runStateStoreContract
+  runStateStoreContract,
+  serializeRunHistory
 };
 //# sourceMappingURL=index.js.map