@pikku/inspector 0.11.0 → 0.11.1

package/src/workflow/patterns.ts

@@ -0,0 +1,182 @@
+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 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 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
+  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
+  }
+
+  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/workflow/validation.ts

@@ -0,0 +1,153 @@
+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)
+ * - ForOfStatement (sequential fanout)
+ * - ReturnStatement
+ * - 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.isForOfStatement(statement) ||
+        ts.isReturnStatement(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, for..of, return, 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) {
+    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) {
+            errors.push({
+              message: `workflow.${propAccess.name.text}() must be awaited`,
+              node,
+            })
+          }
+          return
+        }
+      }
+    }
+
+    if (ts.isAwaitExpression(node)) {
+      // Mark child as awaited
+      ts.forEachChild(node.expression, (child) => visit(child, true))
+    } else {
+      ts.forEachChild(node, (child) => visit(child, false))
+    }
+  }
+
+  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')
+}