@pikku/inspector 0.11.1 → 0.12.0

package/src/utils/workflow/dsl/index.ts

@@ -0,0 +1,11 @@
+/**
+ * DSL (Domain Specific Language) workflow extraction exports
+ */
+export { extractDSLWorkflow } from './extract-dsl-workflow.js'
+export {
+  deserializeDslWorkflow,
+  deserializeGraphWorkflow,
+  deserializeAllDslWorkflows,
+} from './deserialize-dsl-workflow.js'
+export * from './patterns.js'
+export * from './validation.js'

package/src/{workflow → utils/workflow/dsl}/patterns.ts

@@ -42,6 +42,94 @@ export function isWorkflowSleepCall(
   )
 }
 
+/**
+ * Check if a throw statement throws WorkflowCancelledException
+ * Matches: throw new WorkflowCancelledException(...) or throw WorkflowCancelledException(...)
+ */
+export function isThrowCancelException(node: ts.ThrowStatement): boolean {
+  const expr = node.expression
+  if (!expr) return false
+
+  // Check for: throw new WorkflowCancelledException(...)
+  if (ts.isNewExpression(expr)) {
+    if (ts.isIdentifier(expr.expression)) {
+      return expr.expression.text === 'WorkflowCancelledException'
+    }
+  }
+
+  // Check for: throw WorkflowCancelledException(...) - function call style
+  if (ts.isCallExpression(expr)) {
+    if (ts.isIdentifier(expr.expression)) {
+      return expr.expression.text === 'WorkflowCancelledException'
+    }
+  }
+
+  return false
+}
+
+/**
+ * Extract the reason string from a throw WorkflowCancelledException statement
+ */
+export function extractCancelReason(
+  node: ts.ThrowStatement,
+  checker: ts.TypeChecker
+): string | undefined {
+  const expr = node.expression
+  if (!expr) return undefined
+
+  let args: ts.NodeArray<ts.Expression> | undefined
+
+  if (ts.isNewExpression(expr) && expr.arguments) {
+    args = expr.arguments
+  } else if (ts.isCallExpression(expr)) {
+    args = expr.arguments
+  }
+
+  if (args && args.length > 0) {
+    const firstArg = args[0]
+    if (ts.isStringLiteral(firstArg)) {
+      return firstArg.text
+    }
+    // For template literals or other expressions, return the source text
+    return firstArg.getText()
+  }
+
+  return undefined
+}
+
+/**
+ * Check if a call expression is array.filter()
+ */
+export function isArrayFilter(node: ts.CallExpression): boolean {
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return false
+  }
+
+  return node.expression.name.text === 'filter'
+}
+
+/**
+ * Check if a call expression is array.some()
+ */
+export function isArraySome(node: ts.CallExpression): boolean {
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return false
+  }
+
+  return node.expression.name.text === 'some'
+}
+
+/**
+ * Check if a call expression is array.every()
+ */
+export function isArrayEvery(node: ts.CallExpression): boolean {
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return false
+  }
+
+  return node.expression.name.text === 'every'
+}
+
 /**
  * Check if an expression is Promise.all(array.map(...))
  */
@@ -118,6 +206,24 @@ export function isSequentialFanout(node: ts.ForOfStatement): boolean {
   return true
 }
 
+/**
+ * Extract full source path from an expression (e.g., data.memberEmails)
+ */
+function extractSourcePath(expr: ts.Expression): string | null {
+  if (ts.isIdentifier(expr)) {
+    return expr.text
+  }
+
+  if (ts.isPropertyAccessExpression(expr)) {
+    const base = extractSourcePath(expr.expression)
+    if (base) {
+      return `${base}.${expr.name.text}`
+    }
+  }
+
+  return null
+}
+
 /**
  * Extract the variable name from a for..of statement
  */
@@ -135,17 +241,8 @@ export function extractForOfVariable(
 
   const itemVar = decl.name.text
 
-  // Extract source variable
-  let sourceVar: string | null = null
-  if (ts.isIdentifier(node.expression)) {
-    sourceVar = node.expression.text
-  } else if (
-    ts.isPropertyAccessExpression(node.expression) &&
-    ts.isIdentifier(node.expression.expression)
-  ) {
-    // Handle data.memberEmails
-    sourceVar = node.expression.expression.text
-  }
+  // Extract source variable with full path (e.g., data.memberEmails)
+  const sourceVar = extractSourcePath(node.expression)
 
   if (!sourceVar) {
     return null

package/src/{workflow → utils/workflow/dsl}/validation.ts

@@ -16,8 +16,10 @@ export interface ValidationError {
  * - VariableStatement (const/let declarations)
  * - ExpressionStatement (await workflow.do, await workflow.sleep, await Promise.all)
  * - IfStatement (branches)
+ * - SwitchStatement (switch/case)
  * - ForOfStatement (sequential fanout)
  * - ReturnStatement
+ * - ThrowStatement (for WorkflowCancelledException)
  * - Block (containers)
  */
 export function validateNoDisallowedPatterns(node: ts.Node): ValidationError[] {
@@ -29,8 +31,10 @@ export function validateNoDisallowedPatterns(node: ts.Node): ValidationError[] {
         ts.isVariableStatement(statement) ||
         ts.isExpressionStatement(statement) ||
         ts.isIfStatement(statement) ||
+        ts.isSwitchStatement(statement) ||
         ts.isForOfStatement(statement) ||
-        ts.isReturnStatement(statement)
+        ts.isReturnStatement(statement) ||
+        ts.isThrowStatement(statement)
       ) {
         // Allowed statement type - recurse into it
         visitNode(statement)
@@ -38,7 +42,7 @@ export function validateNoDisallowedPatterns(node: ts.Node): ValidationError[] {
         // Unknown/disallowed statement type
         const nodeType = ts.SyntaxKind[statement.kind]
         errors.push({
-          message: `Statement type '${nodeType}' is not allowed in simple workflows. Allowed: const/let, if/else, for..of, return, and workflow calls. If this should be supported, please report the node type: ${nodeType}`,
+          message: `Statement type '${nodeType}' is not allowed in simple workflows. Allowed: const/let, if/else, switch/case, for..of, return, throw, and workflow calls. If this should be supported, please report the node type: ${nodeType}`,
           node: statement,
         })
       }
@@ -109,7 +113,30 @@ export function validateNoDisallowedPatterns(node: ts.Node): ValidationError[] {
 export function validateAwaitedCalls(node: ts.Node): ValidationError[] {
   const errors: ValidationError[] = []
 
-  function visit(node: ts.Node, parentIsAwait: boolean = false) {
+  function visit(
+    node: ts.Node,
+    parentIsAwait: boolean = false,
+    insidePromiseAll: boolean = false
+  ) {
+    // Check if this is Promise.all(...) first, before checking for workflow calls
+    if (
+      ts.isCallExpression(node) &&
+      ts.isPropertyAccessExpression(node.expression)
+    ) {
+      const propAccess = node.expression
+      if (
+        propAccess.name.text === 'all' &&
+        ts.isIdentifier(propAccess.expression) &&
+        propAccess.expression.text === 'Promise'
+      ) {
+        // console.log('[DEBUG] Found Promise.all, setting insidePromiseAll=true')
+        // Visit children with insidePromiseAll = true
+        ts.forEachChild(node, (child) => visit(child, parentIsAwait, true))
+        return
+      }
+    }
+
+    // Now check for workflow calls
     if (ts.isCallExpression(node)) {
       if (ts.isPropertyAccessExpression(node.expression)) {
         const propAccess = node.expression
@@ -118,7 +145,7 @@ export function validateAwaitedCalls(node: ts.Node): ValidationError[] {
           ts.isIdentifier(propAccess.expression) &&
           propAccess.expression.text === 'workflow'
         ) {
-          if (!parentIsAwait) {
+          if (!parentIsAwait && !insidePromiseAll) {
             errors.push({
               message: `workflow.${propAccess.name.text}() must be awaited`,
               node,
@@ -130,10 +157,10 @@ export function validateAwaitedCalls(node: ts.Node): ValidationError[] {
     }
 
     if (ts.isAwaitExpression(node)) {
-      // Mark child as awaited
-      ts.forEachChild(node.expression, (child) => visit(child, true))
+      // Visit the expression itself with parentIsAwait=true
+      visit(node.expression, true, insidePromiseAll)
     } else {
-      ts.forEachChild(node, (child) => visit(child, false))
+      ts.forEachChild(node, (child) => visit(child, false, insidePromiseAll))
     }
   }
 

package/src/utils/workflow/graph/convert-dsl-to-graph.ts

@@ -0,0 +1,422 @@
+/**
+ * Converts DSL (Domain Specific Language) step-based format to graph node format
+ */
+import type { WorkflowStepMeta, WorkflowsMeta } from '@pikku/core/workflow'
+import type {
+  SerializedGraphNode,
+  SerializedWorkflowGraph,
+  FunctionNode,
+  FlowNode,
+  DataRef,
+} from './workflow-graph.types.js'
+
+function makeNodeId(
+  step: WorkflowStepMeta,
+  index: number,
+  prefix: string
+): string {
+  if ('stepName' in step && step.stepName) {
+    return step.stepName
+  }
+  return `${prefix}_${index}`
+}
+
+/**
+ * Check if a node is a terminal flow (no next step should follow)
+ */
+function isTerminalFlow(node: SerializedGraphNode): boolean {
+  if ('flow' in node) {
+    // Cancel and return are terminal flows - they end execution
+    return node.flow === 'cancel' || node.flow === 'return'
+  }
+  return false
+}
+
+/**
+ * Convert InputSource to DataRef
+ */
+function convertInputSource(source: {
+  from: string
+  path?: string
+  name?: string
+  value?: unknown
+  parts?: string[]
+  expressions?: unknown[]
+}): unknown | DataRef {
+  if (source.from === 'literal') {
+    return source.value
+  }
+  if (source.from === 'input') {
+    return { $ref: 'trigger', path: source.path }
+  }
+  if (source.from === 'outputVar') {
+    return { $ref: source.name!, path: source.path }
+  }
+  if (source.from === 'item') {
+    return { $ref: '$item', path: source.path }
+  }
+  if (source.from === 'stateVar') {
+    return { $state: source.name!, path: source.path }
+  }
+  if (source.from === 'template') {
+    return {
+      $template: {
+        parts: source.parts,
+        expressions: source.expressions?.map((expr) =>
+          convertInputSource(expr as any)
+        ),
+      },
+    }
+  }
+  return source.value
+}
+
+/**
+ * Convert a single DSL step to graph node(s)
+ */
+function convertStepToNode(
+  step: WorkflowStepMeta,
+  index: number,
+  steps: WorkflowStepMeta[],
+  nodeIdPrefix: string = 'step'
+): SerializedGraphNode[] {
+  const nodeId = makeNodeId(step, index, nodeIdPrefix)
+  const nextNodeId =
+    index < steps.length - 1
+      ? makeNodeId(steps[index + 1], index + 1, nodeIdPrefix)
+      : undefined
+
+  switch (step.type) {
+    case 'rpc': {
+      const node: FunctionNode = {
+        nodeId,
+        rpcName: step.rpcName,
+        next: nextNodeId,
+      }
+      if (step.inputs) {
+        if (step.inputs === 'passthrough') {
+          // Entire data is passed through - store as reference to trigger
+          node.input = { $passthrough: { $ref: 'trigger' } }
+        } else {
+          node.input = {}
+          for (const [key, source] of Object.entries(step.inputs)) {
+            node.input[key] = convertInputSource(source as any)
+          }
+        }
+      }
+      if (step.outputVar) {
+        node.outputVar = step.outputVar
+      }
+      if (step.options) {
+        node.options = {
+          retries: step.options.retries,
+          retryDelay: step.options.retryDelay?.toString(),
+        }
+      }
+      return [node]
+    }
+
+    case 'sleep': {
+      const node: FlowNode = {
+        nodeId,
+        flow: 'sleep',
+        duration: step.duration,
+        next: nextNodeId,
+      }
+      return [node]
+    }
+
+    case 'inline': {
+      const node: FlowNode = {
+        nodeId,
+        flow: 'inline',
+        description: step.description,
+        next: nextNodeId,
+      }
+      return [node]
+    }
+
+    case 'branch': {
+      // Convert all branch conditions (if/else-if chain)
+      const branchNodes: SerializedGraphNode[] = []
+      const branches: Array<{
+        condition: unknown
+        entry: string
+      }> = []
+
+      for (let i = 0; i < step.branches.length; i++) {
+        const branchSteps = convertStepsToNodes(
+          step.branches[i].steps,
+          `${nodeId}_branch${i}`
+        )
+        if (branchSteps.length > 0) {
+          branches.push({
+            condition: step.branches[i].condition,
+            entry: branchSteps[0].nodeId,
+          })
+          // Link last branch node back to next (unless terminal flow)
+          if (nextNodeId) {
+            const lastBranch = branchSteps[branchSteps.length - 1]
+            if (!lastBranch.next && !isTerminalFlow(lastBranch))
+              lastBranch.next = nextNodeId
+          }
+          branchNodes.push(...branchSteps)
+        }
+      }
+
+      // Convert else branch
+      const elseNodes = step.elseSteps
+        ? convertStepsToNodes(step.elseSteps, `${nodeId}_else`)
+        : []
+      if (elseNodes.length > 0 && nextNodeId) {
+        const lastElse = elseNodes[elseNodes.length - 1]
+        if (!lastElse.next && !isTerminalFlow(lastElse))
+          lastElse.next = nextNodeId
+      }
+
+      const node: FlowNode = {
+        nodeId,
+        flow: 'branch',
+        branches,
+        elseEntry: elseNodes.length > 0 ? elseNodes[0].nodeId : undefined,
+        next: nextNodeId,
+      }
+
+      return [node, ...branchNodes, ...elseNodes]
+    }
+
+    case 'switch': {
+      const caseNodes: SerializedGraphNode[] = []
+      const cases: Array<{
+        value?: unknown
+        expression?: string
+        entry: string
+      }> = []
+
+      for (let i = 0; i < step.cases.length; i++) {
+        const caseSteps = convertStepsToNodes(
+          step.cases[i].steps,
+          `${nodeId}_case${i}`
+        )
+        if (caseSteps.length > 0) {
+          cases.push({
+            value: step.cases[i].value,
+            expression: step.cases[i].expression,
+            entry: caseSteps[0].nodeId,
+          })
+          // Link last case node to next (unless terminal flow)
+          if (nextNodeId) {
+            const lastCase = caseSteps[caseSteps.length - 1]
+            if (!lastCase.next && !isTerminalFlow(lastCase))
+              lastCase.next = nextNodeId
+          }
+          caseNodes.push(...caseSteps)
+        }
+      }
+
+      let defaultEntry: string | undefined
+      if (step.defaultSteps) {
+        const defaultNodes = convertStepsToNodes(
+          step.defaultSteps,
+          `${nodeId}_default`
+        )
+        if (defaultNodes.length > 0) {
+          defaultEntry = defaultNodes[0].nodeId
+          // Link last default node to next (unless terminal flow)
+          if (nextNodeId) {
+            const lastDefault = defaultNodes[defaultNodes.length - 1]
+            if (!lastDefault.next && !isTerminalFlow(lastDefault))
+              lastDefault.next = nextNodeId
+          }
+          caseNodes.push(...defaultNodes)
+        }
+      }
+
+      const node: FlowNode = {
+        nodeId,
+        flow: 'switch',
+        expression: step.expression,
+        cases,
+        defaultEntry,
+        next: nextNodeId,
+      }
+
+      return [node, ...caseNodes]
+    }
+
+    case 'parallel': {
+      // Convert children to nodes
+      const childNodes: SerializedGraphNode[] = []
+      const childEntries: string[] = []
+
+      for (let i = 0; i < step.children.length; i++) {
+        const childSteps = convertStepToNode(
+          step.children[i],
+          i,
+          step.children,
+          `${nodeId}_child`
+        )
+        if (childSteps.length > 0) {
+          childEntries.push(childSteps[0].nodeId)
+          childNodes.push(...childSteps)
+        }
+      }
+
+      const node: FlowNode = {
+        nodeId,
+        flow: 'parallel',
+        children: childEntries,
+        next: nextNodeId,
+      }
+
+      return [node, ...childNodes]
+    }
+
+    case 'fanout': {
+      // Convert child step
+      const childNodes = convertStepToNode(
+        step.child,
+        0,
+        [step.child],
+        `${nodeId}_item`
+      )
+
+      const node: FlowNode = {
+        nodeId,
+        flow: 'fanout',
+        sourceVar: step.sourceVar,
+        itemVar: step.itemVar,
+        mode: step.mode,
+        childEntry: childNodes.length > 0 ? childNodes[0].nodeId : undefined,
+        timeBetween: step.timeBetween,
+        next: nextNodeId,
+      }
+
+      return [node, ...childNodes]
+    }
+
+    case 'filter': {
+      const node: FlowNode = {
+        nodeId,
+        flow: 'filter',
+        sourceVar: step.sourceVar,
+        itemVar: step.itemVar,
+        condition: step.condition,
+        outputVar: step.outputVar,
+        next: nextNodeId,
+      }
+      return [node]
+    }
+
+    case 'arrayPredicate': {
+      const node: FlowNode = {
+        nodeId,
+        flow: 'arrayPredicate',
+        mode: step.mode,
+        sourceVar: step.sourceVar,
+        itemVar: step.itemVar,
+        condition: step.condition,
+        outputVar: step.outputVar,
+        next: nextNodeId,
+      }
+      return [node]
+    }
+
+    case 'return': {
+      const node: FlowNode = {
+        nodeId,
+        flow: 'return',
+        outputs: step.outputs,
+      }
+      return [node]
+    }
+
+    case 'cancel': {
+      const node: FlowNode = {
+        nodeId,
+        flow: 'cancel',
+        reason: step.reason,
+      }
+      return [node]
+    }
+
+    case 'set': {
+      const node: FlowNode = {
+        nodeId,
+        flow: 'set',
+        variable: step.variable,
+        value: step.value,
+        next: nextNodeId,
+      }
+      return [node]
+    }
+
+    default:
+      return []
+  }
+}
+
+/**
+ * Convert array of steps to graph nodes
+ */
+function convertStepsToNodes(
+  steps: WorkflowStepMeta[],
+  nodeIdPrefix: string = 'step'
+): SerializedGraphNode[] {
+  const allNodes: SerializedGraphNode[] = []
+
+  for (let i = 0; i < steps.length; i++) {
+    const nodes = convertStepToNode(steps[i], i, steps, nodeIdPrefix)
+    allNodes.push(...nodes)
+  }
+
+  return allNodes
+}
+
+/**
+ * Convert a DSL workflow to graph format
+ */
+export function convertDslToGraph(
+  workflowName: string,
+  meta: WorkflowsMeta[string]
+): SerializedWorkflowGraph {
+  const nodes = convertStepsToNodes(meta.steps)
+  const nodesRecord: Record<string, SerializedGraphNode> = {}
+
+  for (const node of nodes) {
+    nodesRecord[node.nodeId] = node
+  }
+
+  const entryNodeIds = nodes.length > 0 ? [nodes[0].nodeId] : []
+
+  // Determine source type based on dsl flag:
+  // - dsl === true: pure DSL workflow, can be serialized
+  // - dsl === false: complex workflow with inline steps, not serializable
+  const source = meta.dsl === false ? 'complex' : 'dsl'
+
+  return {
+    name: workflowName,
+    pikkuFuncId: meta.pikkuFuncId,
+    source,
+    description: meta.description,
+    tags: meta.tags,
+    context: meta.context,
+    nodes: nodesRecord,
+    entryNodeIds,
+  }
+}
+
+/**
+ * Convert all DSL workflows to graph format
+ */
+export function convertAllDslToGraphs(
+  workflowsMeta: WorkflowsMeta
+): Record<string, SerializedWorkflowGraph> {
+  const result: Record<string, SerializedWorkflowGraph> = {}
+
+  for (const [name, meta] of Object.entries(workflowsMeta)) {
+    result[name] = convertDslToGraph(name, meta)
+  }
+
+  return result
+}