@pikku/core 0.11.2 → 0.12.1

package/src/wirings/workflow/graph/index.ts

@@ -1,3 +1,14 @@
-export * from './workflow-graph.types.js'
-export * from './graph-node.js'
-export * from './graph-runner.js'
+export {
+  continueGraph,
+  executeGraphStep,
+  onGraphNodeComplete,
+  runFromMeta,
+  runWorkflowGraph,
+} from './graph-runner.js'
+export { template } from './template.js'
+export type { TemplateString } from './template.js'
+export {
+  pikkuWorkflowGraph,
+  type PikkuWorkflowGraphConfig,
+  type PikkuWorkflowGraphResult,
+} from './wire-workflow-graph.js'

package/src/wirings/workflow/graph/template.test.ts

@@ -0,0 +1,49 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { template } from './template.js'
+
+describe('template', () => {
+  test('should parse a simple template with one placeholder', () => {
+    const result = template('Hello $0!', [{ $ref: 'greeting' }])
+    assert.deepStrictEqual(result.$template.parts, ['Hello ', '!'])
+    assert.deepStrictEqual(result.$template.expressions, [{ $ref: 'greeting' }])
+  })
+
+  test('should parse template with multiple placeholders', () => {
+    const result = template('$0 and $1', [{ $ref: 'a' }, { $ref: 'b' }])
+    assert.deepStrictEqual(result.$template.parts, ['', ' and ', ''])
+    assert.strictEqual(result.$template.expressions.length, 2)
+    assert.strictEqual(result.$template.expressions[0].$ref, 'a')
+    assert.strictEqual(result.$template.expressions[1].$ref, 'b')
+  })
+
+  test('should preserve path in references', () => {
+    const result = template('Value: $0', [{ $ref: 'node1', path: 'data.name' }])
+    assert.deepStrictEqual(result.$template.expressions[0], {
+      $ref: 'node1',
+      path: 'data.name',
+    })
+  })
+
+  test('should handle template with no placeholders', () => {
+    const result = template('No placeholders here', [])
+    assert.deepStrictEqual(result.$template.parts, ['No placeholders here'])
+    assert.deepStrictEqual(result.$template.expressions, [])
+  })
+
+  test('should handle out-of-range ref index as unknown', () => {
+    const result = template('$5', [{ $ref: 'a' }])
+    assert.deepStrictEqual(result.$template.expressions[0], { $ref: 'unknown' })
+  })
+
+  test('should handle adjacent placeholders', () => {
+    const result = template('$0$1', [{ $ref: 'a' }, { $ref: 'b' }])
+    assert.deepStrictEqual(result.$template.parts, ['', '', ''])
+    assert.strictEqual(result.$template.expressions.length, 2)
+  })
+
+  test('should omit path when not provided', () => {
+    const result = template('$0', [{ $ref: 'node' }])
+    assert.strictEqual(result.$template.expressions[0].path, undefined)
+  })
+})

package/src/wirings/workflow/graph/template.ts

@@ -0,0 +1,42 @@
+export type TemplateString = {
+  $template: {
+    parts: string[]
+    expressions: Array<{ $ref: string; path?: string }>
+  }
+} & { __brand: 'TemplateString' }
+
+export function template(
+  templateStr: string,
+  refs: Array<{ $ref: string; path?: string }>
+): TemplateString {
+  const parts: string[] = []
+  const expressions: Array<{ $ref: string; path?: string }> = []
+
+  const regex = /\$(\d+)/g
+  let lastIndex = 0
+  let match
+
+  while ((match = regex.exec(templateStr)) !== null) {
+    parts.push(templateStr.slice(lastIndex, match.index))
+
+    const refIndex = parseInt(match[1]!, 10)
+    const refValue = refs[refIndex]
+    if (refValue) {
+      const expr: { $ref: string; path?: string } = { $ref: refValue.$ref }
+      if (refValue.path) {
+        expr.path = refValue.path
+      }
+      expressions.push(expr)
+    } else {
+      expressions.push({ $ref: 'unknown' })
+    }
+
+    lastIndex = regex.lastIndex
+  }
+
+  parts.push(templateStr.slice(lastIndex))
+
+  return {
+    $template: { parts, expressions },
+  } as TemplateString
+}

package/src/wirings/workflow/graph/wire-workflow-graph.ts

@@ -0,0 +1,29 @@
+export interface PikkuWorkflowGraphConfig<
+  FuncMap extends Record<string, string>,
+  T,
+> {
+  disabled?: true
+  name?: string
+  description?: string
+  tags?: string[]
+  nodes: FuncMap
+  config?: T
+}
+
+export interface PikkuWorkflowGraphResult {
+  __type: 'pikkuWorkflowGraph'
+  name?: string
+  description?: string
+  tags?: string[]
+}
+
+export function pikkuWorkflowGraph<
+  const FuncMap extends Record<string, string>,
+>(config: PikkuWorkflowGraphConfig<FuncMap, any>): PikkuWorkflowGraphResult {
+  return {
+    __type: 'pikkuWorkflowGraph',
+    name: config.name,
+    description: config.description,
+    tags: config.tags,
+  }
+}

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

@@ -67,28 +67,6 @@ export interface GraphNodeConfig<NodeIds extends string = string> {
   onError?: NodeIds | NodeIds[]
 }
 
-// Import unified wire types from workflow module
-import type { WorkflowWires } from '../workflow.types.js'
-
-export type { WorkflowWires }
-
-/**
- * Workflow graph definition (internal use)
- */
-export interface WorkflowGraphDefinition<
-  Nodes extends Record<string, GraphNodeConfig<string>> = Record<
-    string,
-    GraphNodeConfig
-  >,
-> {
-  /** Unique workflow name */
-  name: string
-  /** Wire configuration */
-  wires: WorkflowWires
-  /** Graph nodes */
-  graph: Nodes
-}
-
 /**
  * Graph wire context - available to functions running in a workflow graph
  */

package/src/wirings/workflow/index.ts

@@ -4,30 +4,40 @@
 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'
-export { addWorkflowGraph } from './graph/graph-runner.js'
 
-// Unified wireWorkflow function
-export { wireWorkflow } from './wire-workflow.js'
-export type {
-  WorkflowDefinition,
-  WorkflowDefinitionFunc,
-  WorkflowDefinitionGraph,
-} from './wire-workflow.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,
-  WorkflowHTTPWire,
-  WorkflowWires,
+  WorkflowRunWire,
   WorkflowStatus,
   StepStatus,
   WorkflowRun,
   StepState,
+  WorkflowRunService,
   CoreWorkflow,
   PikkuWorkflow,
   ContextVariable,
@@ -46,6 +56,7 @@ export type {
   WorkflowWireDoRPC,
   WorkflowWireDoInline,
   WorkflowWireSleep,
+  WorkflowWireSuspend,
   InputSource,
   OutputBinding,
   RpcStepMeta,

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)
+  })
+})