@sonamu-kit/tasks 0.1.3 → 0.2.0

package/src/execution.test.ts

@@ -505,6 +505,121 @@ describe("executeWorkflow", () => {
   });
 });
 
+describe("executeWorkflow with dynamic retryPolicy", () => {
+  let backend: BackendPostgres;
+
+  beforeAll(async () => {
+    backend = new BackendPostgres(KNEX_GLOBAL_CONFIG, {
+      namespaceId: randomUUID(),
+      runMigrations: false,
+    });
+    await backend.initialize();
+  });
+
+  afterAll(async () => {
+    await backend.stop();
+  });
+
+  test("calls failWorkflowRun with forceComplete=true when shouldRetry returns false", async () => {
+    const client = new OpenWorkflow({ backend });
+
+    // shouldRetry가 false를 반환하는 retryPolicy
+    const workflow = client.defineWorkflow(
+      {
+        name: "dynamic-retry-false",
+        retryPolicy: {
+          maxAttempts: 10, // 정적으로는 10번까지 허용하지만
+          shouldRetry: () => ({ shouldRetry: false, delayMs: 0 }), // 동적으로 즉시 거부
+        },
+      },
+      () => {
+        throw new Error("Intentional failure");
+      },
+    );
+
+    const worker = client.newWorker();
+    const handle = await workflow.run();
+    await worker.tick();
+    await sleep(100);
+
+    // shouldRetry가 false를 반환했으므로 즉시 failed 상태가 되어야 합니다
+    const workflowRun = await backend.getWorkflowRun({
+      workflowRunId: handle.workflowRun.id,
+    });
+    expect(workflowRun?.status).toBe("failed");
+    expect(workflowRun?.attempts).toBe(1); // 한 번만 시도하고 종료
+  });
+
+  test("calls failWorkflowRun with forceComplete=false when shouldRetry returns true", async () => {
+    const client = new OpenWorkflow({ backend });
+
+    // shouldRetry가 true를 반환하는 retryPolicy
+    const workflow = client.defineWorkflow(
+      {
+        name: "dynamic-retry-true",
+        retryPolicy: {
+          maxAttempts: 2,
+          shouldRetry: () => ({ shouldRetry: true, delayMs: 1000 }),
+        },
+      },
+      () => {
+        throw new Error("Intentional failure");
+      },
+    );
+
+    const worker = client.newWorker();
+    const handle = await workflow.run();
+    await worker.tick();
+    await sleep(100);
+
+    // shouldRetry가 true를 반환했으므로 pending 상태로 재시도 대기
+    const workflowRun = await backend.getWorkflowRun({
+      workflowRunId: handle.workflowRun.id,
+    });
+    expect(workflowRun?.status).toBe("pending");
+    expect(workflowRun?.attempts).toBe(1);
+  });
+
+  test("receives correct error and attempt number in shouldRetry function", async () => {
+    const client = new OpenWorkflow({ backend });
+
+    let receivedError: unknown = null;
+    let receivedAttempt: number | null = null;
+
+    const workflow = client.defineWorkflow(
+      {
+        name: "dynamic-retry-params",
+        retryPolicy: {
+          maxAttempts: 10,
+          shouldRetry: (error, attempt) => {
+            receivedError = error;
+            receivedAttempt = attempt;
+            return { shouldRetry: false, delayMs: 0 };
+          },
+        },
+      },
+      () => {
+        throw new Error("Test error message");
+      },
+    );
+
+    const worker = client.newWorker();
+    const handle = await workflow.run();
+    await worker.tick();
+    await sleep(100);
+
+    // shouldRetry 함수가 올바른 파라미터를 받았는지 확인
+    expect(receivedError).not.toBeNull();
+    expect((receivedError as { message?: string }).message).toBe("Test error message");
+    expect(receivedAttempt).toBe(1); // 첫 번째 시도 후이므로 1
+
+    const workflowRun = await backend.getWorkflowRun({
+      workflowRunId: handle.workflowRun.id,
+    });
+    expect(workflowRun?.status).toBe("failed");
+  });
+});
+
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/execution.ts

@@ -2,6 +2,7 @@ import type { Backend } from "./backend";
 import type { DurationString } from "./core/duration";
 import { serializeError } from "./core/error";
 import type { JsonValue } from "./core/json";
+import { isDynamicRetryPolicy, type RetryPolicy } from "./core/retry";
 import type { StepAttempt, StepAttemptCache } from "./core/step";
 import {
   addToStepAttemptCache,
@@ -186,6 +187,7 @@ export interface ExecuteWorkflowParams {
   workflowFn: WorkflowFunction<unknown, unknown>;
   workflowVersion: string | null;
   workerId: string;
+  retryPolicy?: RetryPolicy;
 }
 
 /**
@@ -198,7 +200,7 @@ export interface ExecuteWorkflowParams {
  * @param params - The execution parameters
  */
 export async function executeWorkflow(params: Readonly<ExecuteWorkflowParams>): Promise<void> {
-  const { backend, workflowRun, workflowFn, workflowVersion, workerId } = params;
+  const { backend, workflowRun, workflowFn, workflowVersion, workerId, retryPolicy } = params;
 
   try {
     // load all pages of step history
@@ -281,11 +283,25 @@ export async function executeWorkflow(params: Readonly<ExecuteWorkflowParams>):
       return;
     }
 
-    // mark failure
+    // claimWorkflowRun에서 이미 attempts가 증가된 상태입니다.
+    let forceComplete = false;
+    let customDelayMs: number | undefined;
+    if (retryPolicy && isDynamicRetryPolicy(retryPolicy)) {
+      const serializedError = serializeError(error);
+      const decision = retryPolicy.shouldRetry(serializedError, workflowRun.attempts ?? 1);
+      if (!decision.shouldRetry) {
+        forceComplete = true;
+      } else {
+        customDelayMs = decision.delayMs;
+      }
+    }
+
     await backend.failWorkflowRun({
       workflowRunId: workflowRun.id,
       workerId,
       error: serializeError(error),
+      forceComplete,
+      customDelayMs,
     });
   }
 }

package/src/internal.ts

@@ -3,7 +3,27 @@ export type * from "./client";
 export { loadConfig } from "./config";
 export type { DurationString } from "./core/duration";
 export type { JsonValue } from "./core/json";
-export { DEFAULT_RETRY_POLICY } from "./core/retry";
+export {
+  DEFAULT_RETRY_POLICY,
+  mergeRetryPolicy,
+  serializeRetryPolicy,
+  shouldRetryByPolicy,
+  calculateRetryDelayMs,
+  shouldRetry,
+  isDynamicRetryPolicy,
+  isStaticRetryPolicy,
+} from "./core/retry";
+export type {
+  RetryPolicy,
+  StaticRetryPolicy,
+  DynamicRetryPolicy,
+  SerializableRetryPolicy,
+  RetryDecision,
+  RetryDecisionFn,
+  MergedStaticRetryPolicy,
+  MergedDynamicRetryPolicy,
+  MergedRetryPolicy,
+} from "./core/retry";
 export type { StandardSchemaV1 } from "./core/schema";
 export type { StepAttempt } from "./core/step";
 export type { SchemaInput, SchemaOutput, WorkflowRun } from "./core/workflow";

package/src/worker.ts

@@ -202,6 +202,7 @@ export class Worker {
         workflowFn: workflow.fn,
         workflowVersion: execution.workflowRun.version,
         workerId: execution.workerId,
+        retryPolicy: workflow.spec.retryPolicy,
       });
     } catch (error) {
       // specifically for unexpected errors in the execution wrapper itself, not

package/src/workflow.ts

@@ -1,3 +1,4 @@
+import type { RetryPolicy } from "./core/retry";
 import type { StandardSchemaV1 } from "./core/schema";
 import type { WorkflowFunction } from "./execution";
 
@@ -8,6 +9,8 @@ export interface WorkflowSpec<Input, Output, RawInput> {
   readonly version?: string;
   /** The schema used to validate inputs. */
   readonly schema?: StandardSchemaV1<RawInput, Input>;
+  /** The retry policy for the workflow. */
+  readonly retryPolicy?: RetryPolicy;
   /** Phantom type carrier - won't exist at runtime. */
   readonly __types?: {
     output: Output;