@pikku/inspector 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @pikku/inspector
 
+## 0.7.1
+
+### Patch Changes
+
+- ebfb786: fix: only inspect function calls with pikku\*func in name
+
 ## 0.7.0
 
 This has changed significantly. The inspector now finds all functions and then links them to events.

package/dist/add-functions.js

@@ -176,6 +176,15 @@ export function addFunctions(node, checker, state, filters) {
         return;
     const { expression, arguments: args, typeArguments } = node;
     // only handle calls like pikkuFunc(...)
+    if (!ts.isIdentifier(expression)) {
+        return;
+    }
+    // Match identifiers that contain both "pikku" and "func" (case insensitive)
+    const pikkuFuncPattern = /pikku.*func/i;
+    if (!pikkuFuncPattern.test(expression.text)) {
+        return;
+    }
+    // only handle calls like pikkuFunc(...)
     if (!ts.isIdentifier(expression) || !expression.text.startsWith('pikku')) {
         return;
     }
@@ -196,7 +205,7 @@ export function addFunctions(node, checker, state, filters) {
     }
     if (!ts.isArrowFunction(handlerNode) &&
         !ts.isFunctionExpression(handlerNode)) {
-        console.error(`• Handler for TODO is not a function.`);
+        console.error(`• Handler for ${name} is not a function.`);
         return;
     }
     const services = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "type": "module",

package/src/add-channel.ts

@@ -0,0 +1,482 @@
+import * as ts from 'typescript'
+import { getPropertyValue } from './get-property-value.js'
+import { pathToRegexp } from 'path-to-regexp'
+import { APIDocs } from '@pikku/core'
+import { getInputTypes } from './add-http-route.js'
+import {
+  extractFunctionName,
+  getPropertyAssignmentInitializer,
+  matchesFilters,
+} from './utils.js'
+import type { ChannelMessageMeta, ChannelMeta } from '@pikku/core/channel'
+import type { InspectorFilters, InspectorState } from './types.js'
+
+/**
+ * Safely get the “initializer” expression of a property-like AST node:
+ * - for `foo: expr`, returns `expr`
+ * - for `{ foo }` shorthand, returns the identifier `foo`
+ * - otherwise, returns undefined
+ */
+function getInitializerOf(
+  elem: ts.ObjectLiteralElementLike
+): ts.Expression | undefined {
+  if (ts.isPropertyAssignment(elem)) {
+    return elem.initializer
+  }
+  if (ts.isShorthandPropertyAssignment(elem)) {
+    return elem.name
+  }
+  return undefined
+}
+
+/**
+ * Resolve a handler expression (Identifier, CallExpression, or { func })
+ * into its underlying function name.
+ */
+function getHandlerNameFromExpression(
+  expr: ts.Expression,
+  checker: ts.TypeChecker
+): string | null {
+  // Handle direct identifier case (which includes shorthand properties)
+  if (ts.isIdentifier(expr)) {
+    const sym = checker.getSymbolAtLocation(expr)
+    if (sym) {
+      let resolvedSym = sym
+      if (resolvedSym.flags & ts.SymbolFlags.Alias) {
+        resolvedSym = checker.getAliasedSymbol(resolvedSym) ?? resolvedSym
+      }
+
+      // Try to get declarations
+      const decls = resolvedSym.declarations ?? []
+      if (decls.length > 0) {
+        const decl = decls[0]!
+
+        // For variable declarations, look at the initializer
+        if (ts.isVariableDeclaration(decl) && decl.initializer) {
+          if (
+            ts.isCallExpression(decl.initializer) ||
+            ts.isArrowFunction(decl.initializer) ||
+            ts.isFunctionExpression(decl.initializer)
+          ) {
+            // Extract function name from the declaration's initializer
+            const { pikkuFuncName } = extractFunctionName(
+              decl.initializer,
+              checker
+            )
+            return pikkuFuncName
+          }
+        }
+        // For function declarations, use directly
+        else if (ts.isFunctionDeclaration(decl)) {
+          const { pikkuFuncName } = extractFunctionName(decl, checker)
+          return pikkuFuncName
+        }
+      }
+    }
+
+    // Fallback: try to extract directly from the identifier
+    const { pikkuFuncName } = extractFunctionName(expr, checker)
+    return pikkuFuncName
+  }
+
+  // Handle call expressions
+  if (ts.isCallExpression(expr)) {
+    const { pikkuFuncName } = extractFunctionName(expr, checker)
+    return pikkuFuncName
+  }
+
+  // Handle object literals with 'func' property
+  if (ts.isObjectLiteralExpression(expr)) {
+    const fnProp = getPropertyAssignmentInitializer(expr, 'func', true, checker)
+    if (fnProp) {
+      return getHandlerNameFromExpression(fnProp, checker)
+    }
+  }
+
+  return null
+}
+
+/**
+ * Build out the nested message-routes by looking up each handler
+ * in state.functions.meta instead of re-inferring it here.
+ */
+export function addMessagesRoutes(
+  obj: ts.ObjectLiteralExpression,
+  state: InspectorState,
+  checker: ts.TypeChecker
+): ChannelMeta['messageRoutes'] {
+  const result: ChannelMeta['messageRoutes'] = {}
+  const onMsgRouteProp = getPropertyAssignmentInitializer(
+    obj,
+    'onMessageRoute',
+    true,
+    checker
+  )
+  if (!onMsgRouteProp) return result
+
+  if (!onMsgRouteProp || !ts.isObjectLiteralExpression(onMsgRouteProp))
+    return result
+
+  for (const chanElem of onMsgRouteProp.properties) {
+    const chanInit = getInitializerOf(chanElem)
+    if (!chanInit || !ts.isObjectLiteralExpression(chanInit)) continue
+
+    const channelKey = chanElem.name!.getText()
+    result[channelKey] = {}
+
+    for (const routeElem of chanInit.properties) {
+      const init = getInitializerOf(routeElem)
+      if (!init) continue
+
+      const routeKey = routeElem.name!.getText()
+
+      // For shorthand properties, we need to resolve the identifier to its declaration
+      if (ts.isShorthandPropertyAssignment(routeElem)) {
+        // Get the symbol for the shorthand property
+        const shorthandSym =
+          checker.getShorthandAssignmentValueSymbol(routeElem)
+
+        if (
+          shorthandSym &&
+          shorthandSym.declarations &&
+          shorthandSym.declarations.length > 0
+        ) {
+          const shorthandDecl = shorthandSym.declarations[0]
+          if (!shorthandDecl) {
+            throw new Error(
+              `No declaration found for shorthand property '${routeKey}'`
+            )
+          }
+
+          // Handle import specifiers
+          if (ts.isImportSpecifier(shorthandDecl)) {
+            // Get the imported symbol
+            const importedSymbol = checker.getSymbolAtLocation(
+              shorthandDecl.name
+            )
+            if (importedSymbol) {
+              // Try to resolve the alias to get the original symbol
+              let resolvedSymbol = importedSymbol
+              if (resolvedSymbol.flags & ts.SymbolFlags.Alias) {
+                resolvedSymbol =
+                  checker.getAliasedSymbol(resolvedSymbol) ?? resolvedSymbol
+              }
+
+              // Try to get the declarations of the resolved symbol
+              const importDecls = resolvedSymbol.declarations ?? []
+              if (importDecls.length > 0) {
+                const importDecl = importDecls[0]!
+
+                // Handle different kinds of declarations
+                if (
+                  ts.isVariableDeclaration(importDecl) &&
+                  importDecl.initializer
+                ) {
+                  // Extract from the initializer if it's a function
+                  if (
+                    ts.isArrowFunction(importDecl.initializer) ||
+                    ts.isFunctionExpression(importDecl.initializer) ||
+                    ts.isCallExpression(importDecl.initializer)
+                  ) {
+                    const { pikkuFuncName } = extractFunctionName(
+                      importDecl.initializer,
+                      checker
+                    )
+                    const handlerName = pikkuFuncName
+
+                    // Look up in the registry
+                    const fnMeta = state.functions.meta[handlerName]
+                    if (fnMeta) {
+                      result[channelKey]![routeKey] = {
+                        pikkuFuncName: handlerName,
+                        inputs: fnMeta.inputs ?? null,
+                        outputs: fnMeta.outputs ?? null,
+                      }
+                      continue
+                    }
+                  }
+                } else if (ts.isFunctionDeclaration(importDecl)) {
+                  // Extract from the function declaration
+                  const { pikkuFuncName } = extractFunctionName(
+                    importDecl,
+                    checker
+                  )
+                  const handlerName = pikkuFuncName
+
+                  // Look up in the registry
+                  const fnMeta = state.functions.meta[handlerName]
+                  if (fnMeta) {
+                    result[channelKey]![routeKey] = {
+                      pikkuFuncName: handlerName,
+                      inputs: fnMeta.inputs ?? null,
+                      outputs: fnMeta.outputs ?? null,
+                    }
+                    continue
+                  }
+                } else if (ts.isExportSpecifier(importDecl)) {
+                  // For re-exports, we need to follow another level of indirection
+                  const exportSymbol = checker.getSymbolAtLocation(
+                    importDecl.name
+                  )
+                  if (exportSymbol) {
+                    let resolvedExportSymbol = exportSymbol
+                    if (resolvedExportSymbol.flags & ts.SymbolFlags.Alias) {
+                      resolvedExportSymbol =
+                        checker.getAliasedSymbol(resolvedExportSymbol) ??
+                        resolvedExportSymbol
+                    }
+
+                    const exportDecls = resolvedExportSymbol.declarations ?? []
+                    if (exportDecls.length > 0) {
+                      const exportDecl = exportDecls[0]!
+
+                      if (
+                        ts.isVariableDeclaration(exportDecl) &&
+                        exportDecl.initializer
+                      ) {
+                        const { pikkuFuncName } = extractFunctionName(
+                          exportDecl.initializer,
+                          checker
+                        )
+                        const handlerName = pikkuFuncName
+
+                        const fnMeta = state.functions.meta[handlerName]
+                        if (fnMeta) {
+                          result[channelKey]![routeKey] = {
+                            pikkuFuncName: handlerName,
+                            inputs: fnMeta.inputs ?? null,
+                            outputs: fnMeta.outputs ?? null,
+                          }
+                          continue
+                        }
+                      } else if (ts.isFunctionDeclaration(exportDecl)) {
+                        const { pikkuFuncName } = extractFunctionName(
+                          exportDecl,
+                          checker
+                        )
+                        const handlerName = pikkuFuncName
+
+                        const fnMeta = state.functions.meta[handlerName]
+                        if (fnMeta) {
+                          result[channelKey]![routeKey] = {
+                            pikkuFuncName: handlerName,
+                            inputs: fnMeta.inputs ?? null,
+                            outputs: fnMeta.outputs ?? null,
+                          }
+                          continue
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+
+            // As a fallback, try to look up by name
+            const funcName = shorthandDecl.name.getText()
+
+            // Look for any function in the registry that ends with this name
+            const possibleMatch = Object.keys(state.functions.meta).find(
+              (key) => {
+                const parts = key.split('_')
+                const filename = parts[parts.length - 3] || ''
+                return filename.endsWith(funcName)
+              }
+            )
+
+            if (possibleMatch) {
+              const fnMeta = state.functions.meta[possibleMatch]
+              if (!fnMeta) {
+                console.error(
+                  `No function metadata found for handler '${possibleMatch}'`
+                )
+                continue
+              }
+              result[channelKey]![routeKey] = {
+                pikkuFuncName: possibleMatch,
+                inputs: fnMeta.inputs ?? null,
+                outputs: fnMeta.outputs ?? null,
+              }
+              continue
+            }
+          } else {
+            // Handle other declaration types (variable, function, etc.)
+            let actualFunction: ts.Node | undefined = undefined
+
+            if (ts.isVariableDeclaration(shorthandDecl)) {
+              // Check if it has an initializer
+              if (shorthandDecl.initializer) {
+                // If it's a function expression or similar, use that
+                if (
+                  ts.isArrowFunction(shorthandDecl.initializer) ||
+                  ts.isFunctionExpression(shorthandDecl.initializer) ||
+                  ts.isCallExpression(shorthandDecl.initializer)
+                ) {
+                  actualFunction = shorthandDecl.initializer
+                }
+              }
+            } else if (ts.isFunctionDeclaration(shorthandDecl)) {
+              actualFunction = shorthandDecl
+            }
+
+            // If we found the actual function, extract its name
+            if (actualFunction) {
+              // Extract the function name directly from the actual function
+              const { pikkuFuncName } = extractFunctionName(
+                actualFunction,
+                checker
+              )
+              const handlerName = pikkuFuncName
+
+              // Now use this handlerName to look up in the registry
+              const fnMeta = state.functions.meta[handlerName]
+
+              if (fnMeta) {
+                result[channelKey]![routeKey] = {
+                  pikkuFuncName: handlerName,
+                  inputs: fnMeta.inputs ?? null,
+                  outputs: fnMeta.outputs ?? null,
+                }
+                continue // Skip the normal processing below
+              }
+            }
+          }
+        }
+      }
+
+      // Normal processing for non-shorthand properties
+      const handlerName = getHandlerNameFromExpression(init, checker)
+      if (!handlerName) {
+        console.error(
+          `Could not resolve handler for message route '${routeKey}'`
+        )
+        continue
+      }
+
+      const fnMeta = state.functions.meta[handlerName]
+      if (!fnMeta) {
+        console.error(`No function metadata found for handler '${handlerName}'`)
+        continue
+      }
+
+      result[channelKey]![routeKey] = {
+        pikkuFuncName: handlerName,
+        inputs: fnMeta.inputs ?? null,
+        outputs: fnMeta.outputs ?? null,
+      }
+    }
+  }
+
+  return result
+}
+
+/**
+ * Inspect addChannel calls, look up all handlers in state.functions.meta,
+ * and emit one entry into state.channels.meta.
+ */
+export function addChannel(
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  state: InspectorState,
+  filters: InspectorFilters
+) {
+  if (!ts.isCallExpression(node)) return
+  const { expression, arguments: args } = node
+  if (!ts.isIdentifier(expression) || expression.text !== 'addChannel') return
+  const first = args[0]
+  if (!first || !ts.isObjectLiteralExpression(first)) return
+
+  const obj = first
+  const name = getPropertyValue(obj, 'name') as string | undefined
+  const route = (getPropertyValue(obj, 'route') as string) ?? ''
+
+  if (!name) {
+    console.error('Channel name is required')
+    return
+  }
+
+  // path parameters
+  const params = route
+    ? pathToRegexp(route)
+        .keys.filter((k) => k.type === 'param')
+        .map((k) => k.name)
+    : []
+
+  const docs = getPropertyValue(obj, 'docs') as APIDocs | undefined
+  const tags = getPropertyValue(obj, 'tags') as string[] | undefined
+  const query = getPropertyValue(obj, 'query') as string[] | []
+
+  if (!matchesFilters(filters, { tags }, { type: 'channel', name })) return
+
+  const connect = getPropertyAssignmentInitializer(
+    obj,
+    'onConnect',
+    false,
+    checker
+  )
+  const disconnect = getPropertyAssignmentInitializer(
+    obj,
+    'onDisconnect',
+    false,
+    checker
+  )
+
+  // default onMessage handler
+  let message: ChannelMessageMeta | null = null
+  const onMsgProp = getPropertyAssignmentInitializer(
+    obj,
+    'onMessage',
+    false,
+    checker
+  )
+  if (onMsgProp) {
+    const handlerName =
+      onMsgProp && getHandlerNameFromExpression(onMsgProp, checker)
+    const fnMeta = handlerName && state.functions.meta[handlerName]
+    if (!fnMeta) {
+      console.error(
+        `No function metadata for onMessage handler '${handlerName}'`
+      )
+      throw new Error()
+    } else {
+      message = {
+        pikkuFuncName: extractFunctionName(onMsgProp as any, checker)
+          .pikkuFuncName,
+        inputs: fnMeta.inputs ?? null,
+        outputs: fnMeta.outputs ?? null,
+      }
+    }
+  }
+
+  // nested message-routes
+  const messageRoutes = addMessagesRoutes(obj, state, checker)
+
+  // record into state
+  state.channels.files.add(node.getSourceFile().fileName)
+  state.channels.meta[name] = {
+    name,
+    route,
+    input: null,
+    params: params.length ? params : undefined,
+    query: query?.length ? query : undefined,
+    inputTypes: getInputTypes(
+      state.channels.metaInputTypes,
+      'get',
+      message?.inputs?.[0] ?? null,
+      query,
+      params
+    ),
+    connectPikkuFuncName: connect
+      ? extractFunctionName(connect, checker).pikkuFuncName
+      : null,
+    connect: !!connect,
+    disconnectPikkuFuncName: disconnect
+      ? extractFunctionName(disconnect as any, checker).pikkuFuncName
+      : null,
+    disconnect: !!disconnect,
+    message,
+    messageRoutes,
+    docs: docs ?? undefined,
+    tags: tags ?? undefined,
+  }
+}

package/src/add-file-extends-core-type.ts

@@ -0,0 +1,50 @@
+import * as ts from 'typescript'
+import { PathToNameAndType } from './types.js'
+
+// const VRAMEWORK_TYPES = ['CoreConfig', 'CoreService', 'CoreServices', 'CoreSingletonService', 'CoreSessionService']
+
+export const addFileExtendsCoreType = (
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  methods: PathToNameAndType,
+  expectedTypeName: string
+) => {
+  if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) {
+    const fileName = node.getSourceFile().fileName
+    const typeName = node.name?.getText()
+
+    // Check if the class or interface extends the expected type
+    if (node.heritageClauses) {
+      for (const clause of node.heritageClauses) {
+        if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+          for (const type of clause.types) {
+            const extendedTypeName = type.expression.getText()
+            let extendedTypeDeclarationPath: string | null = null
+
+            // Check if the extended type matches the expected type name
+            if (extendedTypeName === expectedTypeName) {
+              // Retrieve the symbol of the extended type
+              const typeSymbol = checker.getSymbolAtLocation(type.expression)
+              const declaration =
+                typeSymbol &&
+                typeSymbol.declarations &&
+                typeSymbol.declarations[0]
+              if (declaration) {
+                const sourceFile = declaration.getSourceFile()
+                extendedTypeDeclarationPath = sourceFile.fileName // Get the path of the file where the extended type was declared
+              }
+
+              const variables = methods[fileName] || []
+              variables.push({
+                variable: undefined,
+                type: typeName,
+                typePath: extendedTypeDeclarationPath,
+              })
+              methods[fileName] = variables
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/src/add-file-with-config.ts

@@ -0,0 +1,45 @@
+import * as ts from 'typescript'
+import { doesTypeExtendsCore } from './does-type-extend-core-type.js'
+import { PathToNameAndType } from './types.js'
+
+export const addFileWithConfig = (
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  configs: PathToNameAndType
+) => {
+  if (ts.isVariableDeclaration(node)) {
+    const fileName = node.getSourceFile().fileName
+    const variableSymbol = checker.getSymbolAtLocation(node.name)
+
+    if (variableSymbol) {
+      const variableType = checker.getTypeOfSymbolAtLocation(
+        variableSymbol,
+        node.name
+      )
+      const variableName = node.name.getText()
+      const variableTypeText = node.type?.getText()
+
+      // Check if the type extends CoreConfig
+      if (doesTypeExtendsCore(variableType, checker, new Set(), 'CoreConfig')) {
+        // Retrieve the symbol of the type (if it has one)
+        const typeSymbol = variableType.symbol
+        let typeDeclarationPath: string | null = null
+        const declaration =
+          typeSymbol && typeSymbol.declarations && typeSymbol.declarations[0]
+
+        if (declaration) {
+          const sourceFile = declaration.getSourceFile()
+          typeDeclarationPath = sourceFile.fileName // Get the path of the file where the type was declared
+        }
+
+        const variables = configs[fileName] || []
+        variables.push({
+          variable: variableName,
+          type: variableTypeText || null,
+          typePath: typeDeclarationPath,
+        })
+        configs[fileName] = variables
+      }
+    }
+  }
+}

package/src/add-file-with-factory.ts

@@ -0,0 +1,65 @@
+import * as ts from 'typescript'
+import { PathToNameAndType } from './types.js'
+
+export const addFileWithFactory = (
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  methods: PathToNameAndType = new Map(),
+  expectedTypeName: string
+) => {
+  if (ts.isVariableDeclaration(node)) {
+    const fileName = node.getSourceFile().fileName
+    const variableTypeNode = node.type
+    const variableName = node.name.getText()
+
+    if (variableTypeNode && ts.isTypeReferenceNode(variableTypeNode)) {
+      const typeNameNode = variableTypeNode.typeName || null
+
+      let typeDeclarationPath: string | null = null
+
+      // Check if the type name matches the expected type name
+      if (
+        ts.isIdentifier(typeNameNode) &&
+        typeNameNode.text === expectedTypeName
+      ) {
+        const typeSymbol = checker.getSymbolAtLocation(typeNameNode)
+        const declaration =
+          typeSymbol && typeSymbol.declarations && typeSymbol.declarations[0]
+        if (declaration) {
+          const sourceFile = declaration.getSourceFile()
+          typeDeclarationPath = sourceFile.fileName // Get the path of the file where the type was declared
+        }
+
+        const variables = methods[fileName] || []
+        variables.push({
+          variable: variableName,
+          type: typeNameNode.getText(),
+          typePath: typeDeclarationPath,
+        })
+        methods[fileName] = variables
+      }
+
+      // Handle qualified type names if necessary
+      else if (ts.isQualifiedName(typeNameNode)) {
+        const lastName = typeNameNode.right.text
+        if (lastName === expectedTypeName) {
+          const typeSymbol = checker.getSymbolAtLocation(typeNameNode.right)
+          const declaration =
+            typeSymbol && typeSymbol.declarations && typeSymbol.declarations[0]
+          if (declaration) {
+            const sourceFile = declaration.getSourceFile()
+            typeDeclarationPath = sourceFile.fileName // Get the path of the file where the type was declared
+          }
+
+          const variables = methods[fileName] || []
+          variables.push({
+            variable: variableName,
+            type: typeNameNode.getText(),
+            typePath: typeDeclarationPath,
+          })
+          methods[fileName] = variables
+        }
+      }
+    }
+  }
+}