@pikku/inspector 0.11.2 → 0.12.1

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 { resolveAddonName } from '../utils/resolve-addon-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 = resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations);
+        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-wire-addon.d.ts

@@ -0,0 +1,7 @@
+import * as ts from 'typescript';
+import type { InspectorState, InspectorLogger } from '../types.js';
+/**
+ * Detect wireAddon({ name: '...', package: '...' }) call expressions and
+ * populate state.rpc.wireAddonDeclarations and state.rpc.usedAddons.
+ */
+export declare function addWireAddon(node: ts.Node, state: InspectorState, logger: InspectorLogger): void;

package/dist/add/add-wire-addon.js

@@ -0,0 +1,70 @@
+import * as ts from 'typescript';
+function parseStringRecord(obj) {
+    const result = {};
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const keyNode = prop.name;
+        const key = ts.isIdentifier(keyNode)
+            ? keyNode.text
+            : ts.isStringLiteral(keyNode)
+                ? keyNode.text
+                : undefined;
+        if (key && ts.isStringLiteral(prop.initializer)) {
+            result[key] = prop.initializer.text;
+        }
+    }
+    return result;
+}
+/**
+ * Detect wireAddon({ name: '...', package: '...' }) call expressions and
+ * populate state.rpc.wireAddonDeclarations and state.rpc.usedAddons.
+ */
+export function addWireAddon(node, state, logger) {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args } = node;
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireAddon')
+        return;
+    const [firstArg] = args;
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+        return;
+    let name;
+    let pkg;
+    let rpcEndpoint;
+    let secretOverrides;
+    let variableOverrides;
+    for (const prop of firstArg.properties) {
+        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+            continue;
+        const key = prop.name.text;
+        if (key === 'name' && ts.isStringLiteral(prop.initializer)) {
+            name = prop.initializer.text;
+        }
+        else if (key === 'package' && ts.isStringLiteral(prop.initializer)) {
+            pkg = prop.initializer.text;
+        }
+        else if (key === 'rpcEndpoint' && ts.isStringLiteral(prop.initializer)) {
+            rpcEndpoint = prop.initializer.text;
+        }
+        else if (key === 'secretOverrides' &&
+            ts.isObjectLiteralExpression(prop.initializer)) {
+            secretOverrides = parseStringRecord(prop.initializer);
+        }
+        else if (key === 'variableOverrides' &&
+            ts.isObjectLiteralExpression(prop.initializer)) {
+            variableOverrides = parseStringRecord(prop.initializer);
+        }
+    }
+    if (!name || !pkg)
+        return;
+    logger.debug(`• Found wireAddon: ${name} → ${pkg}`);
+    state.rpc.wireAddonDeclarations.set(name, {
+        package: pkg,
+        rpcEndpoint,
+        secretOverrides,
+        variableOverrides,
+    });
+    state.rpc.usedAddons.add(name);
+    state.rpc.wireAddonFiles.add(node.getSourceFile().fileName);
+}

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

@@ -1,6 +1,7 @@
 import type { AddWiring } from '../types.js';
 /**
- * Inspector for wireWorkflow() calls with graph definitions
- * Detects: wireWorkflow({ wires: {...}, graph: pikkuWorkflowGraphResult })
+ * 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;