@pikku/inspector 0.12.74 → 0.12.81

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

@@ -1,612 +0,0 @@
-import * as ts from 'typescript'
-import { createHash } from 'crypto'
-import { relative } from 'path'
-import { formatVersionedId } from '@pikku/core/utils'
-
-/**
- * Deterministic placeholder id for an anonymous/unnamed pikku function or
- * permission. Derived from the call expression's source location (relative path
- * + start position) so `pikku all` produces byte-identical output across runs —
- * a `randomUUID()` here made generated meta non-reproducible. Still `__temp_`
- * prefixed so downstream resolution (which keys off that prefix) is unchanged.
- */
-function tempFuncId(callExpr: ts.Node, rootDir: string): string {
-  const sourceFile = callExpr.getSourceFile()
-  const relPath = relative(rootDir, sourceFile.fileName)
-  const hash = createHash('sha1')
-    .update(`${relPath}:${callExpr.getStart()}`)
-    .digest('hex')
-    .slice(0, 16)
-  return `__temp_${hash}`
-}
-
-export type ExtractedFunctionName = {
-  pikkuFuncId: string
-  name: string
-  explicitName: string | null
-  exportedName: string | null
-  propertyName: string | null
-  isHelper: boolean
-  version: number | null
-}
-
-export function makeContextBasedId(
-  wiringType: string,
-  ...segments: string[]
-): string {
-  return [wiringType, ...segments].join(':')
-}
-
-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('')
-}
-
-/**
- * The step wrappers, whichever kind of subject acts in them. A scenario calls a
- * platform or addon step by name exactly as it calls a persona one.
- */
-const SCENARIO_STEP_WRAPPERS = new Set([
-  'pikkuScenarioStep',
-  'pikkuPlatformScenarioStep',
-  'pikkuAddonScenarioStep',
-])
-
-/**
- * A scenario step is the one wrapper whose `name` is its identity: scenarios
- * reference a step by that string, so it must become the pikkuFuncId (and hence
- * the generated step map's key), not just a cosmetic label the way
- * `pikkuMiddleware`/`pikkuAgent` use it.
- */
-function extractScenarioStepName(
-  callExpr: ts.Node,
-  result: ExtractedFunctionName
-): void {
-  if (
-    !ts.isCallExpression(callExpr) ||
-    !ts.isIdentifier(callExpr.expression) ||
-    !SCENARIO_STEP_WRAPPERS.has(callExpr.expression.text)
-  ) {
-    return
-  }
-  const firstArg = callExpr.arguments[0]
-  if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) {
-    return
-  }
-  for (const prop of firstArg.properties) {
-    if (
-      ts.isPropertyAssignment(prop) &&
-      ts.isIdentifier(prop.name) &&
-      prop.name.text === 'name' &&
-      ts.isStringLiteral(prop.initializer)
-    ) {
-      result.explicitName = prop.initializer.text
-      return
-    }
-  }
-}
-
-export function extractFunctionName(
-  callExpr: ts.Node,
-  checker: ts.TypeChecker,
-  rootDir: string
-): ExtractedFunctionName {
-  const parent: any = callExpr.parent
-
-  // Initialize the result
-  const result: ExtractedFunctionName = {
-    pikkuFuncId: '',
-    name: '',
-    exportedName: null,
-    propertyName: null,
-    explicitName: null,
-    isHelper: false,
-    version: null,
-  }
-
-  extractScenarioStepName(callExpr, result)
-
-  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,
-  // it might be coming from the HTTP route handling flow
-  if (
-    ts.isIdentifier(callExpr) &&
-    callExpr.parent &&
-    ts.isPropertyAssignment(callExpr.parent)
-  ) {
-    // Try to handle the special case for HTTP route functions
-    const sym = checker.getSymbolAtLocation(callExpr)
-    if (sym) {
-      let resolvedSym = sym
-      if (resolvedSym.flags & ts.SymbolFlags.Alias) {
-        resolvedSym = checker.getAliasedSymbol(resolvedSym) ?? resolvedSym
-      }
-
-      const decls = resolvedSym.declarations ?? []
-      if (decls.length > 0) {
-        const decl = decls[0]!
-        // Check if the declaration is a variable that uses a pikkuFun
-        if (ts.isVariableDeclaration(decl) && decl.initializer) {
-          if (
-            ts.isCallExpression(decl.initializer) &&
-            ts.isIdentifier(decl.initializer.expression) &&
-            decl.initializer.expression.text.startsWith('pikku')
-          ) {
-            const args = decl.initializer.arguments
-            const firstArg = args[0]
-            if (
-              firstArg &&
-              (ts.isArrowFunction(firstArg) ||
-                ts.isFunctionExpression(firstArg))
-            ) {
-              // Continue with name extraction
-              if (ts.isIdentifier(parent.name)) {
-                result.propertyName = parent.name.text
-              }
-
-              if (
-                ts.isVariableDeclaration(decl) &&
-                isNamedExport(decl, checker) &&
-                ts.isIdentifier(decl.name)
-              ) {
-                result.exportedName = decl.name.text
-                result.pikkuFuncId = decl.name.text
-              }
-
-              if (!result.pikkuFuncId) {
-                result.pikkuFuncId = tempFuncId(callExpr, rootDir)
-              }
-
-              populateNameByPriority(result)
-              return result
-            }
-          }
-        }
-      }
-    }
-  }
-
-  if (ts.isCallExpression(callExpr)) {
-    const { expression, arguments: args } = callExpr
-
-    // Check if this is a pikku function call (pikkuFunc, pikkuSessionlessFunc, etc)
-    if (ts.isIdentifier(expression) && expression.text.startsWith('pikku')) {
-      // Check for object with 'name' property in first argument
-      const firstArg = args[0]
-      if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-        extractOverrideAndVersion(firstArg, result)
-      }
-
-      // Special handling for pikkuSessionlessFunc pattern - use the arrow function directly
-      if (expression.text.startsWith('pikku')) {
-        if (args.length > 0) {
-          const firstArg = args[0]!
-          if (
-            ts.isArrowFunction(firstArg) ||
-            ts.isFunctionExpression(firstArg)
-          ) {
-            // mainFunc = firstArg // Use the arrow function directly instead of the call expression
-          }
-        }
-      }
-    }
-
-    // Handle object initializer with a func property (for both patterns)
-    if (args.length > 0) {
-      const firstArg = args[0]
-      if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-        // Look for func property in the object
-        for (const prop of firstArg.properties) {
-          if (
-            ts.isPropertyAssignment(prop) &&
-            ts.isIdentifier(prop.name) &&
-            prop.name.text === 'func'
-          ) {
-            if (ts.isIdentifier(prop.initializer)) {
-              // func: someFunction - resolve the function
-              const funcSym = checker.getSymbolAtLocation(prop.initializer)
-              if (funcSym) {
-                let resolvedFuncSym = funcSym
-                if (resolvedFuncSym.flags & ts.SymbolFlags.Alias) {
-                  resolvedFuncSym =
-                    checker.getAliasedSymbol(resolvedFuncSym) ?? resolvedFuncSym
-                }
-
-                const funcDecls = resolvedFuncSym.declarations ?? []
-                if (funcDecls.length > 0) {
-                  const funcDecl = funcDecls[0]!
-                  // Check if it's a pikkuSessionlessFunc
-                  if (
-                    ts.isVariableDeclaration(funcDecl) &&
-                    funcDecl.initializer
-                  ) {
-                    if (
-                      ts.isCallExpression(funcDecl.initializer) &&
-                      ts.isIdentifier(funcDecl.initializer.expression) &&
-                      funcDecl.initializer.expression.text.startsWith('pikku')
-                    ) {
-                      const funcArgs = funcDecl.initializer.arguments
-                      const firstArg = funcArgs[0]
-                      if (
-                        firstArg &&
-                        (ts.isArrowFunction(firstArg) ||
-                          ts.isFunctionExpression(firstArg))
-                      ) {
-                        // mainFunc = firstArg
-
-                        // Check if the variable is exported
-                        if (
-                          isNamedExport(funcDecl, checker) &&
-                          ts.isIdentifier(funcDecl.name)
-                        ) {
-                          result.exportedName = funcDecl.name.text
-                        }
-
-                        break
-                      }
-                    } else if (
-                      ts.isFunctionExpression(funcDecl.initializer) ||
-                      ts.isArrowFunction(funcDecl.initializer)
-                    ) {
-                      if (
-                        isNamedExport(funcDecl, checker) &&
-                        ts.isIdentifier(funcDecl.name)
-                      ) {
-                        result.exportedName = funcDecl.name.text
-                      }
-
-                      break
-                    }
-                  } else if (ts.isFunctionDeclaration(funcDecl)) {
-                    // mainFunc = funcDecl
-
-                    // Check if the function is exported
-                    if (
-                      funcDecl.modifiers?.some(
-                        (m) => m.kind === ts.SyntaxKind.ExportKeyword
-                      ) &&
-                      funcDecl.name &&
-                      ts.isIdentifier(funcDecl.name)
-                    ) {
-                      result.exportedName = funcDecl.name.text
-                    }
-
-                    break
-                  }
-                }
-              } else {
-                // If we can't resolve the symbol, use the identifier itself
-                // mainFunc = prop.initializer
-              }
-              break
-            } else if (
-              ts.isFunctionExpression(prop.initializer) ||
-              ts.isArrowFunction(prop.initializer)
-            ) {
-              // func: () => {} or func: function() {} - use directly
-              // mainFunc = prop.initializer
-              break
-            }
-          } else if (
-            ts.isShorthandPropertyAssignment(prop) &&
-            ts.isIdentifier(prop.name) &&
-            prop.name.text === 'func'
-          ) {
-            // Handle func shorthand property
-            const shorthandSym = checker.getShorthandAssignmentValueSymbol(prop)
-            if (
-              shorthandSym &&
-              shorthandSym.declarations &&
-              shorthandSym.declarations.length > 0
-            ) {
-              const shorthandDecl = shorthandSym.declarations[0]
-              if (!shorthandDecl) {
-                throw new Error('No shorthand declaration found')
-              }
-              if (
-                ts.isVariableDeclaration(shorthandDecl) &&
-                shorthandDecl.initializer
-              ) {
-                if (
-                  ts.isCallExpression(shorthandDecl.initializer) &&
-                  ts.isIdentifier(shorthandDecl.initializer.expression) &&
-                  shorthandDecl.initializer.expression.text.startsWith('pikku')
-                ) {
-                  const args = shorthandDecl.initializer.arguments
-                  const firstArg = args[0]
-                  if (
-                    firstArg &&
-                    (ts.isArrowFunction(firstArg) ||
-                      ts.isFunctionExpression(firstArg))
-                  ) {
-                    // mainFunc = firstArg
-
-                    // Check if the variable is exported
-                    if (
-                      isNamedExport(shorthandDecl, checker) &&
-                      ts.isIdentifier(shorthandDecl.name)
-                    ) {
-                      result.exportedName = shorthandDecl.name.text
-                    }
-
-                    break
-                  }
-                } else if (
-                  ts.isFunctionExpression(shorthandDecl.initializer) ||
-                  ts.isArrowFunction(shorthandDecl.initializer)
-                ) {
-                  if (
-                    isNamedExport(shorthandDecl, checker) &&
-                    ts.isIdentifier(shorthandDecl.name)
-                  ) {
-                    result.exportedName = shorthandDecl.name.text
-                  }
-
-                  break
-                }
-              } else if (ts.isFunctionDeclaration(shorthandDecl)) {
-                // mainFunc = shorthandDecl
-
-                // Check if the function is exported
-                if (
-                  shorthandDecl.modifiers?.some(
-                    (m) => m.kind === ts.SyntaxKind.ExportKeyword
-                  ) &&
-                  shorthandDecl.name &&
-                  ts.isIdentifier(shorthandDecl.name)
-                ) {
-                  result.exportedName = shorthandDecl.name.text
-                }
-
-                break
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  // Handle direct identifier case
-  else if (ts.isIdentifier(callExpr)) {
-    const sym = checker.getSymbolAtLocation(callExpr)
-    if (sym) {
-      let resolvedSym = sym
-      if (resolvedSym.flags & ts.SymbolFlags.Alias) {
-        resolvedSym = checker.getAliasedSymbol(resolvedSym) ?? resolvedSym
-      }
-
-      const decls = resolvedSym.declarations ?? []
-      if (decls.length > 0) {
-        const decl = decls[0]
-        if (!decl) {
-          throw new Error('No declaration found')
-        }
-        if (ts.isVariableDeclaration(decl) && decl.initializer) {
-          if (
-            ts.isCallExpression(decl.initializer) &&
-            ts.isIdentifier(decl.initializer.expression) &&
-            decl.initializer.expression.text.startsWith('pikku')
-          ) {
-            const firstArg = decl.initializer.arguments[0]
-            if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-              extractOverrideAndVersion(firstArg, result)
-            }
-
-            if (decl.initializer.expression.text.startsWith('pikku')) {
-              if (
-                firstArg &&
-                (ts.isArrowFunction(firstArg) ||
-                  ts.isFunctionExpression(firstArg))
-              ) {
-                // mainFunc = firstArg
-              }
-            }
-
-            // Check if the variable is exported
-            if (isNamedExport(decl, checker) && ts.isIdentifier(decl.name)) {
-              result.exportedName = 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, checker) && ts.isIdentifier(decl.name)) {
-              result.exportedName = decl.name.text
-            }
-          }
-        } else if (ts.isFunctionDeclaration(decl)) {
-          // mainFunc = decl
-
-          // Check if the function is exported
-          if (
-            decl.modifiers?.some(
-              (m) => m.kind === ts.SyntaxKind.ExportKeyword
-            ) &&
-            decl.name &&
-            ts.isIdentifier(decl.name)
-          ) {
-            result.exportedName = decl.name.text
-          }
-        }
-      }
-    }
-  }
-
-  // 1) const foo = pikkuFunc(...)
-  if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
-    if (isNamedExport(parent, checker)) {
-      result.exportedName = parent.name.text
-    }
-  }
-  // 2) { foo: pikkuFunc(...) }
-  else if (ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name)) {
-    result.propertyName = parent.name.text
-  }
-  // 2b) Handle shorthand property { foo } - which is equivalent to { foo: foo }
-  else if (
-    ts.isShorthandPropertyAssignment(parent) &&
-    ts.isIdentifier(parent.name)
-  ) {
-    result.propertyName = parent.name.text
-  }
-  // 3) Handle any remaining cases for pikkuFunc({ override: '…', func: … })
-  else if (ts.isCallExpression(callExpr)) {
-    const firstArg = callExpr.arguments[0]
-    if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-      extractOverrideAndVersion(firstArg, result)
-    }
-  }
-
-  // Apply name priority logic
-  populateNameByPriority(result)
-
-  if (result.explicitName) {
-    result.pikkuFuncId = result.explicitName
-  } else if (result.exportedName) {
-    result.pikkuFuncId = result.exportedName
-  } else {
-    result.pikkuFuncId = tempFuncId(callExpr, rootDir)
-  }
-
-  if (result.version !== null) {
-    // Strip trailing VN suffix if it matches the version (e.g. createCardV1 + version:1 → createCard@v1)
-    const vSuffix = `V${result.version}`
-    if (
-      result.pikkuFuncId.endsWith(vSuffix) &&
-      result.pikkuFuncId.length > vSuffix.length
-    ) {
-      result.pikkuFuncId = result.pikkuFuncId.slice(0, -vSuffix.length)
-    }
-    result.pikkuFuncId = formatVersionedId(result.pikkuFuncId, result.version)
-  }
-
-  return result
-}
-
-/**
- * Helper function to populate the 'name' field based on priority
- */
-export function populateNameByPriority(result: ExtractedFunctionName): void {
-  // Priority 1: If we have an explict name, use that
-  if (result.explicitName) {
-    result.name = result.explicitName
-  }
-  // Priority 2: If we have an exported name, use that
-  else if (result.exportedName) {
-    result.name = result.exportedName
-  }
-  // Fallback: Use the deterministic name, but we could shorten it in the future
-  else {
-    // 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,
-  checker?: ts.TypeChecker
-): boolean {
-  let parent: any = declaration.parent
-  if (!parent) return false
-
-  if (ts.isVariableDeclarationList(parent)) {
-    parent = parent.parent
-    if (!parent) return false
-
-    if (ts.isVariableStatement(parent)) {
-      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
-}
-
-function extractOverrideAndVersion(
-  objLiteral: ts.ObjectLiteralExpression,
-  result: ExtractedFunctionName
-): void {
-  for (const prop of objLiteral.properties) {
-    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
-      if (
-        prop.name.text === 'override' &&
-        ts.isStringLiteral(prop.initializer) &&
-        !result.explicitName
-      ) {
-        result.explicitName = prop.initializer.text
-      } else if (
-        prop.name.text === 'version' &&
-        ts.isNumericLiteral(prop.initializer) &&
-        result.version === null
-      ) {
-        const parsed = Number(prop.initializer.text)
-        if (Number.isInteger(parsed) && parsed >= 1) {
-          result.version = parsed
-        }
-      }
-    }
-  }
-}

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

@@ -1,70 +0,0 @@
-import * as ts from 'typescript'
-import {
-  getPropertyAssignmentInitializer,
-  resolveFunctionDeclaration,
-} from './type-utils.js'
-
-/**
- * Where a config object's implementation can live, in the order it is looked for.
- *
- * `func` is the ordinary case. A `pikkuScenarioStep` instead declares one
- * implementation per surface, and every binding shares the step's input and
- * output — that is what makes them interchangeable — so any one of them types
- * the step. `default` is preferred because it is the binding every step is
- * expected to have.
- */
-const IMPLEMENTATION_KEYS = ['func', 'default', 'browser', 'cli'] as const
-
-/**
- * Extracts the actual function node from a pikkuFunc/pikkuWorkflowFunc call
- * Handles both direct function form and config object form { func: ... }
- */
-export function extractFunctionNode(
-  firstArg: ts.Expression,
-  checker: ts.TypeChecker
-): {
-  funcNode: ts.Node
-  resolvedFunc: ts.Node | null
-  isDirectFunction: boolean
-} {
-  let funcNode: ts.Node = firstArg
-  let isDirectFunction = true
-
-  // Check if first argument is a config object with 'func' property
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    isDirectFunction = false
-    let funcInitializer: ts.Expression | undefined
-    for (const key of IMPLEMENTATION_KEYS) {
-      funcInitializer =
-        getPropertyAssignmentInitializer(firstArg, key, true, checker) ??
-        undefined
-      if (funcInitializer) break
-    }
-
-    if (funcInitializer) {
-      funcNode = funcInitializer
-    } else {
-      // Return the original node if no func property found
-      // Caller should handle validation
-      funcNode = firstArg
-    }
-  }
-
-  // Resolve identifier to get the actual function node
-  if (ts.isIdentifier(funcNode)) {
-    const symbol = checker.getSymbolAtLocation(funcNode)
-    const decl = symbol?.valueDeclaration || symbol?.declarations?.[0]
-    if (decl && ts.isVariableDeclaration(decl) && decl.initializer) {
-      funcNode = decl.initializer
-    }
-  }
-
-  // Resolve function declaration for deeper analysis
-  const resolvedFunc = resolveFunctionDeclaration(funcNode, checker)
-
-  return {
-    funcNode,
-    resolvedFunc,
-    isDirectFunction,
-  }
-}