@pikku/inspector 0.11.2 → 0.12.0

package/dist/utils/extract-function-name.js

@@ -1,214 +1,55 @@
 import * as ts from 'typescript';
-import { toRelativePath } from './find-root-dir.js';
-/**
- * Generate a deterministic "anonymous" name for any expression node,
- * but if it's an Identifier pointing to a function, resolve it back
- * to the function's declaration (so you get the true source location).
- */
-export function makeDeterministicAnonName(start, checker, rootDir) {
-    let node = start;
-    let target = start;
-    // Handle the case where we're starting with an identifier directly
-    if (ts.isIdentifier(node)) {
-        const sym = checker.getSymbolAtLocation(node);
-        if (sym) {
-            let resolvedSym = sym;
-            if (resolvedSym.flags & ts.SymbolFlags.Alias) {
-                resolvedSym = checker.getAliasedSymbol(resolvedSym) ?? resolvedSym;
-            }
-            const decls = resolvedSym.declarations ?? [];
-            if (decls.length > 0) {
-                // Start with the declaration, not the reference
-                const decl = decls[0];
-                // If it's a variable declaration with a function initializer, use the function directly
-                if (ts.isVariableDeclaration(decl) &&
-                    decl.initializer &&
-                    (ts.isFunctionExpression(decl.initializer) ||
-                        ts.isArrowFunction(decl.initializer))) {
-                    target = decl.initializer;
-                    // Return early - we found the function directly
-                    const sf = target.getSourceFile();
-                    const relativePath = toRelativePath(sf.fileName, rootDir);
-                    const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
-                    const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
-                    return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
-                }
-                // Otherwise continue resolution with the declaration
-                node = decl;
-                target = decl;
-            }
-        }
-    }
-    // In an object literal property value, first try to resolve the identifier
-    if (ts.isPropertyAssignment(node.parent) &&
-        node === node.parent.initializer &&
-        ts.isIdentifier(node)) {
-        const sym = checker.getSymbolAtLocation(node);
-        if (sym) {
-            // Process the symbol to find the real declaration
-            let resolvedSym = sym;
-            if (resolvedSym.flags & ts.SymbolFlags.Alias) {
-                resolvedSym = checker.getAliasedSymbol(resolvedSym) ?? resolvedSym;
-            }
-            const decls = resolvedSym.declarations ?? [];
-            if (decls.length > 0) {
-                // Found a declaration - use it as our new target
-                const decl = decls[0];
-                if (!decl) {
-                    throw new Error('No declaration found');
-                }
-                // If it's a variable declaration with an initializer function, use that
-                if (ts.isVariableDeclaration(decl) && decl.initializer) {
-                    if (ts.isFunctionExpression(decl.initializer) ||
-                        ts.isArrowFunction(decl.initializer)) {
-                        target = decl.initializer;
-                        // Return early - we found the function directly
-                        const sf = target.getSourceFile();
-                        const relativePath = toRelativePath(sf.fileName, rootDir);
-                        const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
-                        const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
-                        return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
-                    }
-                }
-                else if (ts.isFunctionDeclaration(decl)) {
-                    // Already a function declaration
-                    target = decl;
-                    // Return early
-                    const sf = target.getSourceFile();
-                    const relativePath = toRelativePath(sf.fileName, rootDir);
-                    const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
-                    const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
-                    return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
-                }
-                // If we didn't return early, continue with this declaration
-                node = decl;
-                target = decl;
-            }
-        }
-    }
-    const seen = new Set();
-    for (let depth = 0; depth < 10; depth++) {
-        if (!ts.isIdentifier(node) || seen.has(node))
-            break;
-        seen.add(node);
-        let sym = checker.getSymbolAtLocation(node);
-        if (!sym)
-            break;
-        if (sym.flags & ts.SymbolFlags.Alias) {
-            sym = checker.getAliasedSymbol(sym) ?? sym;
-        }
-        const allDecls = sym.declarations ?? [];
-        // prefer real .ts/.tsx implementation files
-        const implDecls = allDecls.filter((d) => !d.getSourceFile().isDeclarationFile);
-        const decls = implDecls.length ? implDecls : allDecls;
-        let didResolve = false;
-        for (const decl of decls) {
-            // 1) direct function foo() {} or function-expression
-            if (ts.isFunctionDeclaration(decl) ||
-                ts.isFunctionExpression(decl) ||
-                ts.isArrowFunction(decl)) {
-                target = decl;
-                didResolve = true;
-                break;
-            }
-            // 2) const foo = () => {} or foo = function() {}
-            if (ts.isVariableDeclaration(decl) && decl.initializer) {
-                const init = decl.initializer;
-                if (ts.isFunctionExpression(init) || ts.isArrowFunction(init)) {
-                    target = init;
-                    didResolve = true;
-                    break;
-                }
-                // 2b) const foo = bar;  (follow the next identifier)
-                if (ts.isIdentifier(init)) {
-                    node = init;
-                    target = init;
-                    didResolve = true;
-                    break;
-                }
-            }
-            // 3) Handle shorthand property assignments: { foo } (equivalent to { foo: foo })
-            if (ts.isShorthandPropertyAssignment(decl)) {
-                // Get the symbol for the shorthand property
-                const shorthandSym = checker.getShorthandAssignmentValueSymbol(decl);
-                if (shorthandSym &&
-                    shorthandSym.declarations &&
-                    shorthandSym.declarations.length > 0) {
-                    // Use the first declaration as our new target
-                    const shorthandDecl = shorthandSym.declarations[0];
-                    target = shorthandDecl;
-                    if (!shorthandDecl) {
-                        throw new Error('No shorthand declaration found');
-                    }
-                    // Check the type of declaration and extract the appropriate identifier to continue resolving
-                    if (ts.isVariableDeclaration(shorthandDecl) &&
-                        ts.isIdentifier(shorthandDecl.name)) {
-                        node = shorthandDecl.name;
-                        didResolve = true;
-                        break;
-                    }
-                    else if (ts.isFunctionDeclaration(shorthandDecl) &&
-                        shorthandDecl.name &&
-                        ts.isIdentifier(shorthandDecl.name)) {
-                        node = shorthandDecl.name;
-                        didResolve = true;
-                        break;
-                    }
-                    else if (ts.isParameter(shorthandDecl) &&
-                        ts.isIdentifier(shorthandDecl.name)) {
-                        node = shorthandDecl.name;
-                        didResolve = true;
-                        break;
-                    }
-                    else if (ts.isPropertyDeclaration(shorthandDecl) &&
-                        ts.isIdentifier(shorthandDecl.name)) {
-                        node = shorthandDecl.name;
-                        didResolve = true;
-                        break;
-                    }
-                    else if (ts.isMethodDeclaration(shorthandDecl) &&
-                        ts.isIdentifier(shorthandDecl.name)) {
-                        node = shorthandDecl.name;
-                        didResolve = true;
-                        break;
-                    }
-                }
-            }
-            // 4) Handle method declarations in classes/objects
-            if (ts.isMethodDeclaration(decl)) {
-                target = decl;
-                didResolve = true;
-                break;
-            }
-            // you can add more cases here if your setup uses imports, etc.
-        }
-        if (!didResolve)
-            break;
-    }
-    const sf = target.getSourceFile();
-    const relativePath = toRelativePath(sf.fileName, rootDir);
-    const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
-    const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
-    return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
+import { randomUUID } from 'crypto';
+export function makeContextBasedId(wiringType, ...segments) {
+    return [wiringType, ...segments].join(':');
+}
+export function funcIdToTypeName(id) {
+    return id
+        .split(/[^a-zA-Z0-9]/)
+        .filter(Boolean)
+        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+        .join('');
 }
-/**
- * Updated function to extract and prioritize function names correctly
- * This function follows the priority:
- * 1. Object with a name property
- * 2. Exported name
- * 3. Fallback to deterministic name
- */
 export function extractFunctionName(callExpr, checker, rootDir) {
     const parent = callExpr.parent;
     // Initialize the result
     const result = {
-        pikkuFuncName: '', // Will be populated later
-        name: '', // This will hold our "best" name based on priority
+        pikkuFuncId: '',
+        name: '',
         exportedName: null,
-        localName: null,
         propertyName: null,
         explicitName: null,
+        isHelper: false,
     };
+    const workflowHelpers = new Set([
+        'workflow',
+        'workflowStart',
+        'workflowStatus',
+        'graphStart',
+    ]);
+    if (ts.isCallExpression(callExpr) &&
+        ts.isIdentifier(callExpr.expression) &&
+        workflowHelpers.has(callExpr.expression.text)) {
+        const helperName = callExpr.expression.text;
+        const [firstArg, secondArg] = callExpr.arguments;
+        if (firstArg && ts.isStringLiteral(firstArg)) {
+            const workflowName = firstArg.text;
+            let funcName;
+            if (helperName === 'graphStart' &&
+                secondArg &&
+                ts.isStringLiteral(secondArg)) {
+                funcName = `${helperName}:${workflowName}:${secondArg.text}`;
+            }
+            else {
+                funcName = `${helperName}:${workflowName}`;
+            }
+            result.pikkuFuncId = funcName;
+            result.name = funcName;
+            result.explicitName = funcName;
+            result.isHelper = true;
+            return result;
+        }
+    }
     // Special case for wireHTTP: if this is an identifier within an object literal,
     // it might be coming from the HTTP route handling flow
     if (ts.isIdentifier(callExpr) &&
@@ -234,25 +75,19 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                         if (firstArg &&
                             (ts.isArrowFunction(firstArg) ||
                                 ts.isFunctionExpression(firstArg))) {
-                            // Use the function directly for position calculation
-                            result.pikkuFuncName = makeDeterministicAnonName(firstArg, checker, rootDir);
                             // Continue with name extraction
                             if (ts.isIdentifier(parent.name)) {
                                 result.propertyName = parent.name.text;
                             }
-                            // Check if the variable is exported
                             if (ts.isVariableDeclaration(decl) &&
-                                isNamedExport(decl) &&
+                                isNamedExport(decl, checker) &&
                                 ts.isIdentifier(decl.name)) {
                                 result.exportedName = decl.name.text;
-                                // CRITICAL FIX: Use exported name as pikkuFuncName for consistency
-                                result.pikkuFuncName = decl.name.text;
+                                result.pikkuFuncId = decl.name.text;
                             }
-                            else if (ts.isIdentifier(decl.name)) {
-                                // If not exported, still capture the variable name
-                                result.localName = decl.name.text;
+                            if (!result.pikkuFuncId) {
+                                result.pikkuFuncId = `__temp_${randomUUID()}`;
                             }
-                            // Apply name priority logic
                             populateNameByPriority(result);
                             return result;
                         }
@@ -261,9 +96,6 @@ export function extractFunctionName(callExpr, checker, rootDir) {
             }
         }
     }
-    // Keep track of the original call expression for position-based naming
-    let originalCallExpr = callExpr;
-    // For direct pikku function calls where callExpr is the call expression itself
     if (ts.isCallExpression(callExpr)) {
         const { expression, arguments: args } = callExpr;
         // Check if this is a pikku function call (pikkuFunc, pikkuSessionlessFunc, etc)
@@ -327,29 +159,19 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                                                     ts.isFunctionExpression(firstArg))) {
                                                 // mainFunc = firstArg
                                                 // Check if the variable is exported
-                                                if (isNamedExport(funcDecl) &&
+                                                if (isNamedExport(funcDecl, checker) &&
                                                     ts.isIdentifier(funcDecl.name)) {
                                                     result.exportedName = funcDecl.name.text;
                                                 }
-                                                else if (ts.isIdentifier(funcDecl.name)) {
-                                                    // If not exported, still capture the variable name
-                                                    result.localName = funcDecl.name.text;
-                                                }
                                                 break;
                                             }
                                         }
                                         else if (ts.isFunctionExpression(funcDecl.initializer) ||
                                             ts.isArrowFunction(funcDecl.initializer)) {
-                                            // mainFunc = funcDecl.initializer
-                                            // Check if the variable is exported
-                                            if (isNamedExport(funcDecl) &&
+                                            if (isNamedExport(funcDecl, checker) &&
                                                 ts.isIdentifier(funcDecl.name)) {
                                                 result.exportedName = funcDecl.name.text;
                                             }
-                                            else if (ts.isIdentifier(funcDecl.name)) {
-                                                // If not exported, still capture the variable name
-                                                result.localName = funcDecl.name.text;
-                                            }
                                             break;
                                         }
                                     }
@@ -361,11 +183,6 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                                             ts.isIdentifier(funcDecl.name)) {
                                             result.exportedName = funcDecl.name.text;
                                         }
-                                        else if (funcDecl.name &&
-                                            ts.isIdentifier(funcDecl.name)) {
-                                            // If not exported, still capture the function name
-                                            result.localName = funcDecl.name.text;
-                                        }
                                         break;
                                     }
                                 }
@@ -407,29 +224,19 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                                             ts.isFunctionExpression(firstArg))) {
                                         // mainFunc = firstArg
                                         // Check if the variable is exported
-                                        if (isNamedExport(shorthandDecl) &&
+                                        if (isNamedExport(shorthandDecl, checker) &&
                                             ts.isIdentifier(shorthandDecl.name)) {
                                             result.exportedName = shorthandDecl.name.text;
                                         }
-                                        else if (ts.isIdentifier(shorthandDecl.name)) {
-                                            // If not exported, still capture the variable name
-                                            result.localName = shorthandDecl.name.text;
-                                        }
                                         break;
                                     }
                                 }
                                 else if (ts.isFunctionExpression(shorthandDecl.initializer) ||
                                     ts.isArrowFunction(shorthandDecl.initializer)) {
-                                    // mainFunc = shorthandDecl.initializer
-                                    // Check if the variable is exported
-                                    if (isNamedExport(shorthandDecl) &&
+                                    if (isNamedExport(shorthandDecl, checker) &&
                                         ts.isIdentifier(shorthandDecl.name)) {
                                         result.exportedName = shorthandDecl.name.text;
                                     }
-                                    else if (ts.isIdentifier(shorthandDecl.name)) {
-                                        // If not exported, still capture the variable name
-                                        result.localName = shorthandDecl.name.text;
-                                    }
                                     break;
                                 }
                             }
@@ -441,11 +248,6 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                                     ts.isIdentifier(shorthandDecl.name)) {
                                     result.exportedName = shorthandDecl.name.text;
                                 }
-                                else if (shorthandDecl.name &&
-                                    ts.isIdentifier(shorthandDecl.name)) {
-                                    // If not exported, still capture the function name
-                                    result.localName = shorthandDecl.name.text;
-                                }
                                 break;
                             }
                         }
@@ -472,9 +274,6 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                     if (ts.isCallExpression(decl.initializer) &&
                         ts.isIdentifier(decl.initializer.expression) &&
                         decl.initializer.expression.text.startsWith('pikku')) {
-                        // Update originalCallExpr to use the call expression position
-                        // instead of the variable declaration position
-                        originalCallExpr = decl.initializer;
                         // Check for object with 'override' property in first argument
                         const firstArg = decl.initializer.arguments[0];
                         if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
@@ -497,26 +296,17 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                             }
                         }
                         // Check if the variable is exported
-                        if (isNamedExport(decl) && ts.isIdentifier(decl.name)) {
+                        if (isNamedExport(decl, checker) && ts.isIdentifier(decl.name)) {
                             result.exportedName = decl.name.text;
                         }
-                        else if (ts.isIdentifier(decl.name)) {
-                            // If not explicitly set by name property above, set functionName
-                            if (!result.localName) {
-                                result.localName = decl.name.text;
-                            }
-                        }
                     }
                     else if (ts.isFunctionExpression(decl.initializer) ||
                         ts.isArrowFunction(decl.initializer)) {
                         // mainFunc = decl.initializer
                         // Check if the variable is exported
-                        if (isNamedExport(decl) && ts.isIdentifier(decl.name)) {
+                        if (isNamedExport(decl, checker) && ts.isIdentifier(decl.name)) {
                             result.exportedName = decl.name.text;
                         }
-                        else if (ts.isIdentifier(decl.name)) {
-                            result.localName = decl.name.text;
-                        }
                     }
                 }
                 else if (ts.isFunctionDeclaration(decl)) {
@@ -527,27 +317,15 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                         ts.isIdentifier(decl.name)) {
                         result.exportedName = decl.name.text;
                     }
-                    else if (decl.name && ts.isIdentifier(decl.name)) {
-                        result.localName = decl.name.text;
-                    }
                 }
             }
         }
     }
-    // Generate the deterministic function name based on the original call expression
-    // (the config), not the resolved inner function. This ensures the metadata key
-    // matches what will be looked up at runtime when referencing the config object.
-    result.pikkuFuncName = makeDeterministicAnonName(originalCallExpr, checker, rootDir);
-    // Continue with regular name extraction for remaining cases
     // 1) const foo = pikkuFunc(...)
     if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
-        if (isNamedExport(parent)) {
+        if (isNamedExport(parent, checker)) {
             result.exportedName = parent.name.text;
         }
-        else {
-            // Still capture the variable name even if not exported
-            result.localName = parent.name.text;
-        }
     }
     // 2) { foo: pikkuFunc(...) }
     else if (ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name)) {
@@ -559,8 +337,8 @@ export function extractFunctionName(callExpr, checker, rootDir) {
         result.propertyName = parent.name.text;
     }
     // 3) Handle any remaining cases for pikkuFunc({ override: '…', func: … })
-    else if (ts.isCallExpression(originalCallExpr)) {
-        const firstArg = originalCallExpr.arguments[0];
+    else if (ts.isCallExpression(callExpr)) {
+        const firstArg = callExpr.arguments[0];
         if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
             for (const prop of firstArg.properties) {
                 if (ts.isPropertyAssignment(prop) &&
@@ -577,9 +355,14 @@ export function extractFunctionName(callExpr, checker, rootDir) {
     }
     // Apply name priority logic
     populateNameByPriority(result);
-    // CRITICAL FIX: If we have an exported name, use it as the pikkuFuncName for consistent lookup
-    if (result.exportedName && !result.explicitName) {
-        result.pikkuFuncName = result.exportedName;
+    if (result.explicitName) {
+        result.pikkuFuncId = result.explicitName;
+    }
+    else if (result.exportedName) {
+        result.pikkuFuncId = result.exportedName;
+    }
+    else {
+        result.pikkuFuncId = `__temp_${randomUUID()}`;
     }
     return result;
 }
@@ -595,32 +378,44 @@ export function populateNameByPriority(result) {
     else if (result.exportedName) {
         result.name = result.exportedName;
     }
-    // Priority 3: If we have a property name, use that
-    // else if (result.propertyName) {
-    //   result.name = result.propertyName
-    // }
     // Fallback: Use the deterministic name, but we could shorten it in the future
     else {
-        // For now, just use the full pikkuFuncName
-        result.name = result.pikkuFuncName;
+        // For now, just use the full pikkuFuncId
+        result.name = result.pikkuFuncId;
     }
 }
 /**
  * Helper function to check if a variable declaration is a named export
  */
-export function isNamedExport(declaration) {
+export function isNamedExport(declaration, checker) {
     let parent = declaration.parent;
     if (!parent)
         return false;
-    // Check if it's part of a variable declaration list
     if (ts.isVariableDeclarationList(parent)) {
         parent = parent.parent;
         if (!parent)
             return false;
-        // Check if it's in an export declaration
         if (ts.isVariableStatement(parent)) {
-            return (parent.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
-                false);
+            if (parent.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+                return true;
+            }
+        }
+    }
+    if (checker && ts.isIdentifier(declaration.name)) {
+        const sourceFile = declaration.getSourceFile();
+        const sourceFileSymbol = checker.getSymbolAtLocation(sourceFile);
+        if (sourceFileSymbol) {
+            const exports = checker.getExportsOfModule(sourceFileSymbol);
+            const declSymbol = checker.getSymbolAtLocation(declaration.name);
+            if (declSymbol) {
+                return exports.some((exp) => {
+                    let resolved = exp;
+                    if (resolved.flags & ts.SymbolFlags.Alias) {
+                        resolved = checker.getAliasedSymbol(resolved) ?? resolved;
+                    }
+                    return resolved === declSymbol;
+                });
+            }
         }
     }
     return false;

package/dist/utils/extract-services.d.ts

@@ -1,6 +1,7 @@
 import * as ts from 'typescript';
-import { FunctionServicesMeta } from '@pikku/core';
+import { FunctionServicesMeta, FunctionWiresMeta } from '@pikku/core';
 /**
  * Extract services from a function's first parameter destructuring pattern
  */
 export declare function extractServicesFromFunction(handlerNode: ts.FunctionExpression | ts.ArrowFunction): FunctionServicesMeta;
+export declare function extractUsedWires(handlerNode: ts.FunctionExpression | ts.ArrowFunction, paramIndex: number): FunctionWiresMeta;

package/dist/utils/extract-services.js

@@ -21,9 +21,33 @@ export function extractServicesFromFunction(handlerNode) {
                 }
             }
         }
-        else if (ts.isIdentifier(firstParam.name)) {
+        else if (ts.isIdentifier(firstParam.name) &&
+            !firstParam.name.text.startsWith('_')) {
             services.optimized = false;
         }
     }
     return services;
 }
+export function extractUsedWires(handlerNode, paramIndex) {
+    const param = handlerNode.parameters[paramIndex];
+    if (param && ts.isObjectBindingPattern(param.name)) {
+        const wires = [];
+        for (const elem of param.name.elements) {
+            const propertyName = elem.propertyName && ts.isIdentifier(elem.propertyName)
+                ? elem.propertyName.text
+                : ts.isIdentifier(elem.name)
+                    ? elem.name.text
+                    : undefined;
+            if (propertyName) {
+                wires.push(propertyName);
+            }
+        }
+        return { optimized: true, wires };
+    }
+    if (param &&
+        ts.isIdentifier(param.name) &&
+        !param.name.text.startsWith('_')) {
+        return { optimized: false, wires: [] };
+    }
+    return { optimized: true, wires: [] };
+}