@pikku/inspector 0.11.0 → 0.11.2

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[];
+};

package/dist/utils/workflow/graph/serialize-workflow-graph.js

@@ -0,0 +1,152 @@
+/**
+ * Convert a RefValue (from runtime) to DataRef (serialized)
+ */
+function convertRef(ref) {
+    return {
+        $ref: ref.nodeId,
+        path: ref.path,
+    };
+}
+/**
+ * Check if a value is a runtime RefValue
+ */
+function isRefValue(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '__isRef' in value &&
+        value.__isRef === true);
+}
+/**
+ * Convert input mapping from runtime format to serialized format
+ */
+function serializeInputMapping(input) {
+    const result = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (isRefValue(value)) {
+            result[key] = convertRef(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Convert next config from runtime format to serialized format
+ * Runtime uses Record<string, string | string[]> for branching with graph.branch()
+ * Serialized uses { conditions: [...], default: ... } for UI-friendly branching
+ */
+function serializeNext(next) {
+    if (!next)
+        return undefined;
+    if (typeof next === 'string')
+        return next;
+    if (Array.isArray(next))
+        return next;
+    // Record format - convert to conditions format
+    // For now, treat keys as branch identifiers (from graph.branch())
+    // UI can display these as condition labels
+    const conditions = Object.entries(next).map(([key, target]) => ({
+        expression: key, // The branch key becomes the expression
+        target,
+    }));
+    return { conditions };
+}
+/**
+ * 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 function serializeWorkflowGraph(definition, options) {
+    const nodes = {};
+    const entryNodeIds = [];
+    // Create a ref function that captures refs
+    const createRef = (nodeId, path) => ({
+        __isRef: true,
+        nodeId,
+        path,
+    });
+    // Track which nodes have incoming edges
+    const hasIncomingEdge = new Set();
+    // First pass: identify nodes with incoming edges
+    for (const [_nodeId, node] of Object.entries(definition.graph)) {
+        const next = node.next;
+        if (!next)
+            continue;
+        if (typeof next === 'string') {
+            hasIncomingEdge.add(next);
+        }
+        else if (Array.isArray(next)) {
+            next.forEach((n) => hasIncomingEdge.add(n));
+        }
+        else {
+            for (const targets of Object.values(next)) {
+                if (typeof targets === 'string') {
+                    hasIncomingEdge.add(targets);
+                }
+                else {
+                    targets.forEach((n) => hasIncomingEdge.add(n));
+                }
+            }
+        }
+    }
+    // Second pass: serialize nodes
+    for (const [nodeId, node] of Object.entries(definition.graph)) {
+        // Evaluate input callback to get the mapping
+        let input = {};
+        if (node.input) {
+            const rawInput = node.input(createRef);
+            input = serializeInputMapping(rawInput);
+        }
+        // Get RPC name from func
+        const rpcName = node.func?.name || 'unknown';
+        const funcNode = {
+            nodeId,
+            rpcName,
+            input,
+            next: serializeNext(node.next),
+            onError: node.onError,
+        };
+        nodes[nodeId] = funcNode;
+        // Entry nodes have no incoming edges
+        if (!hasIncomingEdge.has(nodeId)) {
+            entryNodeIds.push(nodeId);
+        }
+    }
+    return {
+        name: definition.name,
+        pikkuFuncName: definition.name, // For graph workflows, pikkuFuncName is the workflow name
+        source: 'graph',
+        description: options?.description,
+        tags: options?.tags,
+        wires: definition.wires,
+        nodes,
+        entryNodeIds,
+    };
+}
+/**
+ * Deserialize a workflow graph from JSON to runtime format
+ * This re-hydrates the JSON so it can be executed
+ */
+export function deserializeWorkflowGraph(serialized) {
+    const graph = {};
+    for (const [nodeId, node] of Object.entries(serialized.nodes)) {
+        // Only include FunctionNode properties (nodes with rpcName)
+        if ('rpcName' in node) {
+            const funcNode = node;
+            graph[nodeId] = {
+                rpcName: funcNode.rpcName,
+                input: funcNode.input ?? {},
+                next: funcNode.next,
+                onError: funcNode.onError,
+            };
+        }
+    }
+    return {
+        name: serialized.name,
+        wires: serialized.wires,
+        graph,
+        entryNodeIds: serialized.entryNodeIds,
+    };
+}