@pikku/core 0.12.3 → 0.12.4

package/src/wirings/workflow/index.ts

@@ -1,82 +0,0 @@
-/**
- * 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

@@ -1,200 +0,0 @@
-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)
-  })
-})