@redflow/client 0.0.1 → 0.0.2

package/src/worker.ts

@@ -43,6 +43,8 @@ export type WorkerHandle = {
   stop(): Promise<void>;
 };
 
+const POLL_MS = 250;
+
 const UNLOCK_LUA = `
 if redis.call("get", KEYS[1]) == ARGV[1] then
   return redis.call("del", KEYS[1])
@@ -224,10 +226,6 @@ function defaultStepWorkflowIdempotencyKey(parentRunId: string, stepName: string
   return `stepwf:${encodeIdempotencyPart(parentRunId)}:${encodeIdempotencyPart(stepName)}:${encodeIdempotencyPart(childWorkflowName)}`;
 }
 
-function defaultStepEventIdempotencyKey(parentRunId: string, stepName: string, eventName: string): string {
-  return `stepev:${encodeIdempotencyPart(parentRunId)}:${encodeIdempotencyPart(stepName)}:${encodeIdempotencyPart(eventName)}`;
-}
-
 async function claimQueuedRunForInlineExecution(args: {
   redis: RedisClient;
   prefix: string;
@@ -616,13 +614,9 @@ async function processRun(args: {
 
         const waitForRunResultWithInlineAssist = async <TOutput>(
           childRunId: string,
-          resultOptions: { timeoutMs?: number; pollMs?: number } | undefined,
           stepSignal: AbortSignal,
         ): Promise<TOutput> => {
-          const timeoutMs = resultOptions?.timeoutMs ?? 30_000;
-          const pollMs = resultOptions?.pollMs ?? 250;
-          const deadline = nowMs() + timeoutMs;
-          const missingGraceMs = Math.max(250, Math.min(2000, pollMs * 4));
+          const missingGraceMs = Math.max(250, Math.min(2000, POLL_MS * 4));
 
           let missingSince: number | null = null;
           let seenState = false;
@@ -642,8 +636,7 @@ async function processRun(args: {
                 throw new Error(`Run not found: ${childRunId}`);
               }
 
-              if (t > deadline) throw new TimeoutError(`Timed out waiting for run result (${childRunId})`);
-              await sleep(pollMs);
+              await sleep(POLL_MS);
               continue;
             }
 
@@ -681,8 +674,7 @@ async function processRun(args: {
               }
             }
 
-            if (nowMs() > deadline) throw new TimeoutError(`Timed out waiting for run result (${childRunId})`);
-            await sleep(pollMs);
+            await sleep(POLL_MS);
           }
         };
 
@@ -690,41 +682,31 @@ async function processRun(args: {
           { name: options.name, timeoutMs: options.timeoutMs },
           async ({ signal: stepSignal }) => {
             const handle = await workflow.run(workflowInput, {
-              ...(options.run ?? {}),
+              runAt: options.runAt,
+              queueOverride: options.queueOverride,
+              idempotencyTtl: options.idempotencyTtl,
               idempotencyKey,
             });
 
-            return await waitForRunResultWithInlineAssist(handle.id, options.result, stepSignal);
+            return await waitForRunResultWithInlineAssist(handle.id, stepSignal);
           },
         );
       };
 
-      const emitEventStep: StepApi["emitEvent"] = async (options, payload) => {
+      const emitWorkflowStep: StepApi["emitWorkflow"] = async (options, workflow, workflowInput) => {
         const idempotencyKey =
-          options.idempotencyKey ?? defaultStepEventIdempotencyKey(runId, options.name, options.event);
-
-        return await runStep(
-          { name: options.name, timeoutMs: options.timeoutMs },
-          async () => {
-            return await client.emitEvent(options.event, payload, {
-              ...(options.emit ?? {}),
-              idempotencyKey,
-            });
-          },
-        );
-      };
-
-      const scheduleEventStep: StepApi["scheduleEvent"] = async (options, payload) => {
-        const idempotencyKey =
-          options.idempotencyKey ?? defaultStepEventIdempotencyKey(runId, options.name, options.event);
+          options.idempotencyKey ?? defaultStepWorkflowIdempotencyKey(runId, options.name, workflow.name);
 
         return await runStep(
           { name: options.name, timeoutMs: options.timeoutMs },
           async () => {
-            return await client.scheduleEvent(options.event, payload, {
-              ...(options.schedule ?? {}),
+            const handle = await workflow.run(workflowInput, {
+              runAt: options.runAt,
+              queueOverride: options.queueOverride,
+              idempotencyTtl: options.idempotencyTtl,
               idempotencyKey,
             });
+            return handle.id;
           },
         );
       };
@@ -732,8 +714,7 @@ async function processRun(args: {
       const step: StepApi = {
         run: runStep,
         runWorkflow: runWorkflowStep,
-        emitEvent: emitEventStep,
-        scheduleEvent: scheduleEventStep,
+        emitWorkflow: emitWorkflowStep,
       };
 
       let outputJson: string;
@@ -1039,4 +1020,4 @@ async function invokeOnFailure(
   } catch {
     // onFailure must not interfere with the run lifecycle.
   }
-}
+}

package/src/workflow.ts

@@ -11,15 +11,18 @@ export type Workflow<TInput, TOutput> = {
   run(input: TInput, options?: RunOptions): Promise<RunHandle<TOutput>>;
 };
 
+export type DefineWorkflowConfig<TSchema extends ZodTypeAny | undefined> = Omit<DefineWorkflowOptions<TSchema>, "name">;
+
 export function defineWorkflow<TSchema extends ZodTypeAny | undefined, TOutput>(
-  options: DefineWorkflowOptions<TSchema>,
+  name: string,
+  options: DefineWorkflowConfig<TSchema>,
   handler: WorkflowHandler<InferInput<TSchema>, TOutput>,
 ): Workflow<InferInput<TSchema>, TOutput> {
-  getDefaultRegistry().register({ options, handler });
+  const fullOptions: DefineWorkflowOptions<TSchema> = { name, ...options };
+  getDefaultRegistry().register({ options: fullOptions, handler });
 
-  const name = options.name;
-  const queue = options.queue ?? "default";
-  const configuredMaxAttempts = options.retries?.maxAttempts;
+  const queue = fullOptions.queue ?? "default";
+  const configuredMaxAttempts = fullOptions.retries?.maxAttempts;
   const maxAttemptsOverride =
     typeof configuredMaxAttempts === "number" && Number.isFinite(configuredMaxAttempts) && configuredMaxAttempts > 0
       ? Math.floor(configuredMaxAttempts)
@@ -28,7 +31,9 @@ export function defineWorkflow<TSchema extends ZodTypeAny | undefined, TOutput>(
   return {
     name,
     async run(input, runOptions) {
-      const parsedInput = options.schema ? (validateInputWithSchema(options.schema, input) as InferInput<TSchema>) : input;
+      const parsedInput = fullOptions.schema
+        ? (validateInputWithSchema(fullOptions.schema, input) as InferInput<TSchema>)
+        : input;
       const client = getDefaultClient();
       return await client.runByName<TOutput>(name, parsedInput, {
         ...runOptions,
@@ -39,4 +44,4 @@ export function defineWorkflow<TSchema extends ZodTypeAny | undefined, TOutput>(
   };
 }
 
-export type { WorkflowHandler, WorkflowHandlerContext };
+export type { WorkflowHandler, WorkflowHandlerContext };

package/tests/bugfixes.test.ts

@@ -142,7 +142,7 @@ test("transitionRunStatus: atomically moves status and indexes", async () => {
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow({ name: "atomic-transition-wf", queue: "q_atomic" }, async () => ({ ok: true }));
+  const wf = defineWorkflow("atomic-transition-wf", {queue: "q_atomic" }, async () => ({ ok: true }));
 
   // Enqueue a run manually
   const handle = await wf.run({});
@@ -177,8 +177,8 @@ test("transitionRunStatus: clears availableAt when transitioning away from sched
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow({ name: "clear-avail-wf", queue: "q_avail" }, async () => ({ ok: true }));
-  const handle = await wf.run({}, { availableAt: new Date(Date.now() + 60_000) });
+  const wf = defineWorkflow("clear-avail-wf", {queue: "q_avail" }, async () => ({ ok: true }));
+  const handle = await wf.run({}, { runAt: new Date(Date.now() + 60_000) });
 
   // Should be scheduled
   const state1 = await client.getRun(handle.id);
@@ -209,8 +209,7 @@ test("crash recovery: attempt is not double-incremented", async () => {
   const queue = "q_no_double";
   const countKey = `${prefix}:t:noDoubleCount`;
 
-  const wf = defineWorkflow(
-    { name: "no-double-wf", queue, retries: { maxAttempts: 3 } },
+  const wf = defineWorkflow("no-double-wf", {queue, retries: { maxAttempts: 3 } },
     async ({ step, run }) => {
       await step.run({ name: "do" }, async () => {
         await redis.incr(countKey);
@@ -229,7 +228,7 @@ test("crash recovery: attempt is not double-incremented", async () => {
   });
 
   const handle = await wf.run({});
-  const result = await handle.result({ timeoutMs: 5000, pollMs: 50 });
+  const result = await handle.result({ timeoutMs: 5000 });
   expect(result.attempt).toBe(1);
 
   const state = await client.getRun(handle.id);
@@ -249,8 +248,7 @@ test("crash recovery: re-processing a running run does not bump attempt", async
 
   const queue = "q_recover_attempt";
 
-  const wf = defineWorkflow(
-    { name: "recover-attempt-wf", queue },
+  const wf = defineWorkflow("recover-attempt-wf", {queue },
     async ({ run }) => {
       return { attempt: run.attempt };
     },
@@ -318,10 +316,7 @@ test("retry: run is atomically transitioned to scheduled with queue entry", asyn
 
   const queue = "q_atomic_retry";
 
-  const wf = defineWorkflow(
-    {
-      name: "atomic-retry-wf",
-      queue,
+  const wf = defineWorkflow("atomic-retry-wf", {queue,
       retries: { maxAttempts: 2 },
     },
     async ({ run }) => {
@@ -338,7 +333,7 @@ test("retry: run is atomically transitioned to scheduled with queue entry", asyn
   });
 
   const handle = await wf.run({});
-  const result = await handle.result({ timeoutMs: 15_000, pollMs: 50 });
+  const result = await handle.result({ timeoutMs: 15_000 });
   expect(result).toEqual({ ok: true });
 
   const state = await client.getRun(handle.id);
@@ -431,7 +426,7 @@ test(
     const queue = "q_batch_promote";
     const countKey = `${prefix}:t:batchPromoteCount`;
 
-    const wf = defineWorkflow({ name: "batch-promote-wf", queue }, async ({ step }) => {
+    const wf = defineWorkflow("batch-promote-wf", {queue }, async ({ step }) => {
       await step.run({ name: "do" }, async () => {
         await redis.incr(countKey);
         return true;
@@ -442,7 +437,7 @@ test(
     // Schedule 5 runs for "now" so they all become due simultaneously
     const handles = [];
     for (let i = 0; i < 5; i++) {
-      handles.push(await wf.run({}, { availableAt: new Date(Date.now() + 200) }));
+      handles.push(await wf.run({}, { runAt: new Date(Date.now() + 200) }));
     }
 
     const worker = await startWorker({
@@ -489,14 +484,14 @@ test("cancelRun: cleans processing list for canceled runs", async () => {
 
   const queue = "q_cancel_processing";
 
-  const wf = defineWorkflow({ name: "cancel-proc-wf", queue }, async () => {
+  const wf = defineWorkflow("cancel-proc-wf", {queue }, async () => {
     // Long-running so we can cancel while queued/scheduled
     await new Promise((r) => setTimeout(r, 60_000));
     return { ok: true };
   });
 
   // Schedule a run for the near future
-  const handle = await wf.run({}, { availableAt: new Date(Date.now() + 100) });
+  const handle = await wf.run({}, { runAt: new Date(Date.now() + 100) });
 
   // Manually place it into processing to simulate race condition
   const processingKey = keys.queueProcessing(prefix, queue);
@@ -525,7 +520,7 @@ test("duplicate step name: throws a clear error", async () => {
 
   const queue = "q_dup_step";
 
-  const wf = defineWorkflow({ name: "dup-step-wf", queue }, async ({ step }) => {
+  const wf = defineWorkflow("dup-step-wf", {queue }, async ({ step }) => {
     await step.run({ name: "same-name" }, async () => 1);
     // This should throw because step name is already used
     await step.run({ name: "same-name" }, async () => 2);
@@ -565,7 +560,7 @@ test("unique step names: work normally", async () => {
 
   const queue = "q_unique_steps";
 
-  const wf = defineWorkflow({ name: "unique-steps-wf", queue }, async ({ step }) => {
+  const wf = defineWorkflow("unique-steps-wf", {queue }, async ({ step }) => {
     const a = await step.run({ name: "step-a" }, async () => 1);
     const b = await step.run({ name: "step-b" }, async () => 2);
     const c = await step.run({ name: "step-c" }, async () => 3);
@@ -580,7 +575,7 @@ test("unique step names: work normally", async () => {
   });
 
   const handle = await wf.run({});
-  const result = await handle.result({ timeoutMs: 5000, pollMs: 50 });
+  const result = await handle.result({ timeoutMs: 5000 });
   expect(result).toEqual({ sum: 6 });
 
   await worker.stop();
@@ -602,10 +597,7 @@ test(
     const queue = "q_full_retry";
     const attemptsKey = `${prefix}:t:fullRetryAttempts`;
 
-    const wf = defineWorkflow(
-      {
-        name: "full-retry-wf",
-        queue,
+    const wf = defineWorkflow("full-retry-wf", {queue,
         retries: { maxAttempts: 3 },
       },
       async ({ run, step }) => {
@@ -626,7 +618,7 @@ test(
     });
 
     const handle = await wf.run({});
-    const result = await handle.result({ timeoutMs: 30_000, pollMs: 100 });
+    const result = await handle.result({ timeoutMs: 30_000 });
     expect(result).toEqual({ ok: true, finalAttempt: 3 });
 
     const state = await client.getRun(handle.id);
@@ -661,10 +653,7 @@ test(
 
     const queue = "q_exhaust";
 
-    const wf = defineWorkflow(
-      {
-        name: "exhaust-wf",
-        queue,
+    const wf = defineWorkflow("exhaust-wf", {queue,
         retries: { maxAttempts: 2 },
       },
       async () => {
@@ -716,7 +705,7 @@ test("status indexes: consistent through full lifecycle", async () => {
 
   const queue = "q_status_idx";
 
-  const wf = defineWorkflow({ name: "status-idx-wf", queue }, async ({ step }) => {
+  const wf = defineWorkflow("status-idx-wf", {queue }, async ({ step }) => {
     await step.run({ name: "do" }, async () => {
       await new Promise((r) => setTimeout(r, 200));
       return true;
@@ -749,7 +738,7 @@ test("status indexes: consistent through full lifecycle", async () => {
   expect(queuedMembers.includes(handle.id)).toBe(false);
 
   // Wait for succeeded
-  await handle.result({ timeoutMs: 5000, pollMs: 50 });
+  await handle.result({ timeoutMs: 5000 });
 
   const succeededMembers = await redis.zrange(`${prefix}:runs:status:succeeded`, 0, -1);
   expect(succeededMembers.includes(handle.id)).toBe(true);
@@ -758,4 +747,4 @@ test("status indexes: consistent through full lifecycle", async () => {
 
   await worker.stop();
   redis.close();
-});
+});

package/tests/fixtures/worker-crash.ts

@@ -15,8 +15,8 @@ if (!url || !prefix || !workflowName || !queue || !step1Key) {
 const redis = new RedisClient(url);
 
 defineWorkflow(
+  workflowName,
   {
-    name: workflowName,
     queue,
     retries: { maxAttempts: 3 },
   },

package/tests/fixtures/worker-recover.ts

@@ -17,8 +17,8 @@ const redis = new RedisClient(url);
 const client = createClient({ redis, prefix });
 
 defineWorkflow(
+  workflowName,
   {
-    name: workflowName,
     queue,
     retries: { maxAttempts: 3 },
   },