@pikku/inspector 0.6.4 → 0.7.1

package/dist/visit.d.ts

@@ -1,3 +1,4 @@
 import * as ts from 'typescript';
 import { InspectorFilters, InspectorState } from './types.js';
-export declare const visit: (checker: ts.TypeChecker, node: ts.Node, state: InspectorState, filters: InspectorFilters) => void;
+export declare const visitSetup: (checker: ts.TypeChecker, node: ts.Node, state: InspectorState, filters: InspectorFilters) => void;
+export declare const visitRoutes: (checker: ts.TypeChecker, node: ts.Node, state: InspectorState, filters: InspectorFilters) => void;

package/dist/visit.js

@@ -1,18 +1,23 @@
 import * as ts from 'typescript';
 import { addFileWithFactory } from './add-file-with-factory.js';
 import { addFileExtendsCoreType } from './add-file-extends-core-type.js';
-import { addRoute } from './add-http-route.js';
+import { addHTTPRoute } from './add-http-route.js';
 import { addSchedule } from './add-schedule.js';
+import { addFunctions } from './add-functions.js';
 import { addChannel } from './add-channel.js';
-export const visit = (checker, node, state, filters) => {
+export const visitSetup = (checker, node, state, filters) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices');
     addFileExtendsCoreType(node, checker, state.sessionServicesTypeImportMap, 'CoreServices');
     addFileExtendsCoreType(node, checker, state.userSessionTypeImportMap, 'CoreUserSession');
     addFileWithFactory(node, checker, state.singletonServicesFactories, 'CreateSingletonServices');
     addFileWithFactory(node, checker, state.sessionServicesFactories, 'CreateSessionServices');
     addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
-    addRoute(node, checker, state, filters);
+    addFunctions(node, checker, state, filters);
+    ts.forEachChild(node, (child) => visitSetup(checker, child, state, filters));
+};
+export const visitRoutes = (checker, node, state, filters) => {
+    addHTTPRoute(node, checker, state, filters);
     addSchedule(node, checker, state, filters);
     addChannel(node, checker, state, filters);
-    ts.forEachChild(node, (child) => visit(checker, child, state, filters));
+    ts.forEachChild(node, (child) => visitRoutes(checker, child, state, filters));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.6.4",
+  "version": "0.7.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "type": "module",
@@ -17,7 +17,7 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "dependencies": {
-    "@pikku/core": "^0.6.22",
+    "@pikku/core": "^0.7.0",
     "path-to-regexp": "^8.2.0",
     "typescript": "^5.6"
   },

package/src/add-channel.ts

@@ -4,177 +4,479 @@ import { pathToRegexp } from 'path-to-regexp'
 import { APIDocs } from '@pikku/core'
 import { getInputTypes } from './add-http-route.js'
 import {
-  getPropertyAssignment,
-  getFunctionTypes,
+  extractFunctionName,
+  getPropertyAssignmentInitializer,
   matchesFilters,
 } from './utils.js'
-import { ChannelMeta } from '@pikku/core/channel'
-import { TypesMap } from './types-map.js'
-import { InspectorFilters, InspectorState } from './types.js'
+import type { ChannelMessageMeta, ChannelMeta } from '@pikku/core/channel'
+import type { InspectorFilters, InspectorState } from './types.js'
 
-const addMessagesRoutes = (
-  obj: ts.ObjectLiteralExpression,
-  checker: ts.TypeChecker,
-  typesMap: TypesMap
-) => {
-  const messageTypes: ChannelMeta['messageRoutes'] = {}
-
-  // Find the onMessageRoute property
-  const messagesProperty = obj.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === 'onMessageRoute'
-  )
+/**
+ * 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]!
 
-  if (!messagesProperty || !ts.isPropertyAssignment(messagesProperty)) {
-    console.log(
-      'onMessageRoute property not found or is not a valid assignment.'
-    )
-    return {}
+        // 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
   }
 
-  const initializer = messagesProperty.initializer
-  // Ensure initializer is an object literal expression
-  if (!ts.isObjectLiteralExpression(initializer)) {
-    console.log('onMessageRoute is not an object literal.')
-    return {}
+  // Handle object literals with 'func' property
+  if (ts.isObjectLiteralExpression(expr)) {
+    const fnProp = getPropertyAssignmentInitializer(expr, 'func', true, checker)
+    if (fnProp) {
+      return getHandlerNameFromExpression(fnProp, checker)
+    }
   }
 
-  // Iterate over the first level properties (like 'event')
-  initializer.properties.forEach((property) => {
-    const channel = property.name!.getText()
-    messageTypes[channel] = {}
-
-    if (ts.isPropertyAssignment(property)) {
-      const nestedObject = property.initializer
-      if (ts.isObjectLiteralExpression(nestedObject)) {
-        const keys = nestedObject.properties.map((p) => p.name?.getText())
-        for (const route of keys) {
-          if (route) {
-            const result = getFunctionTypes(checker, nestedObject, {
-              funcName: route,
-              inputIndex: 0,
-              outputIndex: 1,
-              typesMap,
-            })
-            const inputs = result?.inputs || null
-            const outputs = result?.outputs || null
-            const type = result?.type || null
-            messageTypes[channel][route] = { inputs, outputs, type }
+  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
+              }
+            }
           }
         }
-      } else {
-        console.warn('Nested property is not an object literal:', nestedObject)
       }
-    } else {
-      console.warn(
-        `Property "${property.getText()}" is a ${ts.SyntaxKind[property.kind]}`
-      )
+
+      // 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 messageTypes
+  return result
 }
 
-export const addChannel = (
+/**
+ * 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
-  }
+) {
+  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 args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
+  const obj = first
+  const name = getPropertyValue(obj, 'name') as string | undefined
+  const route = (getPropertyValue(obj, 'route') as string) ?? ''
 
-  // Check if the call is to addRoute
-  if (!ts.isIdentifier(expression) || expression.text !== 'addChannel') {
+  if (!name) {
+    console.error('Channel name is required')
     return
   }
 
-  if (!firstArg) {
-    return
-  }
+  // path parameters
+  const params = route
+    ? pathToRegexp(route)
+        .keys.filter((k) => k.type === 'param')
+        .map((k) => k.name)
+    : []
 
-  let docs: APIDocs | undefined
-  let paramsValues: string[] | null = []
-  let queryValues: string[] | [] = []
-  let tags: string[] | undefined = undefined
-  let inputType: string | null = null
-  let route: string | null = null
-  let name: string | null = null
+  const docs = getPropertyValue(obj, 'docs') as APIDocs | undefined
+  const tags = getPropertyValue(obj, 'tags') as string[] | undefined
+  const query = getPropertyValue(obj, 'query') as string[] | []
 
-  // Check if the first argument is an object literal
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
+  if (!matchesFilters(filters, { tags }, { type: 'channel', name })) return
 
-    name = getPropertyValue(obj, 'name') as string | null
-    route = getPropertyValue(obj, 'route') as string | null
-
-    if (!name) {
-      console.error('Channel name is required')
-      return
-    }
+  const connect = getPropertyAssignmentInitializer(
+    obj,
+    'onConnect',
+    false,
+    checker
+  )
+  const disconnect = getPropertyAssignmentInitializer(
+    obj,
+    'onDisconnect',
+    false,
+    checker
+  )
 
-    if (route) {
-      const { keys } = pathToRegexp(route)
-      paramsValues = keys.reduce((result, { type, name }) => {
-        if (type === 'param') {
-          result.push(name)
-        }
-        return result
-      }, [] as string[])
+  // 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 {
-      route = ''
+      message = {
+        pikkuFuncName: extractFunctionName(onMsgProp as any, checker)
+          .pikkuFuncName,
+        inputs: fnMeta.inputs ?? null,
+        outputs: fnMeta.outputs ?? null,
+      }
     }
+  }
 
-    docs = (getPropertyValue(obj, 'docs') as APIDocs) || undefined
-    queryValues = (getPropertyValue(obj, 'query') as string[]) || []
-    tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
-
-    const connect = !!getPropertyAssignment(obj, 'onConnect')
-    const disconnect = !!getPropertyAssignment(obj, 'onDisconnect')
-    const { inputs, outputs, type } = getFunctionTypes(checker, obj, {
-      funcName: 'onMessage',
-      inputIndex: 0,
-      outputIndex: 1,
-      typesMap: state.channels.typesMap,
-    })
-    const message = { inputs, outputs, type }
-    const messageRoutes = addMessagesRoutes(
-      obj,
-      checker,
-      state.channels.typesMap
-    )
-
-    if (!matchesFilters(filters, { tags }, { type: 'channel', name })) {
-      return
-    }
+  // nested message-routes
+  const messageRoutes = addMessagesRoutes(obj, state, checker)
 
-    state.channels.files.add(node.getSourceFile().fileName)
-    state.channels.meta.push({
-      name,
-      route,
-      input: inputType,
-      params: paramsValues.length > 0 ? paramsValues : undefined,
-      query: queryValues.length > 0 ? queryValues : undefined,
-      inputTypes: getInputTypes(
-        state.channels.metaInputTypes,
-        'get',
-        inputType,
-        queryValues,
-        paramsValues
-      ),
-      connect,
-      disconnect,
-      message: message || undefined,
-      messageRoutes,
-      docs,
-      tags,
-    })
+  // 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,
   }
 }