convex-effect-workflows 0.1.0

package/src/client/encoded.lifecycle.test.ts

@@ -0,0 +1,336 @@
+/// <reference types="vite/client" />
+
+import { describe, expect, test } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Workflow from "@effect/workflow/Workflow";
+import {
+  makeUnsafe as makeUnsafeWorkflowEngine,
+  WorkflowEngine,
+  WorkflowInstance,
+} from "@effect/workflow/WorkflowEngine";
+import { api } from "../component/_generated/api.js";
+import { initConvexTest } from "../component/setup.test.js";
+import { makeConvexEncoded } from "./encoded.js";
+import { ConvexCtx } from "./ConvexCtx.js";
+
+describe("encoded lifecycle", () => {
+  test("activity step suspends then replays to completion", async () => {
+    const t = initConvexTest();
+
+    const ctx = {
+      runMutation: async (fn: any, args: any) => t.mutation(fn, args),
+      runQuery: async (fn: any, args: any) => t.query(fn, args),
+      scheduler: {
+        runAfter: async () => "scheduled" as any,
+      },
+    };
+
+    const enqueued: Array<{ stepNumber: number; attempt: number }> = [];
+
+    const encoded = makeConvexEncoded(api as any, {
+      enqueueRunner: async () => {},
+      enqueueActivity: async (_ctx, args) => {
+        enqueued.push({ stepNumber: args.stepNumber, attempt: args.attempt });
+        return `work-${args.stepNumber}`;
+      },
+    });
+    const engine = makeUnsafeWorkflowEngine(encoded);
+
+    const workflow = Workflow.make({
+      name: "encodedLifecycle",
+      payload: Schema.Struct({ id: Schema.String }),
+      success: Schema.String,
+      error: Schema.String,
+      idempotencyKey: (payload) => payload.id,
+    });
+
+    const activity = { name: "testActivity" } as any;
+
+    const execute = (_payload: object, _executionId: string) =>
+      Effect.gen(function*() {
+        const wfEngine = yield* WorkflowEngine;
+        const result = yield* wfEngine.activityExecute(activity, 1);
+        if (result._tag === "Suspended") {
+          const instance = yield* WorkflowInstance;
+          return yield* Workflow.suspend(instance);
+        }
+        return yield* result.exit;
+      });
+
+    const first = await Effect.runPromise(
+      Effect.scoped(
+        Effect.provideService(
+          Effect.provideService(
+            Effect.gen(function*() {
+              yield* encoded.register(workflow as any, execute as any);
+              return yield* encoded.execute(workflow as any, {
+                executionId: "exec-encoded-lifecycle",
+                payload: { id: "1" },
+                discard: false,
+                parent: undefined,
+              });
+            }) as any,
+            WorkflowEngine,
+            engine,
+          ),
+          ConvexCtx,
+          ctx as any,
+        ),
+      ),
+    );
+
+    expect((first as any)._tag).toBe("Suspended");
+    expect(enqueued).toEqual([{ stepNumber: 0, attempt: 1 }]);
+
+    const step = await t.query(api.journalSteps.getJournalStep, {
+      executionId: "exec-encoded-lifecycle",
+      stepNumber: 0,
+    });
+    expect(step).toBeTruthy();
+    expect(step!.state).toBe("suspended");
+
+    await t.mutation(api.journalSteps.completeJournalStep, {
+      executionId: "exec-encoded-lifecycle",
+      stepNumber: 0,
+      runResult: {
+        kind: "success",
+        valuePreview: "done",
+      },
+    });
+
+    const second = await Effect.runPromise(
+      Effect.scoped(
+        Effect.provideService(
+          Effect.provideService(
+            encoded.execute(workflow as any, {
+              executionId: "exec-encoded-lifecycle",
+              payload: { id: "1" },
+              discard: false,
+              parent: undefined,
+            }) as any,
+            WorkflowEngine,
+            engine,
+          ),
+          ConvexCtx,
+          ctx as any,
+        ),
+      ),
+    );
+
+    expect((second as any)._tag).toBe("Complete");
+    expect(enqueued).toEqual([{ stepNumber: 0, attempt: 1 }]);
+  });
+
+  test("replay ignores activity attempt differences for completed steps", async () => {
+    const t = initConvexTest();
+
+    const ctx = {
+      runMutation: async (fn: any, args: any) => t.mutation(fn, args),
+      runQuery: async (fn: any, args: any) => t.query(fn, args),
+      scheduler: {
+        runAfter: async () => "scheduled" as any,
+      },
+    };
+
+    const enqueued: Array<{ stepNumber: number; attempt: number }> = [];
+
+    const encoded = makeConvexEncoded(api as any, {
+      enqueueRunner: async () => {},
+      enqueueActivity: async (_ctx, args) => {
+        enqueued.push({ stepNumber: args.stepNumber, attempt: args.attempt });
+        return `work-${args.stepNumber}`;
+      },
+    });
+    const engine = makeUnsafeWorkflowEngine(encoded);
+
+    const workflow = Workflow.make({
+      name: "encodedAttemptReplay",
+      payload: Schema.Struct({ id: Schema.String }),
+      success: Schema.String,
+      error: Schema.String,
+      idempotencyKey: (payload) => payload.id,
+    });
+
+    const activity = { name: "stableActivity" } as any;
+
+    const firstExecute = (_payload: object, _executionId: string) =>
+      Effect.gen(function*() {
+        const wfEngine = yield* WorkflowEngine;
+        const result = yield* wfEngine.activityExecute(activity, 1);
+        if (result._tag === "Suspended") {
+          const instance = yield* WorkflowInstance;
+          return yield* Workflow.suspend(instance);
+        }
+        return yield* result.exit;
+      });
+
+    await Effect.runPromise(
+      Effect.scoped(
+        Effect.provideService(
+          Effect.provideService(
+            Effect.gen(function*() {
+              yield* encoded.register(workflow as any, firstExecute as any);
+              return yield* encoded.execute(workflow as any, {
+                executionId: "exec-encoded-attempt-replay",
+                payload: { id: "1" },
+                discard: false,
+                parent: undefined,
+              });
+            }) as any,
+            WorkflowEngine,
+            engine,
+          ),
+          ConvexCtx,
+          ctx as any,
+        ),
+      ),
+    );
+
+    await t.mutation(api.journalSteps.completeJournalStep, {
+      executionId: "exec-encoded-attempt-replay",
+      stepNumber: 0,
+      runResult: {
+        kind: "success",
+        valuePreview: "done",
+      },
+    });
+
+    const secondExecute = (_payload: object, _executionId: string) =>
+      Effect.gen(function*() {
+        const wfEngine = yield* WorkflowEngine;
+        // Attempt value changed from 1 -> 2; replay should still match.
+        const result = yield* wfEngine.activityExecute(activity, 2);
+        if (result._tag === "Suspended") {
+          const instance = yield* WorkflowInstance;
+          return yield* Workflow.suspend(instance);
+        }
+        return yield* result.exit;
+      });
+
+    const replay = await Effect.runPromise(
+      Effect.scoped(
+        Effect.provideService(
+          Effect.provideService(
+            Effect.gen(function*() {
+              yield* encoded.register(workflow as any, secondExecute as any);
+              return yield* encoded.execute(workflow as any, {
+                executionId: "exec-encoded-attempt-replay",
+                payload: { id: "1" },
+                discard: false,
+                parent: undefined,
+              });
+            }) as any,
+            WorkflowEngine,
+            engine,
+          ),
+          ConvexCtx,
+          ctx as any,
+        ),
+      ),
+    );
+
+    expect((replay as any)._tag).toBe("Complete");
+    expect(JSON.stringify(replay)).not.toContain("Determinism mismatch");
+    expect(enqueued).toHaveLength(1);
+    expect(enqueued[0]).toEqual({ stepNumber: 0, attempt: 1 });
+  });
+
+  test("determinism mismatch returns terminal failure result", async () => {
+    const t = initConvexTest();
+
+    const ctx = {
+      runMutation: async (fn: any, args: any) => t.mutation(fn, args),
+      runQuery: async (fn: any, args: any) => t.query(fn, args),
+      scheduler: {
+        runAfter: async () => "scheduled" as any,
+      },
+    };
+
+    const encoded = makeConvexEncoded(api as any, {
+      enqueueRunner: async () => {},
+      enqueueActivity: async () => "work-0",
+    });
+    const engine = makeUnsafeWorkflowEngine(encoded);
+
+    const workflow = Workflow.make({
+      name: "encodedDeterminism",
+      payload: Schema.Struct({ id: Schema.String }),
+      success: Schema.String,
+      error: Schema.String,
+      idempotencyKey: (payload) => payload.id,
+    });
+
+    const activityA = { name: "activityA" } as any;
+    const activityB = { name: "activityB" } as any;
+
+    const firstExecute = (_payload: object, _executionId: string) =>
+      Effect.gen(function*() {
+        const wfEngine = yield* WorkflowEngine;
+        const result = yield* wfEngine.activityExecute(activityA, 1);
+        if (result._tag === "Suspended") {
+          const instance = yield* WorkflowInstance;
+          return yield* Workflow.suspend(instance);
+        }
+        return yield* result.exit;
+      });
+
+    await Effect.runPromise(
+      Effect.scoped(
+        Effect.provideService(
+          Effect.provideService(
+            Effect.gen(function*() {
+              yield* encoded.register(workflow as any, firstExecute as any);
+              return yield* encoded.execute(workflow as any, {
+                executionId: "exec-encoded-determinism",
+                payload: { id: "1" },
+                discard: false,
+                parent: undefined,
+              });
+            }) as any,
+            WorkflowEngine,
+            engine,
+          ),
+          ConvexCtx,
+          ctx as any,
+        ),
+      ),
+    );
+
+    const mismatchedExecute = (_payload: object, _executionId: string) =>
+      Effect.gen(function*() {
+        const wfEngine = yield* WorkflowEngine;
+        const result = yield* wfEngine.activityExecute(activityB, 1);
+        if (result._tag === "Suspended") {
+          const instance = yield* WorkflowInstance;
+          return yield* Workflow.suspend(instance);
+        }
+        return yield* result.exit;
+      });
+
+    const mismatchResult = await Effect.runPromise(
+      Effect.scoped(
+        Effect.provideService(
+          Effect.provideService(
+            Effect.gen(function*() {
+              yield* encoded.register(workflow as any, mismatchedExecute as any);
+              return yield* encoded.execute(workflow as any, {
+                executionId: "exec-encoded-determinism",
+                payload: { id: "1" },
+                discard: false,
+                parent: undefined,
+              });
+            }) as any,
+            WorkflowEngine,
+            engine,
+          ),
+          ConvexCtx,
+          ctx as any,
+        ),
+      ),
+    );
+
+    expect((mismatchResult as any)._tag).toBe("Complete");
+    expect((mismatchResult as any).exit._tag).toBe("Failure");
+  });
+});

package/src/client/encoded.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, test } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Workflow from "@effect/workflow/Workflow";
+import * as Schema from "effect/Schema";
+import * as DurableClock from "@effect/workflow/DurableClock";
+import { makeConvexEncoded } from "./encoded.js";
+import { ConvexCtx } from "./ConvexCtx.js";
+
+describe("makeConvexEncoded scheduleClock", () => {
+  test("schedules deferred completion wake", async () => {
+    const deferredDoneRef = Symbol("deferredDone");
+    const getExecutionRef = Symbol("getExecution");
+
+    const scheduled: Array<{ delay: number; fn: unknown; args: unknown }> = [];
+
+    const ctx = {
+      runQuery: async (fn: unknown, args: any) => {
+        if (fn === getExecutionRef) {
+          return {
+            executionId: args.executionId,
+            generation: 3,
+            status: "running",
+            runnerHandle: "function://runner",
+          };
+        }
+        throw new Error("unexpected query");
+      },
+      runMutation: async () => {
+        throw new Error("unexpected mutation");
+      },
+      scheduler: {
+        runAfter: async (delay: number, fn: unknown, args: unknown) => {
+          scheduled.push({ delay, fn, args });
+          return "scheduled-id" as any;
+        },
+      },
+    };
+
+    const component = {
+      executions: {
+        getExecution: getExecutionRef,
+      },
+      deferreds: {
+        deferredDone: deferredDoneRef,
+      },
+    } as any;
+
+    const encoded = makeConvexEncoded(component, {
+      enqueueRunner: async () => {},
+      enqueueActivity: async () => "work-id",
+    });
+
+    const workflow = Workflow.make({
+      name: "clockWorkflow",
+      payload: Schema.Struct({ id: Schema.String }),
+      success: Schema.String,
+      error: Schema.String,
+      idempotencyKey: (p) => p.id,
+    });
+
+    const clock = DurableClock.make({
+      name: "wait",
+      duration: 1000,
+    });
+
+    await Effect.runPromise(
+      Effect.provideService(
+        encoded.scheduleClock(workflow as any, {
+          executionId: "exec-1",
+          clock,
+        }) as any,
+        ConvexCtx,
+        ctx as any,
+      ),
+    );
+
+    expect(scheduled).toHaveLength(1);
+    expect(scheduled[0]?.delay).toBe(1000);
+    expect(scheduled[0]?.fn).toBe(deferredDoneRef);
+  });
+
+  test("schedules only deferred completion when no runnerHandle", async () => {
+    const deferredDoneRef = Symbol("deferredDone");
+    const getExecutionRef = Symbol("getExecution");
+
+    const scheduled: Array<{ delay: number; fn: unknown; args: unknown }> = [];
+
+    const ctx = {
+      runQuery: async (fn: unknown, args: any) => {
+        if (fn === getExecutionRef) {
+          return {
+            executionId: args.executionId,
+            generation: 1,
+            status: "running",
+            runnerHandle: undefined,
+          };
+        }
+        throw new Error("unexpected query");
+      },
+      runMutation: async () => {
+        throw new Error("unexpected mutation");
+      },
+      scheduler: {
+        runAfter: async (delay: number, fn: unknown, args: unknown) => {
+          scheduled.push({ delay, fn, args });
+          return "scheduled-id" as any;
+        },
+      },
+    };
+
+    const component = {
+      executions: {
+        getExecution: getExecutionRef,
+      },
+      deferreds: {
+        deferredDone: deferredDoneRef,
+      },
+    } as any;
+
+    const encoded = makeConvexEncoded(component, {
+      enqueueRunner: async () => {},
+      enqueueActivity: async () => "work-id",
+    });
+
+    const workflow = Workflow.make({
+      name: "clockWorkflow",
+      payload: Schema.Struct({ id: Schema.String }),
+      success: Schema.String,
+      error: Schema.String,
+      idempotencyKey: (p) => p.id,
+    });
+
+    const clock = DurableClock.make({
+      name: "wait",
+      duration: 250,
+    });
+
+    await Effect.runPromise(
+      Effect.provideService(
+        encoded.scheduleClock(workflow as any, {
+          executionId: "exec-2",
+          clock,
+        }) as any,
+        ConvexCtx,
+        ctx as any,
+      ),
+    );
+
+    expect(scheduled).toHaveLength(1);
+    expect(scheduled[0]?.delay).toBe(250);
+    expect(scheduled[0]?.fn).toBe(deferredDoneRef);
+  });
+});