@pikku/inspector 0.11.2 → 0.12.0

package/src/utils/extract-function-name.ts

@@ -1,264 +1,30 @@
 import * as ts from 'typescript'
-import { toRelativePath } from './find-root-dir.js'
+import { randomUUID } from 'crypto'
 
 export type ExtractedFunctionName = {
-  pikkuFuncName: string
+  pikkuFuncId: string
   name: string
   explicitName: string | null
   exportedName: string | null
-  localName: string | null
   propertyName: string | null
+  isHelper: boolean
 }
 
-/**
- * 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: ts.Node,
-  checker: ts.TypeChecker,
-  rootDir: string
+export function makeContextBasedId(
+  wiringType: string,
+  ...segments: string[]
 ): string {
-  let node: ts.Node = start
-  let target: ts.Node = 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<ts.Node>()
-  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
-  }
+  return [wiringType, ...segments].join(':')
+}
 
-  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}`
+export function funcIdToTypeName(id: string): string {
+  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: ts.Node,
   checker: ts.TypeChecker,
@@ -268,12 +34,46 @@ export function extractFunctionName(
 
   // Initialize the result
   const result: ExtractedFunctionName = {
-    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: string
+      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,
@@ -308,33 +108,24 @@ export function extractFunctionName(
               (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
-              } else if (ts.isIdentifier(decl.name)) {
-                // If not exported, still capture the variable name
-                result.localName = decl.name.text
+                result.pikkuFuncId = decl.name.text
+              }
+
+              if (!result.pikkuFuncId) {
+                result.pikkuFuncId = `__temp_${randomUUID()}`
               }
 
-              // Apply name priority logic
               populateNameByPriority(result)
               return result
             }
@@ -344,10 +135,6 @@ export function extractFunctionName(
     }
   }
 
-  // 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
 
@@ -429,13 +216,10 @@ export function extractFunctionName(
 
                         // Check if the variable is exported
                         if (
-                          isNamedExport(funcDecl) &&
+                          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
@@ -444,17 +228,11 @@ export function extractFunctionName(
                       ts.isFunctionExpression(funcDecl.initializer) ||
                       ts.isArrowFunction(funcDecl.initializer)
                     ) {
-                      // mainFunc = funcDecl.initializer
-
-                      // Check if the variable is exported
                       if (
-                        isNamedExport(funcDecl) &&
+                        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
@@ -471,12 +249,6 @@ export function extractFunctionName(
                       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
@@ -531,13 +303,10 @@ export function extractFunctionName(
 
                     // Check if the variable is exported
                     if (
-                      isNamedExport(shorthandDecl) &&
+                      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
@@ -546,17 +315,11 @@ export function extractFunctionName(
                   ts.isFunctionExpression(shorthandDecl.initializer) ||
                   ts.isArrowFunction(shorthandDecl.initializer)
                 ) {
-                  // mainFunc = shorthandDecl.initializer
-
-                  // Check if the variable is exported
                   if (
-                    isNamedExport(shorthandDecl) &&
+                    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
@@ -573,12 +336,6 @@ export function extractFunctionName(
                   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
@@ -610,10 +367,6 @@ export function extractFunctionName(
             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)) {
@@ -642,13 +395,8 @@ export function extractFunctionName(
             }
 
             // 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) ||
@@ -657,10 +405,8 @@ export function extractFunctionName(
             // 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)) {
@@ -675,31 +421,16 @@ export function extractFunctionName(
             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(...) }
@@ -714,8 +445,8 @@ export function extractFunctionName(
     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 (
@@ -735,9 +466,12 @@ export function extractFunctionName(
   // 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
@@ -755,35 +489,51 @@ export function populateNameByPriority(result: ExtractedFunctionName): void {
   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: ts.VariableDeclaration): boolean {
+export function isNamedExport(
+  declaration: ts.VariableDeclaration,
+  checker?: ts.TypeChecker
+): boolean {
   let parent: any = 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
+        })
+      }
     }
   }
 

package/src/utils/extract-services.ts

@@ -1,5 +1,5 @@
 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
@@ -26,10 +26,43 @@ export function extractServicesFromFunction(
           services.services.push(original)
         }
       }
-    } 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: ts.FunctionExpression | ts.ArrowFunction,
+  paramIndex: number
+): FunctionWiresMeta {
+  const param = handlerNode.parameters[paramIndex]
+  if (param && ts.isObjectBindingPattern(param.name)) {
+    const wires: string[] = []
+    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: [] }
+}