@pikku/inspector 0.9.5 → 0.10.0

package/src/{add-channel.ts → add/add-channel.ts}

@@ -1,21 +1,20 @@
 import * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
-import { pathToRegexp } from 'path-to-regexp'
-import { PikkuDocs, PikkuWiringTypes } from '@pikku/core'
+import { ErrorCode } from '../error-codes.js'
 import {
-  extractFunctionName,
-  getPropertyAssignmentInitializer,
-  matchesFilters,
-} from './utils.js'
+  getPropertyValue,
+  getPropertyTags,
+} from '../utils/get-property-value.js'
+import { pathToRegexp } from 'path-to-regexp'
+import { PikkuDocs } from '@pikku/core'
+import { extractFunctionName } from '../utils/extract-function-name.js'
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import type { ChannelMessageMeta, ChannelMeta } from '@pikku/core/channel'
-import type {
-  InspectorFilters,
-  InspectorState,
-  InspectorLogger,
-} from './types.js'
+import type { InspectorState, AddWiring } from '../types.js'
+import { resolveMiddleware } from '../utils/middleware.js'
+import { extractWireNames } from '../utils/post-process.js'
 
 /**
- * Safely get the “initializer” expression of a property-like AST node:
+ * 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
@@ -38,7 +37,8 @@ function getInitializerOf(
  */
 function getHandlerNameFromExpression(
   expr: ts.Expression,
-  checker: ts.TypeChecker
+  checker: ts.TypeChecker,
+  rootDir: string
 ): string | null {
   // Handle direct identifier case (which includes shorthand properties)
   if (ts.isIdentifier(expr)) {
@@ -64,27 +64,28 @@ function getHandlerNameFromExpression(
             // Extract function name from the declaration's initializer
             const { pikkuFuncName } = extractFunctionName(
               decl.initializer,
-              checker
+              checker,
+              rootDir
             )
             return pikkuFuncName
           }
         }
         // For function declarations, use directly
         else if (ts.isFunctionDeclaration(decl)) {
-          const { pikkuFuncName } = extractFunctionName(decl, checker)
+          const { pikkuFuncName } = extractFunctionName(decl, checker, rootDir)
           return pikkuFuncName
         }
       }
     }
 
     // Fallback: try to extract directly from the identifier
-    const { pikkuFuncName } = extractFunctionName(expr, checker)
+    const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir)
     return pikkuFuncName
   }
 
   // Handle call expressions
   if (ts.isCallExpression(expr)) {
-    const { pikkuFuncName } = extractFunctionName(expr, checker)
+    const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir)
     return pikkuFuncName
   }
 
@@ -92,7 +93,7 @@ function getHandlerNameFromExpression(
   if (ts.isObjectLiteralExpression(expr)) {
     const fnProp = getPropertyAssignmentInitializer(expr, 'func', true, checker)
     if (fnProp) {
-      return getHandlerNameFromExpression(fnProp, checker)
+      return getHandlerNameFromExpression(fnProp, checker, rootDir)
     }
   }
 
@@ -104,6 +105,10 @@ function getHandlerNameFromExpression(
  * in state.functions.meta instead of re-inferring it here.
  */
 export function addMessagesRoutes(
+  logger: {
+    error: (msg: string) => void
+    critical: (code: ErrorCode, msg: string) => void
+  },
   obj: ts.ObjectLiteralExpression,
   state: InspectorState,
   checker: ts.TypeChecker
@@ -183,7 +188,8 @@ export function addMessagesRoutes(
                   ) {
                     const { pikkuFuncName } = extractFunctionName(
                       importDecl.initializer,
-                      checker
+                      checker,
+                      state.rootDir
                     )
                     const handlerName = pikkuFuncName
 
@@ -200,7 +206,8 @@ export function addMessagesRoutes(
                   // Extract from the function declaration
                   const { pikkuFuncName } = extractFunctionName(
                     importDecl,
-                    checker
+                    checker,
+                    state.rootDir
                   )
                   const handlerName = pikkuFuncName
 
@@ -235,7 +242,8 @@ export function addMessagesRoutes(
                       ) {
                         const { pikkuFuncName } = extractFunctionName(
                           exportDecl.initializer,
-                          checker
+                          checker,
+                          state.rootDir
                         )
                         const handlerName = pikkuFuncName
 
@@ -249,7 +257,8 @@ export function addMessagesRoutes(
                       } else if (ts.isFunctionDeclaration(exportDecl)) {
                         const { pikkuFuncName } = extractFunctionName(
                           exportDecl,
-                          checker
+                          checker,
+                          state.rootDir
                         )
                         const handlerName = pikkuFuncName
 
@@ -282,7 +291,8 @@ export function addMessagesRoutes(
             if (possibleMatch) {
               const fnMeta = state.functions.meta[possibleMatch]
               if (!fnMeta) {
-                console.error(
+                logger.critical(
+                  ErrorCode.FUNCTION_METADATA_NOT_FOUND,
                   `No function metadata found for handler '${possibleMatch}'`
                 )
                 continue
@@ -317,7 +327,8 @@ export function addMessagesRoutes(
               // Extract the function name directly from the actual function
               const { pikkuFuncName } = extractFunctionName(
                 actualFunction,
-                checker
+                checker,
+                state.rootDir
               )
               const handlerName = pikkuFuncName
 
@@ -336,9 +347,13 @@ export function addMessagesRoutes(
       }
 
       // Normal processing for non-shorthand properties
-      const handlerName = getHandlerNameFromExpression(init, checker)
+      const handlerName = getHandlerNameFromExpression(
+        init,
+        checker,
+        state.rootDir
+      )
       if (!handlerName) {
-        console.error(
+        logger.error(
           `Could not resolve handler for message route '${routeKey}'`
         )
         continue
@@ -346,7 +361,10 @@ export function addMessagesRoutes(
 
       const fnMeta = state.functions.meta[handlerName]
       if (!fnMeta) {
-        console.error(`No function metadata found for handler '${handlerName}'`)
+        logger.critical(
+          ErrorCode.FUNCTION_METADATA_NOT_FOUND,
+          `No function metadata found for handler '${handlerName}'`
+        )
         continue
       }
 
@@ -363,13 +381,13 @@ export function addMessagesRoutes(
  * 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,
-  logger: InspectorLogger
-) {
+export const addChannel: AddWiring = (
+  logger,
+  node,
+  checker,
+  state,
+  options
+) => {
   if (!ts.isCallExpression(node)) return
   const { expression, arguments: args } = node
   if (!ts.isIdentifier(expression) || expression.text !== 'wireChannel') return
@@ -381,7 +399,7 @@ export function addChannel(
   const route = (getPropertyValue(obj, 'route') as string) ?? ''
 
   if (!name) {
-    console.error('Channel name is required')
+    logger.critical(ErrorCode.MISSING_CHANNEL_NAME, 'Channel name is required')
     return
   }
 
@@ -393,21 +411,9 @@ export function addChannel(
     : []
 
   const docs = getPropertyValue(obj, 'docs') as PikkuDocs | undefined
-  const tags = getPropertyValue(obj, 'tags') as string[] | undefined
+  const tags = getPropertyTags(obj, 'Channel', route, logger)
   const query = getPropertyValue(obj, 'query') as string[] | []
 
-  const filePath = node.getSourceFile().fileName
-
-  if (
-    !matchesFilters(
-      filters,
-      { tags },
-      { type: PikkuWiringTypes.channel, name, filePath },
-      logger
-    )
-  )
-    return
-
   const connect = getPropertyAssignmentInitializer(
     obj,
     'onConnect',
@@ -432,7 +438,8 @@ export function addChannel(
 
   if (onMsgProp) {
     const handlerName =
-      onMsgProp && getHandlerNameFromExpression(onMsgProp, checker)
+      onMsgProp &&
+      getHandlerNameFromExpression(onMsgProp, checker, state.rootDir)
     const fnMeta = handlerName && state.functions.meta[handlerName]
     if (!fnMeta) {
       console.error(
@@ -441,14 +448,52 @@ export function addChannel(
       throw new Error()
     } else {
       message = {
-        pikkuFuncName: extractFunctionName(onMsgProp as any, checker)
-          .pikkuFuncName,
+        pikkuFuncName: extractFunctionName(
+          onMsgProp as any,
+          checker,
+          state.rootDir
+        ).pikkuFuncName,
       }
     }
   }
 
   // nested message-routes
-  const messageWirings = addMessagesRoutes(obj, state, checker)
+  const messageWirings = addMessagesRoutes(logger, obj, state, checker)
+
+  // --- resolve middleware ---
+  const middleware = resolveMiddleware(state, obj, tags, checker)
+
+  // --- track used functions/middleware for service aggregation ---
+  // Track connect/disconnect/message handlers
+  if (connect) {
+    const connectFuncName = extractFunctionName(
+      connect,
+      checker,
+      state.rootDir
+    ).pikkuFuncName
+    state.serviceAggregation.usedFunctions.add(connectFuncName)
+  }
+  if (disconnect) {
+    const disconnectFuncName = extractFunctionName(
+      disconnect as any,
+      checker,
+      state.rootDir
+    ).pikkuFuncName
+    state.serviceAggregation.usedFunctions.add(disconnectFuncName)
+  }
+  if (message) {
+    state.serviceAggregation.usedFunctions.add(message.pikkuFuncName)
+  }
+  // Track message wiring handlers
+  for (const channelHandlers of Object.values(messageWirings)) {
+    for (const handler of Object.values(channelHandlers)) {
+      state.serviceAggregation.usedFunctions.add(handler.pikkuFuncName)
+    }
+  }
+  // Track middleware
+  extractWireNames(middleware).forEach((name) =>
+    state.serviceAggregation.usedMiddleware.add(name)
+  )
 
   // record into state
   state.channels.files.add(node.getSourceFile().fileName)
@@ -466,17 +511,24 @@ export function addChannel(
     //   params
     // ),
     connect: connect
-      ? { pikkuFuncName: extractFunctionName(connect, checker).pikkuFuncName }
+      ? {
+          pikkuFuncName: extractFunctionName(connect, checker, state.rootDir)
+            .pikkuFuncName,
+        }
       : null,
     disconnect: disconnect
       ? {
-          pikkuFuncName: extractFunctionName(disconnect as any, checker)
-            .pikkuFuncName,
+          pikkuFuncName: extractFunctionName(
+            disconnect as any,
+            checker,
+            state.rootDir
+          ).pikkuFuncName,
         }
       : null,
     message,
     messageWirings,
     docs: docs ?? undefined,
     tags: tags ?? undefined,
+    middleware,
   }
 }