@pikku/inspector 0.9.5 → 0.10.0

package/src/{utils.ts → utils/extract-function-name.ts}

@@ -1,8 +1,7 @@
 import * as ts from 'typescript'
-import { InspectorFilters, InspectorLogger } from './types.js'
-import { PikkuWiringTypes, FunctionServicesMeta } from '@pikku/core'
+import { toRelativePath } from './find-root-dir.js'
 
-type ExtractedFunctionName = {
+export type ExtractedFunctionName = {
   pikkuFuncName: string
   name: string
   explicitName: string | null
@@ -18,7 +17,8 @@ type ExtractedFunctionName = {
  */
 export function makeDeterministicAnonName(
   start: ts.Node,
-  checker: ts.TypeChecker
+  checker: ts.TypeChecker,
+  rootDir: string
 ): string {
   let node: ts.Node = start
   let target: ts.Node = start
@@ -47,7 +47,8 @@ export function makeDeterministicAnonName(
           target = decl.initializer
           // Return early - we found the function directly
           const sf = target.getSourceFile()
-          const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_')
+          const relativePath = toRelativePath(sf.fileName, rootDir)
+          const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_')
           const { line, character } = ts.getLineAndCharacterOfPosition(
             sf,
             target.getStart()
@@ -93,7 +94,8 @@ export function makeDeterministicAnonName(
             target = decl.initializer
             // Return early - we found the function directly
             const sf = target.getSourceFile()
-            const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_')
+            const relativePath = toRelativePath(sf.fileName, rootDir)
+            const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_')
             const { line, character } = ts.getLineAndCharacterOfPosition(
               sf,
               target.getStart()
@@ -105,7 +107,8 @@ export function makeDeterministicAnonName(
           target = decl
           // Return early
           const sf = target.getSourceFile()
-          const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_')
+          const relativePath = toRelativePath(sf.fileName, rootDir)
+          const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_')
           const { line, character } = ts.getLineAndCharacterOfPosition(
             sf,
             target.getStart()
@@ -240,7 +243,8 @@ export function makeDeterministicAnonName(
   }
 
   const sf = target.getSourceFile()
-  const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_')
+  const relativePath = toRelativePath(sf.fileName, rootDir)
+  const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_')
   const { line, character } = ts.getLineAndCharacterOfPosition(
     sf,
     target.getStart()
@@ -257,7 +261,8 @@ export function makeDeterministicAnonName(
  */
 export function extractFunctionName(
   callExpr: ts.Node,
-  checker: ts.TypeChecker
+  checker: ts.TypeChecker,
+  rootDir: string
 ): ExtractedFunctionName {
   const parent: any = callExpr.parent
 
@@ -306,7 +311,8 @@ export function extractFunctionName(
               // Use the function directly for position calculation
               result.pikkuFuncName = makeDeterministicAnonName(
                 firstArg,
-                checker
+                checker,
+                rootDir
               )
 
               // Continue with name extraction
@@ -338,9 +344,8 @@ export function extractFunctionName(
     }
   }
 
-  // First, figure out what function we're really dealing with
-  let mainFunc = callExpr
-  let originalCallExpr = callExpr // Keep track of the original call expression for name extraction
+  // 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)) {
@@ -373,7 +378,7 @@ export function extractFunctionName(
             ts.isArrowFunction(firstArg) ||
             ts.isFunctionExpression(firstArg)
           ) {
-            mainFunc = firstArg // Use the arrow function directly instead of the call expression
+            // mainFunc = firstArg // Use the arrow function directly instead of the call expression
           }
         }
       }
@@ -420,7 +425,7 @@ export function extractFunctionName(
                         (ts.isArrowFunction(firstArg) ||
                           ts.isFunctionExpression(firstArg))
                       ) {
-                        mainFunc = firstArg
+                        // mainFunc = firstArg
 
                         // Check if the variable is exported
                         if (
@@ -439,7 +444,7 @@ export function extractFunctionName(
                       ts.isFunctionExpression(funcDecl.initializer) ||
                       ts.isArrowFunction(funcDecl.initializer)
                     ) {
-                      mainFunc = funcDecl.initializer
+                      // mainFunc = funcDecl.initializer
 
                       // Check if the variable is exported
                       if (
@@ -455,7 +460,7 @@ export function extractFunctionName(
                       break
                     }
                   } else if (ts.isFunctionDeclaration(funcDecl)) {
-                    mainFunc = funcDecl
+                    // mainFunc = funcDecl
 
                     // Check if the function is exported
                     if (
@@ -479,7 +484,7 @@ export function extractFunctionName(
                 }
               } else {
                 // If we can't resolve the symbol, use the identifier itself
-                mainFunc = prop.initializer
+                // mainFunc = prop.initializer
               }
               break
             } else if (
@@ -487,7 +492,7 @@ export function extractFunctionName(
               ts.isArrowFunction(prop.initializer)
             ) {
               // func: () => {} or func: function() {} - use directly
-              mainFunc = prop.initializer
+              // mainFunc = prop.initializer
               break
             }
           } else if (
@@ -522,7 +527,7 @@ export function extractFunctionName(
                     (ts.isArrowFunction(firstArg) ||
                       ts.isFunctionExpression(firstArg))
                   ) {
-                    mainFunc = firstArg
+                    // mainFunc = firstArg
 
                     // Check if the variable is exported
                     if (
@@ -541,7 +546,7 @@ export function extractFunctionName(
                   ts.isFunctionExpression(shorthandDecl.initializer) ||
                   ts.isArrowFunction(shorthandDecl.initializer)
                 ) {
-                  mainFunc = shorthandDecl.initializer
+                  // mainFunc = shorthandDecl.initializer
 
                   // Check if the variable is exported
                   if (
@@ -557,7 +562,7 @@ export function extractFunctionName(
                   break
                 }
               } else if (ts.isFunctionDeclaration(shorthandDecl)) {
-                mainFunc = shorthandDecl
+                // mainFunc = shorthandDecl
 
                 // Check if the function is exported
                 if (
@@ -605,6 +610,10 @@ 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 'name' property in first argument
             const firstArg = decl.initializer.arguments[0]
             if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
@@ -628,7 +637,7 @@ export function extractFunctionName(
                 (ts.isArrowFunction(firstArg) ||
                   ts.isFunctionExpression(firstArg))
               ) {
-                mainFunc = firstArg
+                // mainFunc = firstArg
               }
             }
 
@@ -645,7 +654,7 @@ export function extractFunctionName(
             ts.isFunctionExpression(decl.initializer) ||
             ts.isArrowFunction(decl.initializer)
           ) {
-            mainFunc = decl.initializer
+            // mainFunc = decl.initializer
 
             // Check if the variable is exported
             if (isNamedExport(decl) && ts.isIdentifier(decl.name)) {
@@ -655,7 +664,7 @@ export function extractFunctionName(
             }
           }
         } else if (ts.isFunctionDeclaration(decl)) {
-          mainFunc = decl
+          // mainFunc = decl
 
           // Check if the function is exported
           if (
@@ -674,8 +683,14 @@ export function extractFunctionName(
     }
   }
 
-  // Now generate the deterministic function name based on the resolved function
-  result.pikkuFuncName = makeDeterministicAnonName(mainFunc, checker)
+  // 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(...)
@@ -731,7 +746,7 @@ export function extractFunctionName(
 /**
  * Helper function to populate the 'name' field based on priority
  */
-function populateNameByPriority(result: ExtractedFunctionName): void {
+export function populateNameByPriority(result: ExtractedFunctionName): void {
   // Priority 1: If we have an explict name, use that
   if (result.explicitName) {
     result.name = result.explicitName
@@ -754,7 +769,7 @@ function populateNameByPriority(result: ExtractedFunctionName): void {
 /**
  * Helper function to check if a variable declaration is a named export
  */
-function isNamedExport(declaration: ts.VariableDeclaration): boolean {
+export function isNamedExport(declaration: ts.VariableDeclaration): boolean {
   let parent: any = declaration.parent
   if (!parent) return false
 
@@ -774,180 +789,3 @@ function isNamedExport(declaration: ts.VariableDeclaration): boolean {
 
   return false
 }
-
-// Until here
-export const extractTypeKeys = (type: ts.Type): string[] => {
-  return type.getProperties().map((symbol) => symbol.getName())
-}
-
-export function getPropertyAssignmentInitializer(
-  obj: ts.ObjectLiteralExpression,
-  propName: string,
-  followShorthand = false,
-  checker?: ts.TypeChecker
-): ts.Expression | undefined {
-  for (const prop of obj.properties) {
-    // ①  foo: () => {}
-    if (
-      ts.isPropertyAssignment(prop) &&
-      ts.isIdentifier(prop.name) &&
-      prop.name.text === propName
-    ) {
-      return prop.initializer
-    }
-
-    // ②  foo() { … }
-    if (
-      ts.isMethodDeclaration(prop) &&
-      ts.isIdentifier(prop.name) &&
-      prop.name.text === propName
-    ) {
-      return prop.name // the method node *is* the function
-    }
-
-    // ③  { foo }  (shorthand)
-    if (
-      followShorthand &&
-      ts.isShorthandPropertyAssignment(prop) &&
-      prop.name.text === propName
-    ) {
-      if (!checker) return prop.name // best effort without a checker
-
-      let sym = checker.getSymbolAtLocation(prop.name)
-      if (sym && sym.flags & ts.SymbolFlags.Alias) {
-        sym = checker.getAliasedSymbol(sym)
-      }
-
-      const decl = sym?.declarations?.[0]
-
-      // const foo = () => {}
-      if (
-        decl &&
-        ts.isVariableDeclaration(decl) &&
-        decl.initializer &&
-        (ts.isArrowFunction(decl.initializer) ||
-          ts.isFunctionExpression(decl.initializer))
-      ) {
-        return decl.initializer
-      }
-
-      // function foo() {}
-      if (
-        decl &&
-        (ts.isFunctionDeclaration(decl) ||
-          ts.isArrowFunction(decl) ||
-          ts.isFunctionExpression(decl))
-      ) {
-        return decl as ts.Expression
-      }
-
-      // fallback – just give back the identifier
-      return prop.name
-    }
-  }
-
-  return undefined
-}
-
-export const matchesFilters = (
-  filters: InspectorFilters,
-  params: { tags?: string[] },
-  meta: {
-    type: PikkuWiringTypes
-    name: string
-    filePath?: string
-  },
-  logger: InspectorLogger
-) => {
-  // If no filters are provided, allow everything
-  if (Object.keys(filters).length === 0) {
-    return true
-  }
-
-  // If all filter arrays are empty, allow everything
-  if (
-    (!filters.tags || filters.tags.length === 0) &&
-    (!filters.types || filters.types.length === 0) &&
-    (!filters.directories || filters.directories.length === 0)
-  ) {
-    return true
-  }
-
-  // Check type filter
-  if (filters.types && filters.types.length > 0) {
-    if (!filters.types.includes(meta.type)) {
-      logger.debug(`⒡ Filtered by type: ${meta.type}:${meta.name}`)
-      return false
-    }
-  }
-
-  // Check directory filter
-  if (filters.directories && filters.directories.length > 0) {
-    if (!meta.filePath) {
-      logger.debug(
-        `⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`
-      )
-      return false
-    }
-
-    const matchesDirectory = filters.directories.some((dir) => {
-      // Normalize paths for comparison
-      const normalizedFilePath = meta.filePath!.replace(/\\/g, '/')
-      const normalizedDir = dir.replace(/\\/g, '/')
-      return normalizedFilePath.includes(normalizedDir)
-    })
-
-    if (!matchesDirectory) {
-      logger.debug(
-        `⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`
-      )
-      return false
-    }
-  }
-
-  // Check tag filter
-  if (filters.tags && filters.tags.length > 0) {
-    if (
-      !params.tags ||
-      !filters.tags.some((tag) => params.tags!.includes(tag))
-    ) {
-      logger.debug(`⒡ Filtered by tags: ${meta.type}:${meta.name}`)
-      return false
-    }
-  }
-
-  return true
-}
-
-/**
- * Extract services from a function's first parameter destructuring pattern
- */
-export function extractServicesFromFunction(
-  handlerNode: ts.FunctionExpression | ts.ArrowFunction
-): FunctionServicesMeta {
-  const services: FunctionServicesMeta = {
-    optimized: true,
-    services: [],
-  }
-
-  const firstParam = handlerNode.parameters[0]
-  if (firstParam) {
-    if (ts.isObjectBindingPattern(firstParam.name)) {
-      for (const elem of firstParam.name.elements) {
-        const original =
-          elem.propertyName && ts.isIdentifier(elem.propertyName)
-            ? elem.propertyName.text
-            : ts.isIdentifier(elem.name)
-              ? elem.name.text
-              : undefined
-        if (original) {
-          services.services.push(original)
-        }
-      }
-    } else if (ts.isIdentifier(firstParam.name)) {
-      services.optimized = false
-    }
-  }
-
-  return services
-}

package/src/utils/extract-services.ts

@@ -0,0 +1,35 @@
+import * as ts from 'typescript'
+import { FunctionServicesMeta } from '@pikku/core'
+
+/**
+ * Extract services from a function's first parameter destructuring pattern
+ */
+export function extractServicesFromFunction(
+  handlerNode: ts.FunctionExpression | ts.ArrowFunction
+): FunctionServicesMeta {
+  const services: FunctionServicesMeta = {
+    optimized: true,
+    services: [],
+  }
+
+  const firstParam = handlerNode.parameters[0]
+  if (firstParam) {
+    if (ts.isObjectBindingPattern(firstParam.name)) {
+      for (const elem of firstParam.name.elements) {
+        const original =
+          elem.propertyName && ts.isIdentifier(elem.propertyName)
+            ? elem.propertyName.text
+            : ts.isIdentifier(elem.name)
+              ? elem.name.text
+              : undefined
+        if (original) {
+          services.services.push(original)
+        }
+      }
+    } else if (ts.isIdentifier(firstParam.name)) {
+      services.optimized = false
+    }
+  }
+
+  return services
+}