@pikku/inspector 0.11.0 → 0.11.2

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/utils/workflow/dsl/patterns.ts

@@ -0,0 +1,279 @@
+import * as ts from 'typescript'
+
+/**
+ * Pattern detection helpers for simple workflow extraction
+ */
+
+/**
+ * Check if a call expression is workflow.do()
+ */
+export function isWorkflowDoCall(
+  node: ts.CallExpression,
+  checker: ts.TypeChecker
+): boolean {
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return false
+  }
+
+  const propAccess = node.expression
+  return (
+    propAccess.name.text === 'do' &&
+    ts.isIdentifier(propAccess.expression) &&
+    propAccess.expression.text === 'workflow'
+  )
+}
+
+/**
+ * Check if a call expression is workflow.sleep()
+ */
+export function isWorkflowSleepCall(
+  node: ts.CallExpression,
+  checker: ts.TypeChecker
+): boolean {
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return false
+  }
+
+  const propAccess = node.expression
+  return (
+    propAccess.name.text === 'sleep' &&
+    ts.isIdentifier(propAccess.expression) &&
+    propAccess.expression.text === 'workflow'
+  )
+}
+
+/**
+ * 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(...))
+ */
+export function isParallelFanout(node: ts.CallExpression): boolean {
+  // Promise.all(...)
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return false
+  }
+
+  const propAccess = node.expression
+  if (
+    !ts.isIdentifier(propAccess.expression) ||
+    propAccess.expression.text !== 'Promise' ||
+    propAccess.name.text !== 'all'
+  ) {
+    return false
+  }
+
+  // Check if argument is array.map(...)
+  const arg = node.arguments[0]
+  if (!arg || !ts.isCallExpression(arg)) {
+    return false
+  }
+
+  if (!ts.isPropertyAccessExpression(arg.expression)) {
+    return false
+  }
+
+  return arg.expression.name.text === 'map'
+}
+
+/**
+ * Check if an expression is Promise.all([...])
+ */
+export function isParallelGroup(node: ts.CallExpression): boolean {
+  // Promise.all(...)
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return false
+  }
+
+  const propAccess = node.expression
+  if (
+    !ts.isIdentifier(propAccess.expression) ||
+    propAccess.expression.text !== 'Promise' ||
+    propAccess.name.text !== 'all'
+  ) {
+    return false
+  }
+
+  // Check if argument is an array literal
+  const arg = node.arguments[0]
+  return !!arg && ts.isArrayLiteralExpression(arg)
+}
+
+/**
+ * Check if a for statement is a valid sequential fanout (for..of)
+ */
+export function isSequentialFanout(node: ts.ForOfStatement): boolean {
+  // Must have const declaration
+  if (!ts.isVariableDeclarationList(node.initializer)) {
+    return false
+  }
+
+  const declList = node.initializer
+  if (!(declList.flags & ts.NodeFlags.Const)) {
+    return false
+  }
+
+  // Must have exactly one declaration
+  if (declList.declarations.length !== 1) {
+    return false
+  }
+
+  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
+ */
+export function extractForOfVariable(
+  node: ts.ForOfStatement
+): { itemVar: string; sourceVar: string } | null {
+  if (!ts.isVariableDeclarationList(node.initializer)) {
+    return null
+  }
+
+  const decl = node.initializer.declarations[0]
+  if (!ts.isIdentifier(decl.name)) {
+    return null
+  }
+
+  const itemVar = decl.name.text
+
+  // Extract source variable with full path (e.g., data.memberEmails)
+  const sourceVar = extractSourcePath(node.expression)
+
+  if (!sourceVar) {
+    return null
+  }
+
+  return { itemVar, sourceVar }
+}
+
+/**
+ * Check if a type is an array type
+ */
+export function isArrayType(type: ts.Type, checker: ts.TypeChecker): boolean {
+  // Check if it's an array type
+  if (checker.isArrayType(type)) {
+    return true
+  }
+
+  // Check if it's a tuple type
+  if (type.flags & ts.TypeFlags.Object) {
+    const objectType = type as ts.ObjectType
+    if (objectType.objectFlags & ts.ObjectFlags.Tuple) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Get the source text of a node (for condition expressions)
+ */
+export function getSourceText(node: ts.Node): string {
+  return node.getText().trim()
+}

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

@@ -0,0 +1,180 @@
+import * as ts from 'typescript'
+
+/**
+ * Validation rules for simple workflows
+ */
+
+export interface ValidationError {
+  message: string
+  node: ts.Node
+}
+
+/**
+ * Check if a node contains only allowed patterns
+ *
+ * Allowed patterns:
+ * - 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[] {
+  const errors: ValidationError[] = []
+
+  function visitBlock(block: ts.Block) {
+    for (const statement of block.statements) {
+      if (
+        ts.isVariableStatement(statement) ||
+        ts.isExpressionStatement(statement) ||
+        ts.isIfStatement(statement) ||
+        ts.isSwitchStatement(statement) ||
+        ts.isForOfStatement(statement) ||
+        ts.isReturnStatement(statement) ||
+        ts.isThrowStatement(statement)
+      ) {
+        // Allowed statement type - recurse into it
+        visitNode(statement)
+      } else {
+        // 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, switch/case, for..of, return, throw, and workflow calls. If this should be supported, please report the node type: ${nodeType}`,
+          node: statement,
+        })
+      }
+    }
+  }
+
+  function visitNode(node: ts.Node) {
+    // Disallow while and do-while
+    if (ts.isWhileStatement(node) || ts.isDoStatement(node)) {
+      errors.push({
+        message: 'while and do-while loops are not allowed in simple workflows',
+        node,
+      })
+      return
+    }
+
+    // Disallow for and for-in loops
+    if (ts.isForInStatement(node) || ts.isForStatement(node)) {
+      errors.push({
+        message:
+          'for and for-in loops are not allowed in simple workflows. Use for-of instead.',
+        node,
+      })
+      return
+    }
+
+    // Check for inline workflow.do
+    if (ts.isCallExpression(node)) {
+      if (ts.isPropertyAccessExpression(node.expression)) {
+        const propAccess = node.expression
+        if (
+          propAccess.name.text === 'do' &&
+          ts.isIdentifier(propAccess.expression) &&
+          propAccess.expression.text === 'workflow'
+        ) {
+          const secondArg = node.arguments[1]
+          if (
+            secondArg &&
+            (ts.isArrowFunction(secondArg) ||
+              ts.isFunctionExpression(secondArg))
+          ) {
+            errors.push({
+              message:
+                'Inline workflow.do with function argument is not allowed in simple workflows. Use RPC form instead.',
+              node,
+            })
+            return
+          }
+        }
+      }
+    }
+
+    // Recurse into blocks
+    if (ts.isBlock(node)) {
+      visitBlock(node)
+    } else {
+      ts.forEachChild(node, visitNode)
+    }
+  }
+
+  visitNode(node)
+  return errors
+}
+
+/**
+ * Validate that all workflow.do calls are awaited
+ */
+export function validateAwaitedCalls(node: ts.Node): ValidationError[] {
+  const errors: ValidationError[] = []
+
+  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
+        if (
+          (propAccess.name.text === 'do' || propAccess.name.text === 'sleep') &&
+          ts.isIdentifier(propAccess.expression) &&
+          propAccess.expression.text === 'workflow'
+        ) {
+          if (!parentIsAwait && !insidePromiseAll) {
+            errors.push({
+              message: `workflow.${propAccess.name.text}() must be awaited`,
+              node,
+            })
+          }
+          return
+        }
+      }
+    }
+
+    if (ts.isAwaitExpression(node)) {
+      // Visit the expression itself with parentIsAwait=true
+      visit(node.expression, true, insidePromiseAll)
+    } else {
+      ts.forEachChild(node, (child) => visit(child, false, insidePromiseAll))
+    }
+  }
+
+  visit(node)
+  return errors
+}
+
+/**
+ * Combine all validation errors into a single error message
+ */
+export function formatValidationErrors(errors: ValidationError[]): string {
+  if (errors.length === 0) {
+    return ''
+  }
+
+  return errors.map((err) => `- ${err.message}`).join('\n')
+}