@pikku/core 0.12.20 → 0.12.21

package/src/wirings/workflow/workflow-queue-workers.test.ts

@@ -0,0 +1,131 @@
+import { beforeEach, describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { resetPikkuState, pikkuState } from '../../pikku-state.js'
+import {
+  pikkuWorkflowWorkerFunc,
+  pikkuWorkflowOrchestratorFunc,
+  pikkuWorkflowSleeperFunc,
+} from './workflow-queue-workers.js'
+
+beforeEach(() => {
+  resetPikkuState()
+})
+
+describe('workflow-queue-workers', () => {
+  test('worker calls executeWorkflowStep on the workflow service', async () => {
+    const calls: unknown[][] = []
+    const rpc = { rpcWithWire: async () => ({ ok: true }) }
+
+    pikkuState(null, 'package', 'singletonServices', {
+      workflowService: {
+        executeWorkflowStep: async (...args: unknown[]) => {
+          calls.push(args)
+        },
+      },
+    } as never)
+
+    await pikkuWorkflowWorkerFunc(
+      {},
+      {
+        runId: 'run-1',
+        stepName: 'step-a',
+        rpcName: 'rpc.doThing',
+        data: { ok: true },
+      },
+      { rpc: rpc as never }
+    )
+
+    assert.deepEqual(calls, [
+      ['run-1', 'step-a', 'rpc.doThing', { ok: true }, rpc],
+    ])
+  })
+
+  test('worker throws when workflow service is missing', async () => {
+    pikkuState(null, 'package', 'singletonServices', {} as never)
+
+    await assert.rejects(
+      () =>
+        pikkuWorkflowWorkerFunc(
+          {},
+          {
+            runId: 'run-1',
+            stepName: 'step-a',
+            rpcName: 'rpc.doThing',
+            data: {},
+          },
+          { rpc: {} as never }
+        ),
+      {
+        message:
+          'Workflow service not initialized: cannot execute workflow step for runId run-1, stepName step-a',
+      }
+    )
+  })
+
+  test('orchestrator calls orchestrateWorkflow on the workflow service', async () => {
+    const calls: unknown[][] = []
+    const rpc = { rpcWithWire: async () => ({ ok: true }) }
+
+    pikkuState(null, 'package', 'singletonServices', {
+      workflowService: {
+        orchestrateWorkflow: async (...args: unknown[]) => {
+          calls.push(args)
+        },
+      },
+    } as never)
+
+    await pikkuWorkflowOrchestratorFunc(
+      {},
+      { runId: 'run-2' },
+      { rpc: rpc as never }
+    )
+
+    assert.deepEqual(calls, [['run-2', rpc]])
+  })
+
+  test('orchestrator throws when workflow service is missing', async () => {
+    pikkuState(null, 'package', 'singletonServices', {} as never)
+
+    await assert.rejects(
+      () =>
+        pikkuWorkflowOrchestratorFunc(
+          {},
+          { runId: 'run-2' },
+          { rpc: {} as never }
+        ),
+      {
+        message:
+          'Workflow service not initialized: cannot orchestrate workflow for runId run-2',
+      }
+    )
+  })
+
+  test('sleeper calls executeWorkflowSleepCompleted on the workflow service', async () => {
+    const calls: unknown[][] = []
+
+    pikkuState(null, 'package', 'singletonServices', {
+      workflowService: {
+        executeWorkflowSleepCompleted: async (...args: unknown[]) => {
+          calls.push(args)
+        },
+      },
+    } as never)
+
+    await pikkuWorkflowSleeperFunc({}, { runId: 'run-3', stepId: 'step-3' })
+
+    assert.deepEqual(calls, [['run-3', 'step-3']])
+  })
+
+  test('sleeper throws when workflow service is missing', async () => {
+    pikkuState(null, 'package', 'singletonServices', {} as never)
+
+    await assert.rejects(
+      () => pikkuWorkflowSleeperFunc({}, { runId: 'run-3', stepId: 'step-3' }),
+      {
+        message:
+          'Workflow service not initialized: cannot execute workflow sleep completed for runId run-3, stepId step-3',
+      }
+    )
+  })
+})

package/src/wirings/workflow/workflow.types.ts

@@ -191,15 +191,78 @@ export interface WorkflowRunService {
   deleteRun(id: string): Promise<boolean>
 }
 
+/**
+ * Write-only companion to `WorkflowRunService`. An executor (a
+ * `PikkuWorkflowService` subclass) can be given a mirror; every write
+ * the executor makes to its own canonical store is then forwarded here,
+ * so an external read store (e.g. a DB queried by the console UI) stays
+ * in sync with DO/Redis/etc-driven runs.
+ *
+ * Mirror failures are logged but never fail the workflow — the mirror is
+ * an index, not the source of truth.
+ */
+export interface WorkflowRunMirror {
+  createRun(
+    runId: string,
+    workflowName: string,
+    input: any,
+    inline: boolean,
+    graphHash: string,
+    wire: WorkflowRunWire,
+    options?: {
+      deterministic?: boolean
+      plannedSteps?: WorkflowPlannedStep[]
+    }
+  ): Promise<void>
+
+  updateRunStatus(
+    id: string,
+    status: WorkflowStatus,
+    output?: any,
+    error?: SerializedError
+  ): Promise<void>
+
+  insertStepState(
+    runId: string,
+    step: StepState & { stepName: string; rpcName: string | null; data: any }
+  ): Promise<void>
+
+  setStepRunning(stepId: string): Promise<void>
+  setStepScheduled(stepId: string): Promise<void>
+  setStepResult(stepId: string, result: any): Promise<void>
+  setStepChildRunId(stepId: string, childRunId: string): Promise<void>
+  setStepError(stepId: string, error: SerializedError): Promise<void>
+
+  createRetryAttempt(
+    failedStepId: string,
+    newStep: StepState & { stepName: string }
+  ): Promise<void>
+
+  setBranchTaken(stepId: string, branchKey: string): Promise<void>
+
+  updateRunState(runId: string, name: string, value: unknown): Promise<void>
+
+  upsertWorkflowVersion(
+    name: string,
+    graphHash: string,
+    graph: any,
+    source: string,
+    status?: WorkflowVersionStatus
+  ): Promise<void>
+
+  updateWorkflowVersionStatus(
+    name: string,
+    graphHash: string,
+    status: WorkflowVersionStatus
+  ): Promise<void>
+}
+
 /**
  * Core workflow definition
  */
 export type CoreWorkflow<
-  PikkuFunctionConfig extends CorePikkuFunctionConfig<
-    any,
-    any,
-    any
-  > = CorePikkuFunctionConfig<any, any, any>,
+  PikkuFunctionConfig extends CorePikkuFunctionConfig<any, any, any> =
+    CorePikkuFunctionConfig<any, any, any>,
 > = {
   /** Unique workflow name */
   name: string