@pikku/inspector 0.9.5 → 0.9.6-next.0

package/src/add/add-middleware.ts

@@ -0,0 +1,326 @@
+import * as ts from 'typescript'
+import { AddWiring } from '../types.js'
+import {
+  extractFunctionName,
+  isNamedExport,
+} from '../utils/extract-function-name.js'
+import { extractServicesFromFunction } from '../utils/extract-services.js'
+import { extractMiddlewarePikkuNames } from '../utils/middleware.js'
+
+/**
+ * Inspect pikkuMiddleware calls, addMiddleware calls, and addHTTPMiddleware calls
+ */
+export const addMiddleware: AddWiring = (logger, node, checker, state) => {
+  if (!ts.isCallExpression(node)) return
+
+  const { expression, arguments: args } = node
+
+  // only handle specific function calls
+  if (!ts.isIdentifier(expression)) {
+    return
+  }
+
+  // Handle pikkuMiddleware(...) - individual middleware function definition
+  if (expression.text === 'pikkuMiddleware') {
+    const handlerNode = args[0]
+    if (!handlerNode) return
+
+    if (
+      !ts.isArrowFunction(handlerNode) &&
+      !ts.isFunctionExpression(handlerNode)
+    ) {
+      logger.error(`• Handler for pikkuMiddleware is not a function.`)
+      return
+    }
+
+    const services = extractServicesFromFunction(handlerNode)
+    const { pikkuFuncName, exportedName } = extractFunctionName(node, checker)
+    state.middleware.meta[pikkuFuncName] = {
+      services,
+      sourceFile: node.getSourceFile().fileName,
+      position: node.getStart(),
+      exportedName,
+    }
+
+    logger.debug(
+      `• Found middleware with services: ${services.services.join(', ')}`
+    )
+    return
+  }
+
+  // Handle pikkuMiddlewareFactory(...) - middleware factory function
+  if (expression.text === 'pikkuMiddlewareFactory') {
+    const factoryNode = args[0]
+    if (!factoryNode) return
+
+    if (
+      !ts.isArrowFunction(factoryNode) &&
+      !ts.isFunctionExpression(factoryNode)
+    ) {
+      logger.error(`• Handler for pikkuMiddlewareFactory is not a function.`)
+      return
+    }
+
+    // Extract services by looking inside the factory function body
+    // The factory should return pikkuMiddleware(...), so we need to find that call
+    let services = { optimized: false, services: [] as string[] }
+
+    const findPikkuMiddlewareCall = (
+      node: ts.Node
+    ): ts.CallExpression | undefined => {
+      if (ts.isCallExpression(node)) {
+        const expr = node.expression
+        if (ts.isIdentifier(expr) && expr.text === 'pikkuMiddleware') {
+          return node
+        }
+      }
+      return ts.forEachChild(node, findPikkuMiddlewareCall)
+    }
+
+    const pikkuMiddlewareCall = findPikkuMiddlewareCall(factoryNode)
+    if (pikkuMiddlewareCall && pikkuMiddlewareCall.arguments[0]) {
+      const middlewareHandler = pikkuMiddlewareCall.arguments[0]
+      if (
+        ts.isArrowFunction(middlewareHandler) ||
+        ts.isFunctionExpression(middlewareHandler)
+      ) {
+        services = extractServicesFromFunction(middlewareHandler)
+      }
+    }
+
+    const { pikkuFuncName, exportedName } = extractFunctionName(node, checker)
+    state.middleware.meta[pikkuFuncName] = {
+      services,
+      sourceFile: node.getSourceFile().fileName,
+      position: node.getStart(),
+      exportedName,
+      factory: true,
+    }
+
+    logger.debug(
+      `• Found middleware factory with services: ${services.services.join(', ')}`
+    )
+    return
+  }
+
+  // Handle addMiddleware('tag', [middleware1, middleware2])
+  // Supports two patterns:
+  // 1. export const x = () => addMiddleware('tag', [...])  (factory - tree-shakeable)
+  // 2. export const x = addMiddleware('tag', [...])  (direct - no tree-shaking)
+  if (expression.text === 'addMiddleware') {
+    const tagArg = args[0]
+    const middlewareArrayArg = args[1]
+
+    if (!tagArg || !middlewareArrayArg) return
+
+    // Extract tag name
+    let tag: string | undefined
+    if (ts.isStringLiteral(tagArg)) {
+      tag = tagArg.text
+    }
+
+    if (!tag) {
+      logger.warn(`• addMiddleware call without valid tag string`)
+      return
+    }
+
+    // Check if middleware array is a literal array
+    if (!ts.isArrayLiteralExpression(middlewareArrayArg)) {
+      logger.error(
+        `• addMiddleware('${tag}', ...) must have a literal array as second argument`
+      )
+      return
+    }
+
+    // Extract middleware pikkuFuncNames from array
+    const middlewareNames = extractMiddlewarePikkuNames(
+      middlewareArrayArg,
+      checker
+    )
+
+    if (middlewareNames.length === 0) {
+      logger.warn(`• addMiddleware('${tag}', ...) has empty middleware array`)
+      return
+    }
+
+    // Collect services from all middleware in the group
+    const allServices = new Set<string>()
+    for (const middlewareName of middlewareNames) {
+      const middlewareMeta = state.middleware.meta[middlewareName]
+      if (middlewareMeta && middlewareMeta.services) {
+        for (const service of middlewareMeta.services.services) {
+          allServices.add(service)
+        }
+      }
+    }
+
+    // Check if this call is wrapped in a factory function
+    // We need to walk up the tree to see if the parent is: const x = () => addMiddleware(...)
+    let isFactory = false
+    let exportedName: string | null = null
+    let parent = node.parent
+
+    // Check if parent is arrow function: () => addMiddleware(...)
+    if (parent && ts.isArrowFunction(parent)) {
+      // Check if arrow function has no parameters
+      if (parent.parameters.length === 0) {
+        isFactory = true
+
+        // For factories, we need to check the arrow function's parent for the export name
+        // const apiTagMiddleware = () => addMiddleware(...)
+        const arrowParent = parent.parent
+        if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
+          if (ts.isIdentifier(arrowParent.name)) {
+            // Check if it's exported
+            if (isNamedExport(arrowParent)) {
+              exportedName = arrowParent.name.text
+            }
+          }
+        }
+      }
+    }
+
+    // If not a factory, get export name from the call expression itself
+    if (!isFactory) {
+      const extracted = extractFunctionName(node, checker)
+      exportedName = extracted.exportedName
+    }
+
+    // Log warning if not using factory pattern
+    if (!isFactory && exportedName) {
+      logger.warn(
+        `• Middleware group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
+          `For tree-shaking, use: export const ${exportedName} = () => addMiddleware('${tag}', [...])`
+      )
+    }
+
+    // Store group metadata
+    state.middleware.tagMiddleware.set(tag, {
+      exportName: exportedName,
+      sourceFile: node.getSourceFile().fileName,
+      position: node.getStart(),
+      services: {
+        optimized: false,
+        services: Array.from(allServices),
+      },
+      middlewareCount: middlewareNames.length,
+      isFactory,
+    })
+
+    logger.debug(
+      `• Found tag middleware group: ${tag} -> [${middlewareNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`
+    )
+    return
+  }
+
+  // Handle addHTTPMiddleware(pattern, [middleware1, middleware2])
+  // Supports two patterns:
+  // 1. export const x = () => addHTTPMiddleware('*', [...])  (factory - tree-shakeable)
+  // 2. export const x = addHTTPMiddleware('*', [...])  (direct - no tree-shaking)
+  if (expression.text === 'addHTTPMiddleware') {
+    const patternArg = args[0]
+    const middlewareArrayArg = args[1]
+
+    if (!patternArg || !middlewareArrayArg) return
+
+    // Extract route pattern
+    let pattern: string | undefined
+    if (ts.isStringLiteral(patternArg)) {
+      pattern = patternArg.text
+    }
+
+    if (!pattern) {
+      logger.warn(`• addHTTPMiddleware call without valid pattern string`)
+      return
+    }
+
+    // Check if middleware array is a literal array
+    if (!ts.isArrayLiteralExpression(middlewareArrayArg)) {
+      logger.error(
+        `• addHTTPMiddleware('${pattern}', ...) must have a literal array as second argument`
+      )
+      return
+    }
+
+    // Extract middleware pikkuFuncNames from array
+    const middlewareNames = extractMiddlewarePikkuNames(
+      middlewareArrayArg,
+      checker
+    )
+
+    if (middlewareNames.length === 0) {
+      logger.warn(
+        `• addHTTPMiddleware('${pattern}', ...) has empty middleware array`
+      )
+      return
+    }
+
+    // Collect services from all middleware in the group
+    const allServices = new Set<string>()
+    for (const middlewareName of middlewareNames) {
+      const middlewareMeta = state.middleware.meta[middlewareName]
+      if (middlewareMeta && middlewareMeta.services) {
+        for (const service of middlewareMeta.services.services) {
+          allServices.add(service)
+        }
+      }
+    }
+
+    // Check if this call is wrapped in a factory function
+    let isFactory = false
+    let exportedName: string | null = null
+    let parent = node.parent
+
+    // Check if parent is arrow function: () => addHTTPMiddleware(...)
+    if (parent && ts.isArrowFunction(parent)) {
+      // Check if arrow function has no parameters
+      if (parent.parameters.length === 0) {
+        isFactory = true
+
+        // For factories, we need to check the arrow function's parent for the export name
+        // const apiRouteMiddleware = () => addHTTPMiddleware(...)
+        const arrowParent = parent.parent
+        if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
+          if (ts.isIdentifier(arrowParent.name)) {
+            // Check if it's exported
+            if (isNamedExport(arrowParent)) {
+              exportedName = arrowParent.name.text
+            }
+          }
+        }
+      }
+    }
+
+    // If not a factory, get export name from the call expression itself
+    if (!isFactory) {
+      const extracted = extractFunctionName(node, checker)
+      exportedName = extracted.exportedName
+    }
+
+    // Log warning if not using factory pattern
+    if (!isFactory && exportedName) {
+      logger.warn(
+        `• HTTP middleware group '${exportedName}' for pattern '${pattern}' is not wrapped in a factory function. ` +
+          `For tree-shaking, use: export const ${exportedName} = () => addHTTPMiddleware('${pattern}', [...])`
+      )
+    }
+
+    // Store group metadata
+    state.http.routeMiddleware.set(pattern, {
+      exportName: exportedName,
+      sourceFile: node.getSourceFile().fileName,
+      position: node.getStart(),
+      services: {
+        optimized: false,
+        services: Array.from(allServices),
+      },
+      middlewareCount: middlewareNames.length,
+      isFactory,
+    })
+
+    logger.debug(
+      `• Found HTTP route middleware group: ${pattern} -> [${middlewareNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`
+    )
+    return
+  }
+}

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

@@ -1,17 +1,13 @@
 import * as ts from 'typescript'
-import { InspectorLogger, InspectorState } from './types.js'
-import { extractFunctionName, extractServicesFromFunction } from './utils.js'
+import { AddWiring } from '../types.js'
+import { extractFunctionName } from '../utils/extract-function-name.js'
+import { extractServicesFromFunction } from '../utils/extract-services.js'
 
 /**
  * Inspect pikkuPermission calls and extract first-arg destructuring
  * for tree shaking optimization.
  */
-export function addPermission(
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  state: InspectorState,
-  logger: InspectorLogger
-) {
+export const addPermission: AddWiring = (logger, node, checker, state) => {
   if (!ts.isCallExpression(node)) return
 
   const { expression, arguments: args } = node

package/src/{add-queue-worker.ts → add/add-queue-worker.ts}

@@ -1,19 +1,18 @@
 import * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
+import { getPropertyValue } from '../utils/get-property-value.js'
 import { PikkuDocs, PikkuWiringTypes } from '@pikku/core'
-import { InspectorFilters, InspectorState, InspectorLogger } from './types.js'
-import {
-  extractFunctionName,
-  getPropertyAssignmentInitializer,
-  matchesFilters,
-} from './utils.js'
+import { AddWiring } from '../types.js'
+import { extractFunctionName } from '../utils/extract-function-name.js'
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
+import { matchesFilters } from '../utils/filter-utils.js'
+import { resolveMiddleware } from '../utils/middleware.js'
 
-export const addQueueWorker = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  state: InspectorState,
-  filters: InspectorFilters,
-  logger: InspectorLogger
+export const addQueueWorker: AddWiring = (
+  logger,
+  node,
+  checker,
+  state,
+  options
 ) => {
   if (!ts.isCallExpression(node)) {
     return
@@ -69,7 +68,7 @@ export const addQueueWorker = (
 
     if (
       !matchesFilters(
-        filters,
+        options.filters || {},
         { tags },
         { type: PikkuWiringTypes.queue, name: queueName, filePath },
         logger
@@ -81,12 +80,16 @@ export const addQueueWorker = (
       return
     }
 
+    // --- resolve middleware ---
+    const middleware = resolveMiddleware(state, obj, tags, checker)
+
     state.queueWorkers.files.add(node.getSourceFile().fileName)
     state.queueWorkers.meta[queueName] = {
       pikkuFuncName,
       queueName,
       docs,
       tags,
+      middleware,
     }
   }
 }

package/src/{add-rpc-invocations.ts → add/add-rpc-invocations.ts}

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import { InspectorState, InspectorLogger } from './types.js'
+import { InspectorState, InspectorLogger } from '../types.js'
 
 /**
  * Scan for rpc.invoke() calls to track which functions are actually being invoked

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

@@ -1,19 +1,18 @@
 import * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
+import { getPropertyValue } from '../utils/get-property-value.js'
 import { PikkuDocs, PikkuWiringTypes } from '@pikku/core'
-import { InspectorFilters, InspectorState, InspectorLogger } from './types.js'
-import {
-  extractFunctionName,
-  getPropertyAssignmentInitializer,
-  matchesFilters,
-} from './utils.js'
+import { AddWiring } from '../types.js'
+import { extractFunctionName } from '../utils/extract-function-name.js'
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
+import { matchesFilters } from '../utils/filter-utils.js'
+import { resolveMiddleware } from '../utils/middleware.js'
 
-export const addSchedule = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  state: InspectorState,
-  filters: InspectorFilters,
-  logger: InspectorLogger
+export const addSchedule: AddWiring = (
+  logger,
+  node,
+  checker,
+  state,
+  options
 ) => {
   if (!ts.isCallExpression(node)) {
     return
@@ -66,7 +65,7 @@ export const addSchedule = (
 
     if (
       !matchesFilters(
-        filters,
+        options.filters || {},
         { tags },
         { type: PikkuWiringTypes.scheduler, name: nameValue, filePath },
         logger
@@ -75,6 +74,9 @@ export const addSchedule = (
       return
     }
 
+    // --- resolve middleware ---
+    const middleware = resolveMiddleware(state, obj, tags, checker)
+
     state.scheduledTasks.files.add(node.getSourceFile().fileName)
     state.scheduledTasks.meta[nameValue] = {
       pikkuFuncName,
@@ -82,6 +84,7 @@ export const addSchedule = (
       schedule: scheduleValue,
       docs,
       tags,
+      middleware,
     }
   }
 }

package/src/index.ts

@@ -1,4 +1,9 @@
 export { inspect } from './inspector.js'
+export { getFilesAndMethods } from './utils/get-files-and-methods.js'
 export type { TypesMap } from './types-map.js'
 export type * from './types.js'
 export type { InspectorState } from './types.js'
+export type {
+  FilesAndMethods,
+  FilesAndMethodsErrors,
+} from './utils/get-files-and-methods.js'

package/src/inspector.ts

@@ -1,23 +1,13 @@
 import * as ts from 'typescript'
 import { visitSetup, visitRoutes } from './visit.js'
 import { TypesMap } from './types-map.js'
-import {
-  InspectorState,
-  InspectorHTTPState,
-  InspectorFilters,
-  InspectorLogger,
-} from './types.js'
-
-export const normalizeHTTPTypes = (
-  httpState: InspectorHTTPState
-): InspectorHTTPState => {
-  return httpState
-}
+import { InspectorState, InspectorLogger, InspectorOptions } from './types.js'
+import { getFilesAndMethods } from './utils/get-files-and-methods.js'
 
 export const inspect = (
   logger: InspectorLogger,
   routeFiles: string[],
-  filters: InspectorFilters
+  options: InspectorOptions = {}
 ): InspectorState => {
   const program = ts.createProgram(routeFiles, {
     target: ts.ScriptTarget.ESNext,
@@ -30,12 +20,17 @@ export const inspect = (
     singletonServicesTypeImportMap: new Map(),
     sessionServicesTypeImportMap: new Map(),
     userSessionTypeImportMap: new Map(),
+    configTypeImportMap: new Map(),
     singletonServicesFactories: new Map(),
     sessionServicesFactories: new Map(),
     configFactories: new Map(),
+    filesAndMethods: {},
+    filesAndMethodsErrors: new Map(),
+    typesLookup: new Map(),
     functions: {
       typesMap: new TypesMap(),
       meta: {},
+      files: new Map(),
     },
     http: {
       metaInputTypes: new Map(),
@@ -49,6 +44,7 @@ export const inspect = (
         options: {},
       },
       files: new Set(),
+      routeMiddleware: new Map(),
     },
     channels: {
       files: new Set(),
@@ -75,8 +71,13 @@ export const inspect = (
       promptsMeta: {},
       files: new Set(),
     },
+    cli: {
+      meta: {},
+      files: new Set(),
+    },
     middleware: {
       meta: {},
+      tagMiddleware: new Map(),
     },
     permissions: {
       meta: {},
@@ -86,19 +87,21 @@ export const inspect = (
   // First sweep: add all functions
   for (const sourceFile of sourceFiles) {
     ts.forEachChild(sourceFile, (child) =>
-      visitSetup(checker, child, state, filters, logger)
+      visitSetup(logger, checker, child, state, options)
     )
   }
 
   // Second sweep: add all transports
   for (const sourceFile of sourceFiles) {
     ts.forEachChild(sourceFile, (child) =>
-      visitRoutes(checker, child, state, filters, logger)
+      visitRoutes(logger, checker, child, state, options)
     )
   }
 
-  // Normalise the typesMap
-  state.http = normalizeHTTPTypes(state.http)
+  // Populate filesAndMethods
+  const { result, errors } = getFilesAndMethods(state, options.types)
+  state.filesAndMethods = result
+  state.filesAndMethodsErrors = errors
 
   return state
 }