@pikku/inspector 0.11.1 → 0.12.0

package/dist/add/add-trigger.d.ts

@@ -0,0 +1,2 @@
+import { AddWiring } from '../types.js';
+export declare const addTrigger: AddWiring;

package/dist/add/add-trigger.js

@@ -0,0 +1,87 @@
+import * as ts from 'typescript';
+import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
+import { extractFunctionName, makeContextBasedId, } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { resolveMiddleware } from '../utils/middleware.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { resolveExternalPackageName } from '../utils/resolve-external-package.js';
+import { ErrorCode } from '../error-codes.js';
+export const addTrigger = (logger, node, checker, state, options) => {
+    if (!ts.isCallExpression(node)) {
+        return;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    if (!ts.isIdentifier(expression)) {
+        return;
+    }
+    if (expression.text === 'wireTrigger') {
+        addWireTrigger(logger, node, checker, state, firstArg);
+    }
+    else if (expression.text === 'wireTriggerSource') {
+        addWireTriggerSource(logger, node, checker, state, options, firstArg);
+    }
+};
+const addWireTrigger = (logger, node, checker, state, firstArg) => {
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) {
+        return;
+    }
+    const obj = firstArg;
+    const nameValue = getPropertyValue(obj, 'name');
+    const { disabled, tags, summary, description, errors } = getCommonWireMetaData(obj, 'Trigger', nameValue, logger);
+    if (disabled)
+        return;
+    const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
+    if (!funcInitializer) {
+        logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for trigger '${nameValue}'.`);
+        return;
+    }
+    const extracted = extractFunctionName(funcInitializer, checker, state.rootDir);
+    let pikkuFuncId = extracted.pikkuFuncId;
+    if (pikkuFuncId.startsWith('__temp_') && nameValue) {
+        pikkuFuncId = makeContextBasedId('trigger', nameValue);
+    }
+    if (!nameValue) {
+        return;
+    }
+    // --- resolve middleware ---
+    const middleware = resolveMiddleware(state, obj, tags, checker);
+    // --- track used functions/middleware for service aggregation ---
+    state.serviceAggregation.usedFunctions.add(pikkuFuncId);
+    extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+    state.triggers.files.add(node.getSourceFile().fileName);
+    state.triggers.meta[nameValue] = {
+        pikkuFuncId,
+        name: nameValue,
+        summary,
+        description,
+        errors,
+        tags,
+        middleware,
+    };
+};
+const addWireTriggerSource = (logger, node, checker, state, options, firstArg) => {
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) {
+        return;
+    }
+    const obj = firstArg;
+    const nameValue = getPropertyValue(obj, 'name');
+    if (!nameValue) {
+        return;
+    }
+    const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
+    if (!funcInitializer) {
+        logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for trigger source '${nameValue}'.`);
+        return;
+    }
+    if (ts.isIdentifier(funcInitializer)) {
+        const packageName = resolveExternalPackageName(funcInitializer, checker, options.externalPackages);
+        state.triggers.sourceMeta[nameValue] = {
+            name: nameValue,
+            pikkuFuncId: funcInitializer.text,
+            packageName: packageName || undefined,
+        };
+    }
+    state.triggers.files.add(node.getSourceFile().fileName);
+};

package/dist/add/add-variable.d.ts

@@ -0,0 +1 @@
+export declare const addVariable: import("../types.js").AddWiring;

package/dist/add/add-variable.js

@@ -0,0 +1,8 @@
+import { createAddKeyedWiring } from './add-keyed-wiring.js';
+export const addVariable = createAddKeyedWiring({
+    functionName: 'wireVariable',
+    idField: 'variableId',
+    label: 'Variable',
+    schemaPrefix: 'VariableSchema',
+    getState: (state) => state.variables,
+});

package/dist/add/add-workflow-graph.d.ts

@@ -0,0 +1,7 @@
+import type { AddWiring } from '../types.js';
+/**
+ * Inspector for pikkuWorkflowGraph() calls
+ * Detects: pikkuWorkflowGraph({ nodes: {...}, config: {...} })
+ * or: export const x = pikkuWorkflowGraph({...}) where the call is found via variable declaration
+ */
+export declare const addWorkflowGraph: AddWiring;

package/dist/add/add-workflow-graph.js

@@ -0,0 +1,396 @@
+import * as ts from 'typescript';
+import { ErrorCode } from '../error-codes.js';
+import { extractStringLiteral } from '../utils/extract-node-value.js';
+function extractAstValue(expr, refParamName, templateParamName) {
+    if (ts.isStringLiteral(expr)) {
+        return expr.text;
+    }
+    if (ts.isNumericLiteral(expr)) {
+        return Number(expr.text);
+    }
+    if (expr.kind === ts.SyntaxKind.TrueKeyword) {
+        return true;
+    }
+    if (expr.kind === ts.SyntaxKind.FalseKeyword) {
+        return false;
+    }
+    if (expr.kind === ts.SyntaxKind.NullKeyword) {
+        return null;
+    }
+    if (ts.isCallExpression(expr)) {
+        const callee = expr.expression;
+        if (ts.isIdentifier(callee)) {
+            if (callee.text === refParamName) {
+                const args = expr.arguments;
+                const nodeId = args[0] && ts.isStringLiteral(args[0]) ? args[0].text : 'unknown';
+                const path = args[1] && ts.isStringLiteral(args[1]) ? args[1].text : undefined;
+                return { $ref: nodeId, path };
+            }
+            if (templateParamName && callee.text === templateParamName) {
+                const templateStr = expr.arguments[0] && ts.isStringLiteral(expr.arguments[0])
+                    ? expr.arguments[0].text
+                    : '';
+                const refsArg = expr.arguments[1];
+                const refs = [];
+                if (refsArg && ts.isArrayLiteralExpression(refsArg)) {
+                    for (const el of refsArg.elements) {
+                        const resolved = extractAstValue(el, refParamName, templateParamName);
+                        if (typeof resolved === 'object' &&
+                            resolved !== null &&
+                            '$ref' in resolved) {
+                            refs.push(resolved);
+                        }
+                    }
+                }
+                const parts = [];
+                const expressions = [];
+                const regex = /\$(\d+)/g;
+                let lastIndex = 0;
+                let match;
+                while ((match = regex.exec(templateStr)) !== null) {
+                    parts.push(templateStr.slice(lastIndex, match.index));
+                    const refIndex = parseInt(match[1], 10);
+                    expressions.push(refs[refIndex] ?? { $ref: 'unknown' });
+                    lastIndex = regex.lastIndex;
+                }
+                parts.push(templateStr.slice(lastIndex));
+                return { $template: { parts, expressions } };
+            }
+        }
+    }
+    if (ts.isArrayLiteralExpression(expr)) {
+        return expr.elements.map((el) => extractAstValue(el, refParamName, templateParamName));
+    }
+    if (ts.isObjectLiteralExpression(expr)) {
+        const obj = {};
+        for (const prop of expr.properties) {
+            if (!ts.isPropertyAssignment(prop))
+                continue;
+            const key = ts.isIdentifier(prop.name)
+                ? prop.name.text
+                : ts.isStringLiteral(prop.name)
+                    ? prop.name.text
+                    : null;
+            if (!key)
+                continue;
+            obj[key] = extractAstValue(prop.initializer, refParamName, templateParamName);
+        }
+        return obj;
+    }
+    if (ts.isPrefixUnaryExpression(expr)) {
+        if (expr.operator === ts.SyntaxKind.MinusToken &&
+            ts.isNumericLiteral(expr.operand)) {
+            return -Number(expr.operand.text);
+        }
+    }
+    return undefined;
+}
+function extractInputMapping(node, _checker) {
+    if (!ts.isArrowFunction(node)) {
+        return {};
+    }
+    let bodyObj;
+    if (ts.isObjectLiteralExpression(node.body)) {
+        bodyObj = node.body;
+    }
+    else if (ts.isParenthesizedExpression(node.body)) {
+        if (ts.isObjectLiteralExpression(node.body.expression)) {
+            bodyObj = node.body.expression;
+        }
+    }
+    else if (ts.isBlock(node.body)) {
+        for (const stmt of node.body.statements) {
+            if (ts.isReturnStatement(stmt) && stmt.expression) {
+                if (ts.isObjectLiteralExpression(stmt.expression)) {
+                    bodyObj = stmt.expression;
+                }
+            }
+        }
+    }
+    if (!bodyObj) {
+        return {};
+    }
+    const refParamName = node.parameters.length > 0 && ts.isIdentifier(node.parameters[0].name)
+        ? node.parameters[0].name.text
+        : 'ref';
+    const templateParamName = node.parameters.length > 1 && ts.isIdentifier(node.parameters[1].name)
+        ? node.parameters[1].name.text
+        : undefined;
+    const input = {};
+    for (const prop of bodyObj.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const key = ts.isIdentifier(prop.name)
+            ? prop.name.text
+            : ts.isStringLiteral(prop.name)
+                ? prop.name.text
+                : null;
+        if (!key)
+            continue;
+        const value = extractAstValue(prop.initializer, refParamName, templateParamName);
+        if (value !== undefined) {
+            input[key] = value;
+        }
+    }
+    return input;
+}
+/**
+ * Extract next config (string, array, or record)
+ */
+function extractNextConfig(node, _checker) {
+    if (ts.isStringLiteral(node)) {
+        return node.text;
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        return node.elements
+            .filter(ts.isStringLiteral)
+            .map((el) => el.text);
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        const result = {};
+        for (const prop of node.properties) {
+            if (!ts.isPropertyAssignment(prop))
+                continue;
+            const key = ts.isIdentifier(prop.name)
+                ? prop.name.text
+                : ts.isStringLiteral(prop.name)
+                    ? prop.name.text
+                    : null;
+            if (!key)
+                continue;
+            if (ts.isStringLiteral(prop.initializer)) {
+                result[key] = prop.initializer.text;
+            }
+            else if (ts.isArrayLiteralExpression(prop.initializer)) {
+                result[key] = prop.initializer.elements
+                    .filter(ts.isStringLiteral)
+                    .map((el) => el.text);
+            }
+        }
+        return result;
+    }
+    return undefined;
+}
+/**
+ * Compute entry node IDs from graph nodes
+ */
+function computeEntryNodeIds(graphNodes) {
+    const hasIncomingEdge = new Set();
+    for (const node of Object.values(graphNodes)) {
+        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 if (typeof next === 'object') {
+            for (const targets of Object.values(next)) {
+                if (typeof targets === 'string') {
+                    hasIncomingEdge.add(targets);
+                }
+                else if (Array.isArray(targets)) {
+                    ;
+                    targets.forEach((n) => hasIncomingEdge.add(n));
+                }
+            }
+        }
+    }
+    return Object.keys(graphNodes).filter((nodeId) => !hasIncomingEdge.has(nodeId));
+}
+/**
+ * Extract pikkuWorkflowGraph config from an object literal argument
+ */
+function extractWorkflowGraphConfig(configArg, checker) {
+    let name;
+    let description;
+    let tags;
+    let disabled;
+    let nodesNode;
+    let configNode;
+    for (const prop of configArg.properties) {
+        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+            continue;
+        const propName = prop.name.text;
+        if (propName === 'name') {
+            name = extractStringLiteral(prop.initializer, checker);
+        }
+        else if (propName === 'description') {
+            description = extractStringLiteral(prop.initializer, checker);
+        }
+        else if (propName === 'disabled') {
+            if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                disabled = true;
+            }
+        }
+        else if (propName === 'tags' &&
+            ts.isArrayLiteralExpression(prop.initializer)) {
+            tags = prop.initializer.elements
+                .filter(ts.isStringLiteral)
+                .map((el) => el.text);
+        }
+        else if (propName === 'nodes' &&
+            ts.isObjectLiteralExpression(prop.initializer)) {
+            nodesNode = prop.initializer;
+        }
+        else if (propName === 'config' &&
+            ts.isObjectLiteralExpression(prop.initializer)) {
+            configNode = prop.initializer;
+        }
+    }
+    return { name, description, tags, disabled, nodesNode, configNode };
+}
+/**
+ * Extract graph nodes from the new pikkuWorkflowGraph format
+ * New format: { nodes: { entry: 'rpcName', ... }, config: { entry: { next: 'sendWelcome', ... }, ... } }
+ */
+function extractGraphFromNewFormat(nodesNode, configNode, checker, state) {
+    const nodes = {};
+    if (!nodesNode) {
+        return nodes;
+    }
+    // Extract node ID to RPC name mapping from 'nodes' property
+    const nodeRpcMap = {};
+    for (const prop of nodesNode.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const nodeId = ts.isIdentifier(prop.name)
+            ? prop.name.text
+            : ts.isStringLiteral(prop.name)
+                ? prop.name.text
+                : null;
+        if (!nodeId)
+            continue;
+        const rpcName = extractStringLiteral(prop.initializer, checker);
+        if (rpcName) {
+            nodeRpcMap[nodeId] = rpcName;
+            state.rpc.invokedFunctions.add(rpcName);
+            const funcFile = state.functions.files.get(rpcName);
+            if (funcFile && !state.rpc.internalFiles.has(rpcName)) {
+                state.rpc.internalFiles.set(rpcName, funcFile);
+            }
+        }
+    }
+    // Initialize nodes with their RPC names
+    for (const [nodeId, rpcName] of Object.entries(nodeRpcMap)) {
+        nodes[nodeId] = {
+            nodeId,
+            rpcName,
+            input: {},
+            next: undefined,
+            onError: undefined,
+        };
+    }
+    // Extract config for each node from 'config' property
+    if (configNode) {
+        for (const prop of configNode.properties) {
+            if (!ts.isPropertyAssignment(prop))
+                continue;
+            const nodeId = ts.isIdentifier(prop.name)
+                ? prop.name.text
+                : ts.isStringLiteral(prop.name)
+                    ? prop.name.text
+                    : null;
+            if (!nodeId || !nodes[nodeId])
+                continue;
+            if (ts.isObjectLiteralExpression(prop.initializer)) {
+                const nodeConfig = extractNodeConfigFromObject(prop.initializer, checker);
+                if (nodeConfig) {
+                    nodes[nodeId].next = nodeConfig.next;
+                    nodes[nodeId].onError = nodeConfig.onError;
+                    nodes[nodeId].input = nodeConfig.input;
+                }
+            }
+        }
+    }
+    return nodes;
+}
+/**
+ * Extract node config (next, onError, input) from object literal
+ */
+function extractNodeConfigFromObject(obj, checker) {
+    let next = undefined;
+    let onError = undefined;
+    let input = {};
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+            continue;
+        const propName = prop.name.text;
+        if (propName === 'next') {
+            next = extractNextConfig(prop.initializer, checker);
+        }
+        else if (propName === 'onError') {
+            onError = extractNextConfig(prop.initializer, checker);
+        }
+        else if (propName === 'input') {
+            input = extractInputMapping(prop.initializer, checker);
+        }
+    }
+    return { next, onError, input };
+}
+/**
+ * Inspector for pikkuWorkflowGraph() calls
+ * Detects: pikkuWorkflowGraph({ nodes: {...}, config: {...} })
+ * or: export const x = pikkuWorkflowGraph({...}) where the call is found via variable declaration
+ */
+export const addWorkflowGraph = (logger, node, checker, state) => {
+    if (!ts.isCallExpression(node)) {
+        return;
+    }
+    const expression = node.expression;
+    if (!ts.isIdentifier(expression) ||
+        expression.text !== 'pikkuWorkflowGraph') {
+        return;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    if (!firstArg) {
+        logger.critical(ErrorCode.MISSING_FUNC, 'pikkuWorkflowGraph requires an argument');
+        return;
+    }
+    if (!ts.isObjectLiteralExpression(firstArg)) {
+        logger.critical(ErrorCode.MISSING_FUNC, 'pikkuWorkflowGraph requires an object argument');
+        return;
+    }
+    const graphConfig = extractWorkflowGraphConfig(firstArg, checker);
+    if (!graphConfig) {
+        logger.critical(ErrorCode.MISSING_NAME, 'pikkuWorkflowGraph: failed to extract config');
+        return;
+    }
+    // Resolve exportedName from variable declaration if this is `export const x = pikkuWorkflowGraph({...})`
+    const parent = node.parent;
+    if (!graphConfig.exportedName &&
+        parent &&
+        ts.isVariableDeclaration(parent) &&
+        ts.isIdentifier(parent.name)) {
+        graphConfig.exportedName = parent.name.text;
+    }
+    const workflowName = graphConfig.name || graphConfig.exportedName;
+    if (!workflowName) {
+        logger.critical(ErrorCode.MISSING_NAME, 'pikkuWorkflowGraph requires a name property or exported variable name');
+        return;
+    }
+    let graphNodes = {};
+    if (graphConfig.nodesNode) {
+        graphNodes = extractGraphFromNewFormat(graphConfig.nodesNode, graphConfig.configNode, checker, state);
+    }
+    const entryNodeIds = computeEntryNodeIds(graphNodes);
+    const serialized = {
+        name: workflowName,
+        pikkuFuncId: workflowName,
+        source: 'graph',
+        description: graphConfig.description,
+        tags: graphConfig.tags,
+        nodes: graphNodes,
+        entryNodeIds,
+    };
+    if (graphConfig.disabled)
+        return;
+    state.workflows.graphMeta[workflowName] = serialized;
+    state.workflows.graphFiles.set(workflowName, {
+        path: node.getSourceFile().fileName,
+        exportedName: graphConfig.exportedName || workflowName,
+    });
+};