@pikku/core 0.11.2 → 0.12.0

package/src/wirings/workflow/workflow-utils.ts

@@ -1,120 +0,0 @@
-import { pikkuState } from '../../pikku-state.js'
-import { NotFoundError } from '../../errors/errors.js'
-import {
-  PikkuWire,
-  CreateWireServices,
-  CoreSingletonServices,
-  CoreServices,
-  CoreUserSession,
-} from '../../types/core.types.js'
-import { HTTPWiringMeta } from '../http/http.types.js'
-import { ContextAwareRPCService } from '../rpc/rpc-runner.js'
-
-/**
- * Result of finding a workflow by HTTP wire
- */
-export interface WorkflowHttpMatch {
-  workflowName: string
-  startNode?: string
-}
-
-/**
- * Find workflow name by matching route and method against workflow wires
- */
-export const findWorkflowByHttpWire = (
-  route: string,
-  method: string
-): WorkflowHttpMatch | undefined => {
-  const wirings = pikkuState(null, 'workflows', 'wirings')
-  const graphWirings = pikkuState(null, 'workflows', 'graphWirings')
-
-  // Check DSL workflow wirings
-  for (const [, wiring] of wirings) {
-    const httpWires = wiring.wires?.http
-    if (httpWires) {
-      const matchedWire = httpWires.find(
-        (w) => w.route === route && w.method === method
-      )
-      if (matchedWire) {
-        const meta = pikkuState(null, 'workflows', 'meta')
-        for (const [name, workflowMeta] of Object.entries(meta)) {
-          if (workflowMeta.source !== 'graph') {
-            const registrations = pikkuState(null, 'workflows', 'registrations')
-            if (registrations.has(name)) {
-              return { workflowName: name, startNode: matchedWire.startNode }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Check graph workflow wirings
-  for (const [, wiring] of graphWirings) {
-    const httpWires = wiring.wires?.http
-    if (httpWires) {
-      const matchedWire = httpWires.find(
-        (w) => w.route === route && w.method === method
-      )
-      if (matchedWire) {
-        const meta = pikkuState(null, 'workflows', 'meta')
-        for (const [name, workflowMeta] of Object.entries(meta)) {
-          if (workflowMeta.source === 'graph') {
-            return { workflowName: name, startNode: matchedWire.startNode }
-          }
-        }
-      }
-    }
-  }
-
-  return undefined
-}
-
-/**
- * Start a workflow triggered by an HTTP wire
- * The workflow is responsible for handling the HTTP response
- */
-export const startWorkflowByHttpWire = async (
-  singletonServices: CoreSingletonServices,
-  createWireServices:
-    | CreateWireServices<
-        CoreSingletonServices,
-        CoreServices<CoreSingletonServices>,
-        CoreUserSession
-      >
-    | undefined,
-  matchedRoute: {
-    matchedPath: any
-    params: any
-    route: any
-    meta: HTTPWiringMeta
-  },
-  wire: PikkuWire
-): Promise<void> => {
-  const { meta } = matchedRoute
-
-  const match = findWorkflowByHttpWire(meta.route, meta.method)
-  if (!match) {
-    throw new NotFoundError(
-      `No workflow found for route ${meta.method.toUpperCase()} ${meta.route}`
-    )
-  }
-
-  const workflowService = singletonServices.workflowService
-  if (!workflowService) {
-    throw new Error('WorkflowService not available')
-  }
-
-  const data = await wire.http!.request!.data()
-
-  const wireServices = createWireServices?.(singletonServices, wire)
-  const rpcService = new ContextAwareRPCService(
-    { ...singletonServices, ...wireServices },
-    wire,
-    {}
-  )
-  await workflowService.startWorkflow(match.workflowName, data, rpcService, {
-    inline: true,
-    startNode: match.startNode,
-  })
-}

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

@@ -10,6 +10,7 @@ export type {
   WorkflowWireDoRPC,
   WorkflowWireDoInline,
   WorkflowWireSleep,
+  WorkflowWireSuspend,
   InputSource,
   OutputBinding,
   RpcStepMeta,
@@ -35,6 +36,12 @@ export type {
 
 import type { WorkflowStepMeta } from './dsl/workflow-dsl.types.js'
 
+export interface WorkflowRunWire {
+  type: string
+  id?: string
+  parentRunId?: string
+}
+
 export interface WorkflowServiceConfig {
   retries: number
   retryDelay: number
@@ -43,94 +50,15 @@ export interface WorkflowServiceConfig {
   sleeperRPCName: string
 }
 
-/**
- * HTTP wire configuration for workflows
- */
-export interface WorkflowHTTPWire {
-  route: string
-  method: 'get' | 'post' | 'put' | 'patch' | 'delete'
-  startNode: string
-}
-
-/**
- * Channel wire configuration for workflows
- */
-export interface WorkflowChannelWire {
-  name: string
-  onConnect?: string
-  onDisconnect?: string
-  onMessage?: string
-}
-
-/**
- * Queue wire configuration for workflows
- */
-export interface WorkflowQueueWire {
-  name: string
-  startNode: string
-}
-
-/**
- * CLI wire configuration for workflows
- */
-export interface WorkflowCliWire {
-  command: string
-  startNode: string
-}
-
-/**
- * MCP wire configurations for workflows
- */
-export interface WorkflowMcpWires {
-  tool?: Array<{ name: string; startNode: string }>
-  prompt?: Array<{ name: string; startNode: string }>
-  resource?: Array<{ uri: string; startNode: string }>
-}
-
-/**
- * Schedule wire configuration for workflows
- */
-export interface WorkflowScheduleWire {
-  cron?: string
-  interval?: string
-  startNode: string
-}
-
-/**
- * Trigger wire configuration for workflows
- */
-export interface WorkflowTriggerWire {
-  name: string
-  startNode: string
-}
-
-/**
- * Wire configuration for workflows
- * Defines how a workflow can be triggered
- */
-export interface WorkflowWires {
-  /** API entry point - node ID for startWorkflow() calls */
-  api?: string
-  /** HTTP triggers */
-  http?: WorkflowHTTPWire[]
-  /** Channel triggers */
-  channel?: WorkflowChannelWire[]
-  /** Queue triggers */
-  queue?: WorkflowQueueWire[]
-  /** CLI triggers */
-  cli?: WorkflowCliWire[]
-  /** MCP triggers (tool, prompt, resource) */
-  mcp?: WorkflowMcpWires
-  /** Schedule triggers */
-  schedule?: WorkflowScheduleWire[]
-  /** Named trigger wires */
-  trigger?: WorkflowTriggerWire[]
-}
-
 /**
  * Workflow run status
  */
-export type WorkflowStatus = 'running' | 'completed' | 'failed' | 'cancelled'
+export type WorkflowStatus =
+  | 'running'
+  | 'suspended'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
 
 /**
  * Workflow step status
@@ -141,6 +69,7 @@ export type StepStatus =
   | 'scheduled'
   | 'succeeded'
   | 'failed'
+  | 'suspended'
 
 /**
  * Workflow run representation
@@ -160,6 +89,10 @@ export interface WorkflowRun {
   error?: SerializedError
   /** If true, workflow executes inline without queues */
   inline?: boolean
+  /** Graph hash of the workflow definition at run creation time */
+  graphHash?: string
+  /** Wire origin info (how this run was started) */
+  wire: WorkflowRunWire
   /** Creation timestamp */
   createdAt: Date
   /** Last update timestamp */
@@ -198,6 +131,28 @@ export interface StepState {
   failedAt?: Date
 }
 
+export interface WorkflowRunService {
+  listRuns(options?: {
+    workflowName?: string
+    status?: string
+    limit?: number
+    offset?: number
+  }): Promise<WorkflowRun[]>
+  getRun(id: string): Promise<WorkflowRun | null>
+  getRunSteps(
+    runId: string
+  ): Promise<
+    Array<StepState & { stepName: string; rpcName?: string; data?: any }>
+  >
+  getRunHistory(runId: string): Promise<Array<StepState & { stepName: string }>>
+  getDistinctWorkflowNames(): Promise<string[]>
+  getWorkflowVersion(
+    name: string,
+    graphHash: string
+  ): Promise<{ graph: any; source: string } | null>
+  deleteRun(id: string): Promise<boolean>
+}
+
 /**
  * Core workflow definition
  */
@@ -255,7 +210,7 @@ export type WorkflowContext = Record<string, ContextVariable>
 export type WorkflowsMeta = Record<
   string,
   CommonWireMeta & {
-    workflowName: string
+    name: string
     steps: WorkflowStepMeta[]
     context?: WorkflowContext
     dsl?: boolean
@@ -271,19 +226,19 @@ export interface WorkflowRuntimeMeta {
   /** Workflow name (used as key in registrations) */
   name: string
   /** Pikku function name (for execution) */
-  pikkuFuncName: string
+  pikkuFuncId: string
   /** Source type: 'dsl' (serializable), 'complex' (has inline steps), 'graph' */
-  source?: 'dsl' | 'complex' | 'graph'
+  source: 'dsl' | 'complex' | 'graph'
   /** Optional description */
   description?: string
   /** Tags for organization */
   tags?: string[]
-  /** Wires - how the workflow is triggered */
-  wires?: WorkflowWires
   /** Serialized nodes */
   nodes?: Record<string, any>
   /** Entry node IDs for graph workflows (computed at build time) */
   entryNodeIds?: string[]
+  /** Hash of graph topology (nodes, edges, input mappings) */
+  graphHash?: string
 }
 
 /**