@pikku/core 0.12.4 → 0.12.6

package/src/wirings/workflow/index.ts

@@ -0,0 +1,82 @@
+/**
+ * Workflow module exports
+ */
+export {
+  PikkuWorkflowService,
+  WorkflowCancelledException,
+  WorkflowSuspendedException,
+  WorkflowNotFoundError,
+  WorkflowRunNotFoundError,
+} from './pikku-workflow-service.js'
+
+// Internal registration functions (used by generated code)
+export { addWorkflow } from './dsl/workflow-runner.js'
+
+// Graph helpers (template, pikkuWorkflowGraph)
+export { template, type TemplateString } from './graph/template.js'
+export {
+  pikkuWorkflowGraph,
+  type PikkuWorkflowGraphConfig,
+  type PikkuWorkflowGraphResult,
+} from './graph/wire-workflow-graph.js'
+
+// Workflow helpers (runtime factories for HTTP handlers)
+export {
+  workflow,
+  workflowStart,
+  workflowStatus,
+  graphStart,
+} from './workflow-helpers.js'
+
+// Re-export all types from workflow.types
+export type {
+  WorkflowService,
+  WorkflowServiceConfig,
+  WorkflowRunWire,
+  WorkflowStatus,
+  WorkflowVersionStatus,
+  StepStatus,
+  WorkflowRun,
+  StepState,
+  WorkflowRunService,
+  CoreWorkflow,
+  PikkuWorkflow,
+  ContextVariable,
+  WorkflowContext,
+  WorkflowsMeta,
+  WorkflowRuntimeMeta,
+  WorkflowsRuntimeMeta,
+  WorkflowStepInput,
+  WorkflowOrchestratorInput,
+  WorkflowSleeperInput,
+} from './workflow.types.js'
+
+// Re-export DSL types
+export type {
+  WorkflowStepOptions,
+  WorkflowWireDoRPC,
+  WorkflowWireDoInline,
+  WorkflowWireSleep,
+  WorkflowWireSuspend,
+  InputSource,
+  OutputBinding,
+  RpcStepMeta,
+  SimpleCondition,
+  Condition,
+  BranchCase,
+  BranchStepMeta,
+  ParallelGroupStepMeta,
+  FanoutStepMeta,
+  ReturnStepMeta,
+  InlineStepMeta,
+  SleepStepMeta,
+  CancelStepMeta,
+  SetStepMeta,
+  SwitchCaseMeta,
+  SwitchStepMeta,
+  FilterStepMeta,
+  ArrayPredicateStepMeta,
+  WorkflowStepMeta,
+  WorkflowStepWire,
+  PikkuWorkflowWire,
+} from './workflow.types.js'

package/src/wirings/workflow/pikku-workflow-service.test.ts

@@ -0,0 +1,200 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { InMemoryWorkflowService } from '../../services/in-memory-workflow-service.js'
+import { pikkuState } from '../../pikku-state.js'
+import { addWorkflow } from './dsl/workflow-runner.js'
+import {
+  WorkflowSuspendedException,
+  type PikkuWorkflowWire,
+} from './pikku-workflow-service.js'
+
+describe('pikku-workflow-service version mismatch fallback', () => {
+  test('should fall back to stored graph for dsl workflow version mismatch', async () => {
+    const ws = new InMemoryWorkflowService()
+    const workflowName = 'testDslVersionMismatch'
+    const oldHash = 'old-hash'
+    const newHash = 'new-hash'
+
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async () => {},
+      },
+    } as any)
+
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    metaState[workflowName] = {
+      name: workflowName,
+      pikkuFuncId: workflowName,
+      source: 'dsl',
+      graphHash: newHash,
+    }
+
+    await ws.upsertWorkflowVersion(
+      workflowName,
+      oldHash,
+      {
+        name: workflowName,
+        pikkuFuncId: workflowName,
+        source: 'dsl',
+        graphHash: oldHash,
+        nodes: {
+          nodeA: { nodeId: 'nodeA', rpcName: 'doA' },
+        },
+        entryNodeIds: ['nodeA'],
+      },
+      'dsl'
+    )
+    const runId = await ws.createRun(workflowName, {}, false, oldHash, {
+      type: 'test',
+    })
+
+    await ws.runWorkflowJob(runId, {})
+
+    const step = await ws.getStepState(runId, 'nodeA')
+    const run = await ws.getRun(runId)
+    assert.notEqual(step.stepId, '')
+    assert.equal(step.status, 'pending')
+    assert.equal(run?.status, 'running')
+
+    delete metaState[workflowName]
+  })
+
+  test('should continue from stored graph version when hashes mismatch', async () => {
+    const ws = new InMemoryWorkflowService()
+    const workflowName = 'testGraphVersionMismatch'
+    const oldHash = 'old-graph-hash'
+    const newHash = 'new-graph-hash'
+
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    metaState[workflowName] = {
+      name: workflowName,
+      pikkuFuncId: workflowName,
+      source: 'graph',
+      graphHash: newHash,
+      nodes: {
+        changedNode: { nodeId: 'changedNode', rpcName: 'changedRpc' },
+      },
+      entryNodeIds: ['changedNode'],
+    }
+
+    await ws.upsertWorkflowVersion(
+      workflowName,
+      oldHash,
+      {
+        name: workflowName,
+        pikkuFuncId: workflowName,
+        source: 'graph',
+        graphHash: oldHash,
+        nodes: {},
+        entryNodeIds: [],
+      },
+      'graph'
+    )
+
+    const runId = await ws.createRun(workflowName, {}, false, oldHash, {
+      type: 'test',
+    })
+    await ws.runWorkflowJob(runId, {})
+
+    const run = await ws.getRun(runId)
+    assert.equal(run?.status, 'completed')
+
+    delete metaState[workflowName]
+  })
+})
+
+describe('pikku-workflow-service executeWorkflowStep', () => {
+  test('should set pending step to running before succeeding', async () => {
+    const ws = new InMemoryWorkflowService()
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async () => {},
+      },
+    } as any)
+
+    const runId = await ws.createRun(
+      'pending-step-running',
+      {},
+      false,
+      'hash',
+      { type: 'test' }
+    )
+    await ws.insertStepState(runId, 'stepA', 'doStepA', { a: 1 })
+
+    await ws.executeWorkflowStep(
+      runId,
+      'stepA',
+      'doStepA',
+      { a: 1 },
+      {
+        rpcWithWire: async () => ({ ok: true }),
+      }
+    )
+
+    const step = await ws.getStepState(runId, 'stepA')
+    assert.equal(step.status, 'succeeded')
+    assert.ok(step.runningAt instanceof Date)
+  })
+})
+
+describe('pikku-workflow-service suspend', () => {
+  test('should set run status to suspended when workflow.suspend is called', async () => {
+    const ws = new InMemoryWorkflowService()
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async () => {},
+      },
+    } as any)
+
+    const workflowName = 'testSuspendWorkflow'
+    const graphHash = 'suspend-hash'
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    metaState[workflowName] = {
+      name: workflowName,
+      pikkuFuncId: workflowName,
+      source: 'dsl',
+      graphHash,
+    }
+    const functionMetaState = pikkuState(null, 'function', 'meta')
+    functionMetaState[workflowName] = {
+      name: workflowName,
+      sessionless: true,
+      permissions: [],
+    } as any
+
+    addWorkflow(workflowName, {
+      func: async (
+        _services: any,
+        _data: any,
+        { workflow }: { workflow: PikkuWorkflowWire }
+      ) => {
+        await workflow.suspend('Needs approval')
+        return { ok: true }
+      },
+    })
+
+    const runId = await ws.createRun(workflowName, {}, false, graphHash, {
+      type: 'test',
+    })
+    await assert.rejects(
+      ws.runWorkflowJob(runId, {}),
+      (error: unknown) => error instanceof WorkflowSuspendedException
+    )
+
+    const run = await ws.getRun(runId)
+    assert.equal(run?.status, 'suspended')
+    assert.equal(run?.error?.code, 'WORKFLOW_SUSPENDED')
+    assert.equal(run?.error?.message, 'Needs approval')
+
+    await ws.resumeWorkflow(runId)
+    await ws.runWorkflowJob(runId, {})
+    const resumedRun = await ws.getRun(runId)
+    assert.equal(resumedRun?.status, 'completed')
+    assert.deepEqual(resumedRun?.output, { ok: true })
+
+    delete metaState[workflowName]
+    delete functionMetaState[workflowName]
+    pikkuState(null, 'workflows', 'registrations').delete(workflowName)
+  })
+})