@pikku/inspector 0.11.1 → 0.11.2

package/dist/utils/workflow/dsl/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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/dist/utils/workflow/dsl/index.js

@@ -0,0 +1,7 @@
+/**
+ * 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/dist/{workflow → utils/workflow/dsl}/patterns.d.ts

@@ -10,6 +10,27 @@ export declare function isWorkflowDoCall(node: ts.CallExpression, checker: ts.Ty
  * Check if a call expression is workflow.sleep()
  */
 export declare function isWorkflowSleepCall(node: ts.CallExpression, checker: ts.TypeChecker): boolean;
+/**
+ * Check if a throw statement throws WorkflowCancelledException
+ * Matches: throw new WorkflowCancelledException(...) or throw WorkflowCancelledException(...)
+ */
+export declare function isThrowCancelException(node: ts.ThrowStatement): boolean;
+/**
+ * Extract the reason string from a throw WorkflowCancelledException statement
+ */
+export declare function extractCancelReason(node: ts.ThrowStatement, checker: ts.TypeChecker): string | undefined;
+/**
+ * Check if a call expression is array.filter()
+ */
+export declare function isArrayFilter(node: ts.CallExpression): boolean;
+/**
+ * Check if a call expression is array.some()
+ */
+export declare function isArraySome(node: ts.CallExpression): boolean;
+/**
+ * Check if a call expression is array.every()
+ */
+export declare function isArrayEvery(node: ts.CallExpression): boolean;
 /**
  * Check if an expression is Promise.all(array.map(...))
  */

package/dist/{workflow → utils/workflow/dsl}/patterns.js

@@ -26,6 +26,79 @@ export function isWorkflowSleepCall(node, checker) {
         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) {
+    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, checker) {
+    const expr = node.expression;
+    if (!expr)
+        return undefined;
+    let args;
+    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) {
+    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) {
+    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) {
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    return node.expression.name.text === 'every';
+}
 /**
  * Check if an expression is Promise.all(array.map(...))
  */
@@ -86,6 +159,21 @@ export function isSequentialFanout(node) {
     }
     return true;
 }
+/**
+ * Extract full source path from an expression (e.g., data.memberEmails)
+ */
+function extractSourcePath(expr) {
+    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
  */
@@ -98,16 +186,8 @@ export function extractForOfVariable(node) {
         return null;
     }
     const itemVar = decl.name.text;
-    // Extract source variable
-    let sourceVar = 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/dist/{workflow → utils/workflow/dsl}/validation.d.ts

@@ -13,8 +13,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 declare function validateNoDisallowedPatterns(node: ts.Node): ValidationError[];

package/dist/{workflow → utils/workflow/dsl}/validation.js

@@ -6,8 +6,10 @@ import * as ts from 'typescript';
  * - 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) {
@@ -17,8 +19,10 @@ export function validateNoDisallowedPatterns(node) {
             if (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);
             }
@@ -26,7 +30,7 @@ export function validateNoDisallowedPatterns(node) {
                 // 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,
                 });
             }
@@ -85,14 +89,28 @@ export function validateNoDisallowedPatterns(node) {
  */
 export function validateAwaitedCalls(node) {
     const errors = [];
-    function visit(node, parentIsAwait = false) {
+    function visit(node, parentIsAwait = false, insidePromiseAll = 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) {
+                    if (!parentIsAwait && !insidePromiseAll) {
                         errors.push({
                             message: `workflow.${propAccess.name.text}() must be awaited`,
                             node,
@@ -103,11 +121,11 @@ export function validateAwaitedCalls(node) {
             }
         }
         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));
         }
     }
     visit(node);

package/dist/utils/workflow/graph/convert-dsl-to-graph.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts DSL (Domain Specific Language) step-based format to graph node format
+ */
+import type { WorkflowsMeta } from '@pikku/core/workflow';
+import type { SerializedWorkflowGraph } from './workflow-graph.types.js';
+/**
+ * Convert a DSL workflow to graph format
+ */
+export declare function convertDslToGraph(workflowName: string, meta: WorkflowsMeta[string]): SerializedWorkflowGraph;
+/**
+ * Convert all DSL workflows to graph format
+ */
+export declare function convertAllDslToGraphs(workflowsMeta: WorkflowsMeta): Record<string, SerializedWorkflowGraph>;

package/dist/utils/workflow/graph/convert-dsl-to-graph.js

@@ -0,0 +1,316 @@
+/**
+ * Check if a node is a terminal flow (no next step should follow)
+ */
+function isTerminalFlow(node) {
+    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) {
+    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)),
+            },
+        };
+    }
+    return source.value;
+}
+/**
+ * Convert a single DSL step to graph node(s)
+ */
+function convertStepToNode(step, index, steps, nodeIdPrefix = 'step') {
+    const nodeId = `${nodeIdPrefix}_${index}`;
+    const nextNodeId = index < steps.length - 1 ? `${nodeIdPrefix}_${index + 1}` : undefined;
+    switch (step.type) {
+        case 'rpc': {
+            const node = {
+                nodeId,
+                rpcName: step.rpcName,
+                stepName: step.stepName,
+                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);
+                    }
+                }
+            }
+            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 = {
+                nodeId,
+                flow: 'sleep',
+                stepName: step.stepName,
+                duration: step.duration,
+                next: nextNodeId,
+            };
+            return [node];
+        }
+        case 'inline': {
+            const node = {
+                nodeId,
+                flow: 'inline',
+                stepName: step.stepName,
+                description: step.description,
+                next: nextNodeId,
+            };
+            return [node];
+        }
+        case 'branch': {
+            // Convert all branch conditions (if/else-if chain)
+            const branchNodes = [];
+            const branches = [];
+            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 = {
+                nodeId,
+                flow: 'branch',
+                branches,
+                elseEntry: elseNodes.length > 0 ? elseNodes[0].nodeId : undefined,
+                next: nextNodeId,
+            };
+            return [node, ...branchNodes, ...elseNodes];
+        }
+        case 'switch': {
+            const caseNodes = [];
+            const cases = [];
+            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;
+            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 = {
+                nodeId,
+                flow: 'switch',
+                expression: step.expression,
+                cases,
+                defaultEntry,
+                next: nextNodeId,
+            };
+            return [node, ...caseNodes];
+        }
+        case 'parallel': {
+            // Convert children to nodes
+            const childNodes = [];
+            const childEntries = [];
+            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 = {
+                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 = {
+                nodeId,
+                flow: 'fanout',
+                stepName: step.stepName,
+                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 = {
+                nodeId,
+                flow: 'filter',
+                sourceVar: step.sourceVar,
+                itemVar: step.itemVar,
+                condition: step.condition,
+                outputVar: step.outputVar,
+                next: nextNodeId,
+            };
+            return [node];
+        }
+        case 'arrayPredicate': {
+            const node = {
+                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 = {
+                nodeId,
+                flow: 'return',
+                outputs: step.outputs,
+            };
+            return [node];
+        }
+        case 'cancel': {
+            const node = {
+                nodeId,
+                flow: 'cancel',
+                reason: step.reason,
+            };
+            return [node];
+        }
+        case 'set': {
+            const node = {
+                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, nodeIdPrefix = 'step') {
+    const allNodes = [];
+    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, meta) {
+    const nodes = convertStepsToNodes(meta.steps);
+    const nodesRecord = {};
+    for (const node of nodes) {
+        nodesRecord[node.nodeId] = node;
+    }
+    // Find entry nodes (step_0 is always entry for sequential workflows)
+    const entryNodeIds = nodes.length > 0 ? ['step_0'] : [];
+    // 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,
+        pikkuFuncName: meta.pikkuFuncName,
+        source,
+        description: meta.description,
+        tags: meta.tags,
+        context: meta.context,
+        wires: {}, // DSL workflows don't have explicit wires in meta
+        nodes: nodesRecord,
+        entryNodeIds,
+    };
+}
+/**
+ * Convert all DSL workflows to graph format
+ */
+export function convertAllDslToGraphs(workflowsMeta) {
+    const result = {};
+    for (const [name, meta] of Object.entries(workflowsMeta)) {
+        result[name] = convertDslToGraph(name, meta);
+    }
+    return result;
+}

package/dist/utils/workflow/graph/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Workflow graph serialization exports
+ */
+export * from './workflow-graph.types.js';
+export { serializeWorkflowGraph } from './serialize-workflow-graph.js';
+export { convertDslToGraph } from './convert-dsl-to-graph.js';

package/dist/utils/workflow/graph/index.js

@@ -0,0 +1,6 @@
+/**
+ * Workflow graph serialization exports
+ */
+export * from './workflow-graph.types.js';
+export { serializeWorkflowGraph } from './serialize-workflow-graph.js';
+export { convertDslToGraph } from './convert-dsl-to-graph.js';

package/dist/utils/workflow/graph/serialize-workflow-graph.d.ts

@@ -0,0 +1,43 @@
+import type { SerializedWorkflowGraph, DataRef, SerializedNext } from './workflow-graph.types.js';
+/**
+ * Serialize a workflow graph definition (from runtime) to JSON format
+ *
+ * @param definition - The runtime definition (with callbacks evaluated)
+ * @param rpcNameLookup - Function to get RPC name from a node's func
+ */
+export declare function serializeWorkflowGraph(definition: {
+    name: string;
+    wires: {
+        http?: {
+            route: string;
+            method: string;
+        };
+        queue?: string;
+    };
+    graph: Record<string, {
+        func: {
+            name?: string;
+        };
+        input?: (ref: any) => Record<string, unknown>;
+        next?: string | string[] | Record<string, string | string[]>;
+        onError?: string | string[];
+    }>;
+}, options?: {
+    description?: string;
+    tags?: string[];
+}): SerializedWorkflowGraph;
+/**
+ * Deserialize a workflow graph from JSON to runtime format
+ * This re-hydrates the JSON so it can be executed
+ */
+export declare function deserializeWorkflowGraph(serialized: SerializedWorkflowGraph): {
+    name: string;
+    wires: SerializedWorkflowGraph['wires'];
+    graph: Record<string, {
+        rpcName: string;
+        input: Record<string, unknown | DataRef>;
+        next?: SerializedNext;
+        onError?: string | string[];
+    }>;
+    entryNodeIds: string[];
+};