@gencow/core 0.1.23 → 0.1.25

package/src/__tests__/workflow.test.ts

@@ -0,0 +1,606 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { PGlite } from "@electric-sql/pglite";
+import { drizzle } from "drizzle-orm/pglite";
+import { sql } from "drizzle-orm";
+import { getWorkflowResumeActionName, workflow } from "../workflow.js";
+import { getQueryDef, getRegisteredMutations } from "../reactive.js";
+import { v } from "../v.js";
+import { registerWorkflowsApi } from "../workflows-api.js";
+
+const WORKFLOW_TABLE_SETUP = [
+  `CREATE TABLE IF NOT EXISTS _gencow_workflows (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        args JSONB NOT NULL DEFAULT '{}'::jsonb,
+        status TEXT NOT NULL DEFAULT 'pending',
+        current_step TEXT,
+        result JSONB,
+        error TEXT,
+        realtime_token TEXT NOT NULL DEFAULT '',
+        retry_count INTEGER NOT NULL DEFAULT 0,
+        max_retries INTEGER NOT NULL DEFAULT 3,
+        max_duration_ms BIGINT NOT NULL DEFAULT 1800000,
+        started_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        completed_at TIMESTAMPTZ,
+        user_id TEXT
+    )`,
+  `CREATE TABLE IF NOT EXISTS _gencow_workflow_steps (
+        id SERIAL PRIMARY KEY,
+        workflow_id TEXT NOT NULL REFERENCES _gencow_workflows(id) ON DELETE CASCADE,
+        step_name TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        output JSONB,
+        error TEXT,
+        started_at TIMESTAMPTZ,
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        completed_at TIMESTAMPTZ,
+        UNIQUE(workflow_id, step_name)
+    )`,
+  `CREATE TABLE IF NOT EXISTS _gencow_workflow_events (
+        id TEXT PRIMARY KEY,
+        workflow_id TEXT NOT NULL REFERENCES _gencow_workflows(id) ON DELETE CASCADE,
+        event_name TEXT NOT NULL,
+        payload JSONB,
+        received_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        consumed_at TIMESTAMPTZ
+    )`,
+] as const;
+
+describe("workflow()", () => {
+  let client: PGlite;
+  let db: ReturnType<typeof drizzle>;
+
+  function buildCtx(userId: string | null) {
+    return {
+      db,
+      unsafeDb: db,
+      auth: {
+        getUserIdentity: () => (userId ? { id: userId, email: `${userId}@workflow.test` } : null),
+        requireAuth: () => {
+          if (!userId) throw new Error("Authentication required");
+          return { id: userId, email: `${userId}@workflow.test` };
+        },
+      },
+      storage: {} as any,
+      scheduler: {
+        runAfter: () => "unused",
+        runAt: () => "unused",
+        cancel: () => false,
+        cron: () => {},
+        registerAction: () => {},
+        executeAction: async () => {},
+      },
+      realtime: { emit: () => {}, refresh: () => {} },
+      retry: async (fn: () => Promise<unknown>) => fn(),
+    };
+  }
+
+  beforeAll(async () => {
+    client = new PGlite();
+    db = drizzle({ client });
+    for (const stmt of WORKFLOW_TABLE_SETUP) {
+      await client.exec(stmt);
+    }
+    registerWorkflowsApi();
+  });
+
+  afterAll(async () => {
+    await client.close();
+  });
+
+  it("start mutation inserts workflow row and schedules resume action", async () => {
+    const name = `agents.workflowStart${Date.now()}`;
+    const start = workflow(name, {
+      args: { topic: v.string() },
+      handler: async () => ({ ok: true }),
+    });
+
+    const scheduled: Array<{ delayMs: number; action: string; args: unknown }> = [];
+    const result = await start.handler(
+      {
+        db,
+        unsafeDb: db,
+        auth: {
+          getUserIdentity: () => ({ id: "user_workflow_start", email: "owner@test.dev" }),
+          requireAuth: () => ({ id: "user_workflow_start", email: "owner@test.dev" }),
+        },
+        storage: {} as any,
+        scheduler: {
+          runAfter: (delayMs, action, args) => {
+            scheduled.push({ delayMs, action, args });
+            return "job-start-1";
+          },
+          runAt: () => "unused",
+          cancel: () => false,
+          cron: () => {},
+          registerAction: () => {},
+          executeAction: async () => {},
+        },
+        realtime: { emit: () => {}, refresh: () => {} },
+        retry: async (fn) => fn(),
+      },
+      { topic: "durable execution" },
+    );
+
+    expect(result.status).toBe("pending");
+    expect(result.name).toBe(name);
+    expect(result.scheduledJobId).toBe("job-start-1");
+    expect(scheduled).toEqual([
+      {
+        delayMs: 0,
+        action: getWorkflowResumeActionName(name),
+        args: { workflowId: result.id },
+      },
+    ]);
+
+    const rowResult = await db.execute(sql`
+            SELECT id, name, status, max_retries, user_id, args, realtime_token
+            FROM _gencow_workflows
+            WHERE id = ${result.id}
+        `);
+    const row = (
+      rowResult as {
+        rows: Array<{
+          id: string;
+          name: string;
+          status: string;
+          max_retries: number;
+          user_id: string | null;
+          args: unknown;
+          realtime_token: string;
+        }>;
+      }
+    ).rows[0];
+
+    expect(row.id).toBe(result.id);
+    expect(row.name).toBe(name);
+    expect(row.status).toBe("pending");
+    expect(row.max_retries).toBe(3);
+    expect(row.user_id).toBe("user_workflow_start");
+    expect(row.args).toEqual({ value: { topic: "durable execution" } });
+    expect(row.realtime_token.length).toBeGreaterThan(10);
+  });
+
+  it("scheduler enqueue failure rolls back the workflow row", async () => {
+    const name = `agents.workflowRollback${Date.now()}`;
+    const start = workflow(name, {
+      args: { topic: v.string() },
+      handler: async () => ({ ok: true }),
+    });
+
+    await expect(
+      start.handler(
+        {
+          db,
+          unsafeDb: db,
+          auth: {
+            getUserIdentity: () => null,
+            requireAuth: () => {
+              throw new Error("not used");
+            },
+          },
+          storage: {} as any,
+          scheduler: {
+            runAfter: () => {
+              throw new Error("scheduler unavailable");
+            },
+            runAt: () => "unused",
+            cancel: () => false,
+            cron: () => {},
+            registerAction: () => {},
+            executeAction: async () => {},
+          },
+          realtime: { emit: () => {}, refresh: () => {} },
+          retry: async (fn) => fn(),
+        },
+        { topic: "should rollback" },
+      ),
+    ).rejects.toThrow("scheduler unavailable");
+
+    const countResult = await db.execute(sql`
+            SELECT count(*)::int AS c
+            FROM _gencow_workflows
+            WHERE name = ${name}
+        `);
+    const count = (countResult as { rows: Array<{ c: number }> }).rows[0]?.c ?? 0;
+    expect(count).toBe(0);
+  });
+
+  it("workflows.get returns full snapshot for the owner and hides private workflows from others", async () => {
+    const getWorkflow = getQueryDef("workflows.get");
+    expect(getWorkflow).toBeDefined();
+
+    const workflowId = `wf_owned_${Date.now()}`;
+    await db.execute(sql`
+            INSERT INTO _gencow_workflows (
+                id,
+                name,
+                args,
+                status,
+                current_step,
+                result,
+                error,
+                retry_count,
+                max_retries,
+                max_duration_ms,
+                started_at,
+                updated_at,
+                completed_at,
+                user_id
+            )
+            VALUES (
+                ${workflowId},
+                'agents.report',
+                '{"value":{"topic":"market map"}}'::jsonb,
+                'running',
+                'analyze',
+                NULL,
+                NULL,
+                1,
+                3,
+                1800000,
+                NOW() - INTERVAL '2 minutes',
+                NOW() - INTERVAL '5 seconds',
+                NULL,
+                'owner_workflow'
+            )
+        `);
+    await db.execute(sql`
+            INSERT INTO _gencow_workflow_steps (
+                workflow_id,
+                step_name,
+                status,
+                output,
+                error,
+                started_at,
+                updated_at,
+                completed_at
+            )
+            VALUES
+                (
+                    ${workflowId},
+                    'search',
+                    'completed',
+                    '{"value":{"hits":2}}'::jsonb,
+                    NULL,
+                    NOW() - INTERVAL '90 seconds',
+                    NOW() - INTERVAL '80 seconds',
+                    NOW() - INTERVAL '80 seconds'
+                ),
+                (
+                    ${workflowId},
+                    'analyze',
+                    'running',
+                    NULL,
+                    NULL,
+                    NOW() - INTERVAL '10 seconds',
+                    NOW() - INTERVAL '5 seconds',
+                    NULL
+                )
+        `);
+
+    const ownerSnapshot = await getWorkflow!.handler(buildCtx("owner_workflow") as any, { id: workflowId });
+    expect(ownerSnapshot).toMatchObject({
+      id: workflowId,
+      name: "agents.report",
+      status: "running",
+      derivedStatus: "running",
+      currentStep: "analyze",
+      args: { topic: "market map" },
+      result: null,
+      retryCount: 1,
+      maxRetries: 3,
+    });
+    expect(ownerSnapshot?.realtimeKey).toMatch(new RegExp(`^__gencow\\.workflow\\.state\\.${workflowId}\\.`));
+    expect(ownerSnapshot?.steps).toHaveLength(2);
+    expect(ownerSnapshot?.steps[0]).toMatchObject({
+      name: "search",
+      status: "completed",
+      output: { hits: 2 },
+    });
+    expect(ownerSnapshot?.steps[1]).toMatchObject({
+      name: "analyze",
+      status: "running",
+      output: null,
+    });
+
+    const strangerSnapshot = await getWorkflow!.handler(buildCtx("stranger_workflow") as any, {
+      id: workflowId,
+    });
+    expect(strangerSnapshot).toBeNull();
+  });
+
+  it("workflows.get allows ownerless public workflows to be polled without auth", async () => {
+    const getWorkflow = getQueryDef("workflows.get");
+    expect(getWorkflow).toBeDefined();
+
+    const workflowId = `wf_public_${Date.now()}`;
+    await db.execute(sql`
+            INSERT INTO _gencow_workflows (
+                id,
+                name,
+                args,
+                status,
+                current_step,
+                result,
+                error,
+                retry_count,
+                max_retries,
+                max_duration_ms,
+                started_at,
+                updated_at,
+                completed_at,
+                user_id
+            )
+            VALUES (
+                ${workflowId},
+                'agents.public',
+                '{"value":{"topic":"public"}}'::jsonb,
+                'completed',
+                NULL,
+                '{"value":{"report":"done"}}'::jsonb,
+                NULL,
+                0,
+                3,
+                1800000,
+                NOW() - INTERVAL '1 minute',
+                NOW() - INTERVAL '5 seconds',
+                NOW() - INTERVAL '5 seconds',
+                NULL
+            )
+        `);
+
+    const snapshot = await getWorkflow!.handler(buildCtx(null) as any, { id: workflowId });
+    expect(snapshot).toMatchObject({
+      id: workflowId,
+      status: "completed",
+      derivedStatus: "completed",
+      result: { report: "done" },
+      steps: [],
+    });
+    expect(snapshot?.realtimeKey).toMatch(new RegExp(`^__gencow\\.workflow\\.state\\.${workflowId}\\.`));
+  });
+
+  it("workflows.signal persists an event and wakes waiting workflows for the owner only", async () => {
+    const signalWorkflow = getRegisteredMutations().find((item) => item.name === "workflows.signal");
+    expect(signalWorkflow).toBeDefined();
+
+    const workflowId = `wf_signal_${Date.now()}`;
+    await db.execute(sql`
+            INSERT INTO _gencow_workflows (
+                id,
+                name,
+                args,
+                status,
+                current_step,
+                result,
+                error,
+                retry_count,
+                max_retries,
+                max_duration_ms,
+                started_at,
+                updated_at,
+                completed_at,
+                user_id
+            )
+            VALUES (
+                ${workflowId},
+                'agents.waiting',
+                '{}'::jsonb,
+                'pending',
+                'wait:approval#1',
+                NULL,
+                NULL,
+                0,
+                3,
+                1800000,
+                NOW() - INTERVAL '20 seconds',
+                NOW() - INTERVAL '5 seconds',
+                NULL,
+                'signal_owner'
+            )
+        `);
+
+    const scheduled: Array<{ delayMs: number; action: string; args: unknown }> = [];
+    const accepted = await signalWorkflow!.handler(
+      {
+        ...buildCtx("signal_owner"),
+        scheduler: {
+          runAfter: (delayMs, action, args) => {
+            scheduled.push({ delayMs, action, args });
+            return "job-signal-1";
+          },
+          runAt: () => "unused",
+          cancel: () => false,
+          cron: () => {},
+          registerAction: () => {},
+          executeAction: async () => {},
+        },
+      } as any,
+      {
+        id: workflowId,
+        event: "approval",
+        payload: { approved: true },
+      },
+    );
+
+    expect(accepted).toEqual({
+      ok: true,
+      workflowId,
+      event: "approval",
+      scheduledJobId: "job-signal-1",
+    });
+    expect(scheduled).toEqual([
+      {
+        delayMs: 0,
+        action: getWorkflowResumeActionName("agents.waiting"),
+        args: { workflowId },
+      },
+    ]);
+
+    const eventResult = await db.execute(sql`
+            SELECT workflow_id, event_name, payload, consumed_at IS NULL AS is_unconsumed
+            FROM _gencow_workflow_events
+            WHERE workflow_id = ${workflowId}
+        `);
+    const eventRow = (
+      eventResult as {
+        rows: Array<{
+          workflow_id: string;
+          event_name: string;
+          payload: unknown;
+          is_unconsumed: boolean;
+        }>;
+      }
+    ).rows[0];
+    expect(eventRow).toEqual({
+      workflow_id: workflowId,
+      event_name: "approval",
+      payload: { value: { approved: true } },
+      is_unconsumed: true,
+    });
+
+    const denied = await signalWorkflow!.handler(buildCtx("someone_else") as any, {
+      id: workflowId,
+      event: "approval",
+      payload: { approved: false },
+    });
+    expect(denied).toEqual({
+      ok: false,
+      workflowId,
+      event: "approval",
+      scheduledJobId: null,
+    });
+  });
+
+  it("workflows.list requires auth and filters to the current owner", async () => {
+    const listWorkflows = getQueryDef("workflows.list");
+    expect(listWorkflows).toBeDefined();
+
+    const userACompleted = `wf_user_a_completed_${Date.now()}`;
+    const userAWaiting = `wf_user_a_waiting_${Date.now()}`;
+    const userASleeping = `wf_user_a_sleeping_${Date.now()}`;
+    const userBRunning = `wf_user_b_running_${Date.now()}`;
+
+    await db.execute(sql`
+            INSERT INTO _gencow_workflows (
+                id,
+                name,
+                args,
+                status,
+                current_step,
+                result,
+                error,
+                retry_count,
+                max_retries,
+                max_duration_ms,
+                started_at,
+                updated_at,
+                completed_at,
+                user_id
+            )
+            VALUES
+                (
+                    ${userACompleted},
+                    'agents.sync',
+                    '{}'::jsonb,
+                    'completed',
+                    NULL,
+                    NULL,
+                    NULL,
+                    0,
+                    3,
+                    1800000,
+                    NOW() - INTERVAL '30 seconds',
+                    NOW() - INTERVAL '20 seconds',
+                    NOW() - INTERVAL '20 seconds',
+                    'workflow_user_a'
+                ),
+                (
+                    ${userAWaiting},
+                    'agents.sync',
+                    '{}'::jsonb,
+                    'pending',
+                    'wait:approval#1',
+                    NULL,
+                    NULL,
+                    0,
+                    3,
+                    1800000,
+                    NOW() - INTERVAL '10 seconds',
+                    NOW() - INTERVAL '10 seconds',
+                    NULL,
+                    'workflow_user_a'
+                ),
+                (
+                    ${userASleeping},
+                    'agents.sync',
+                    '{}'::jsonb,
+                    'pending',
+                    'sleep#1',
+                    NULL,
+                    NULL,
+                    0,
+                    3,
+                    1800000,
+                    NOW() - INTERVAL '15 seconds',
+                    NOW() - INTERVAL '12 seconds',
+                    NULL,
+                    'workflow_user_a'
+                ),
+                (
+                    ${userBRunning},
+                    'agents.sync',
+                    '{}'::jsonb,
+                    'running',
+                    'analyze',
+                    NULL,
+                    NULL,
+                    0,
+                    3,
+                    1800000,
+                    NOW() - INTERVAL '5 seconds',
+                    NOW() - INTERVAL '5 seconds',
+                    NULL,
+                    'workflow_user_b'
+                )
+        `);
+
+    const ownWorkflows = await listWorkflows!.handler(buildCtx("workflow_user_a") as any, { limit: 10 });
+    expect(ownWorkflows.map((item: any) => item.id)).toEqual([userAWaiting, userASleeping, userACompleted]);
+    expect(ownWorkflows.every((item: any) => item.name === "agents.sync")).toBe(true);
+    expect(ownWorkflows.some((item: any) => item.id === userBRunning)).toBe(false);
+    expect(ownWorkflows.find((item: any) => item.id === userAWaiting)?.derivedStatus).toBe("waiting");
+    expect(ownWorkflows.find((item: any) => item.id === userASleeping)?.derivedStatus).toBe("sleeping");
+
+    const completedOnly = await listWorkflows!.handler(buildCtx("workflow_user_a") as any, {
+      limit: 10,
+      status: "completed",
+    });
+    expect(completedOnly).toHaveLength(1);
+    expect(completedOnly[0]?.id).toBe(userACompleted);
+
+    const waitingOnly = await listWorkflows!.handler(buildCtx("workflow_user_a") as any, {
+      limit: 10,
+      status: "waiting",
+    });
+    expect(waitingOnly).toHaveLength(1);
+    expect(waitingOnly[0]?.id).toBe(userAWaiting);
+
+    const sleepingOnly = await listWorkflows!.handler(buildCtx("workflow_user_a") as any, {
+      limit: 10,
+      status: "sleeping",
+    });
+    expect(sleepingOnly).toHaveLength(1);
+    expect(sleepingOnly[0]?.id).toBe(userASleeping);
+
+    await expect(listWorkflows!.handler(buildCtx(null) as any, { limit: 10 })).rejects.toThrow(
+      "Authentication required",
+    );
+
+    await expect(
+      listWorkflows!.handler(buildCtx("workflow_user_a") as any, { limit: 10, status: "mystery" }),
+    ).rejects.toThrow('Argument "status": expected one of pending, running, completed, failed');
+  });
+});