@pikku/inspector 0.10.0 → 0.10.2

package/src/add/add-channel.ts

@@ -136,7 +136,15 @@ export function addMessagesRoutes(
       const init = getInitializerOf(routeElem)
       if (!init) continue
 
-      const routeKey = routeElem.name!.getText()
+      // Get the route key, stripping quotes if it's a string literal
+      const routeName = routeElem.name
+      if (!routeName) continue
+
+      let routeKey = routeName.getText()
+      // For string literals like 'greet' or "greet", strip the quotes
+      if (ts.isStringLiteral(routeName)) {
+        routeKey = routeName.text
+      }
 
       // For shorthand properties, we need to resolve the identifier to its declaration
       if (ts.isShorthandPropertyAssignment(routeElem)) {
@@ -196,8 +204,17 @@ export function addMessagesRoutes(
                     // Look up in the registry
                     const fnMeta = state.functions.meta[handlerName]
                     if (fnMeta) {
+                      // Resolve middleware for this route
+                      const routeTags = ts.isObjectLiteralExpression(init)
+                        ? getPropertyTags(init, 'channel', channelKey, logger)
+                        : undefined
+                      const routeMiddleware = ts.isObjectLiteralExpression(init)
+                        ? resolveMiddleware(state, init, routeTags, checker)
+                        : undefined
+
                       result[channelKey]![routeKey] = {
                         pikkuFuncName: handlerName,
+                        middleware: routeMiddleware,
                       }
                       continue
                     }
@@ -214,8 +231,17 @@ export function addMessagesRoutes(
                   // Look up in the registry
                   const fnMeta = state.functions.meta[handlerName]
                   if (fnMeta) {
+                    // Resolve middleware for this route
+                    const routeTags = ts.isObjectLiteralExpression(init)
+                      ? getPropertyTags(init, 'channel', channelKey, logger)
+                      : undefined
+                    const routeMiddleware = ts.isObjectLiteralExpression(init)
+                      ? resolveMiddleware(state, init, routeTags, checker)
+                      : undefined
+
                     result[channelKey]![routeKey] = {
                       pikkuFuncName: handlerName,
+                      middleware: routeMiddleware,
                     }
                     continue
                   }
@@ -249,8 +275,24 @@ export function addMessagesRoutes(
 
                         const fnMeta = state.functions.meta[handlerName]
                         if (fnMeta) {
+                          // Resolve middleware for this route
+                          const routeTags = ts.isObjectLiteralExpression(init)
+                            ? getPropertyTags(
+                                init,
+                                'channel',
+                                channelKey,
+                                logger
+                              )
+                            : undefined
+                          const routeMiddleware = ts.isObjectLiteralExpression(
+                            init
+                          )
+                            ? resolveMiddleware(state, init, routeTags, checker)
+                            : undefined
+
                           result[channelKey]![routeKey] = {
                             pikkuFuncName: handlerName,
+                            middleware: routeMiddleware,
                           }
                           continue
                         }
@@ -264,8 +306,24 @@ export function addMessagesRoutes(
 
                         const fnMeta = state.functions.meta[handlerName]
                         if (fnMeta) {
+                          // Resolve middleware for this route
+                          const routeTags = ts.isObjectLiteralExpression(init)
+                            ? getPropertyTags(
+                                init,
+                                'channel',
+                                channelKey,
+                                logger
+                              )
+                            : undefined
+                          const routeMiddleware = ts.isObjectLiteralExpression(
+                            init
+                          )
+                            ? resolveMiddleware(state, init, routeTags, checker)
+                            : undefined
+
                           result[channelKey]![routeKey] = {
                             pikkuFuncName: handlerName,
+                            middleware: routeMiddleware,
                           }
                           continue
                         }
@@ -336,8 +394,17 @@ export function addMessagesRoutes(
               const fnMeta = state.functions.meta[handlerName]
 
               if (fnMeta) {
+                // Resolve middleware for this route
+                const routeTags = ts.isObjectLiteralExpression(init)
+                  ? getPropertyTags(init, 'channel', channelKey, logger)
+                  : undefined
+                const routeMiddleware = ts.isObjectLiteralExpression(init)
+                  ? resolveMiddleware(state, init, routeTags, checker)
+                  : undefined
+
                 result[channelKey]![routeKey] = {
                   pikkuFuncName: handlerName,
+                  middleware: routeMiddleware,
                 }
                 continue // Skip the normal processing below
               }
@@ -368,8 +435,18 @@ export function addMessagesRoutes(
         continue
       }
 
+      // Resolve middleware and permissions for this route
+      // Check if the route config is an object literal with middleware/permissions
+      const routeTags = ts.isObjectLiteralExpression(init)
+        ? getPropertyTags(init, 'channel', channelKey, logger)
+        : undefined
+      const routeMiddleware = ts.isObjectLiteralExpression(init)
+        ? resolveMiddleware(state, init, routeTags, checker)
+        : undefined
+
       result[channelKey]![routeKey] = {
         pikkuFuncName: handlerName,
+        middleware: routeMiddleware,
       }
     }
   }
@@ -417,13 +494,13 @@ export const addChannel: AddWiring = (
   const connect = getPropertyAssignmentInitializer(
     obj,
     'onConnect',
-    false,
+    true,
     checker
   )
   const disconnect = getPropertyAssignmentInitializer(
     obj,
     'onDisconnect',
-    false,
+    true,
     checker
   )
 
@@ -432,28 +509,26 @@ export const addChannel: AddWiring = (
   const onMsgProp = getPropertyAssignmentInitializer(
     obj,
     'onMessage',
-    false,
+    true,
     checker
   )
 
   if (onMsgProp) {
-    const handlerName =
-      onMsgProp &&
-      getHandlerNameFromExpression(onMsgProp, checker, state.rootDir)
-    const fnMeta = handlerName && state.functions.meta[handlerName]
+    const { pikkuFuncName } = extractFunctionName(
+      onMsgProp,
+      checker,
+      state.rootDir
+    )
+    const fnMeta = state.functions.meta[pikkuFuncName]
     if (!fnMeta) {
-      console.error(
-        `No function metadata for onMessage handler '${handlerName}'`
+      logger.critical(
+        ErrorCode.FUNCTION_METADATA_NOT_FOUND,
+        `No function metadata found for onMessage handler '${pikkuFuncName}'`
       )
-      throw new Error()
-    } else {
-      message = {
-        pikkuFuncName: extractFunctionName(
-          onMsgProp as any,
-          checker,
-          state.rootDir
-        ).pikkuFuncName,
-      }
+      return
+    }
+    message = {
+      pikkuFuncName,
     }
   }
 

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

@@ -2,6 +2,13 @@ import * as ts from 'typescript'
 import { PathToNameAndType, InspectorState } from '../types.js'
 import { extractServicesFromFunction } from '../utils/extract-services.js'
 
+// Mapping of wrapper function names to their corresponding types
+const wrapperFunctionMap: Record<string, string> = {
+  pikkuConfig: 'CreateConfig',
+  pikkuServices: 'CreateSingletonServices',
+  pikkuSessionServices: 'CreateSessionServices',
+}
+
 export const addFileWithFactory = (
   node: ts.Node,
   checker: ts.TypeChecker,
@@ -14,6 +21,68 @@ export const addFileWithFactory = (
     const variableTypeNode = node.type
     const variableName = node.name.getText()
 
+    // Check for wrapper function calls FIRST (e.g., pikkuConfig(...), pikkuServices(...))
+    // This handles both cases: with and without explicit type annotations
+    if (node.initializer && ts.isCallExpression(node.initializer)) {
+      const callExpression = node.initializer
+      const expression = callExpression.expression
+
+      if (ts.isIdentifier(expression)) {
+        const wrapperFunctionName = expression.text
+        const inferredType = wrapperFunctionMap[wrapperFunctionName]
+
+        if (inferredType === expectedTypeName) {
+          // Get the type declaration path from the wrapper function
+          const typeSymbol = checker.getSymbolAtLocation(expression)
+          let typeDeclarationPath: string | null = null
+
+          if (
+            typeSymbol &&
+            typeSymbol.declarations &&
+            typeSymbol.declarations[0]
+          ) {
+            const declaration = typeSymbol.declarations[0]
+            const sourceFile = declaration.getSourceFile()
+            typeDeclarationPath = sourceFile.fileName
+          }
+
+          const variables = methods.get(fileName) || []
+          variables.push({
+            variable: variableName,
+            type: inferredType,
+            typePath: typeDeclarationPath,
+          })
+          methods.set(fileName, variables)
+
+          // Extract singleton services for CreateSessionServices factories
+          if (
+            expectedTypeName === 'CreateSessionServices' &&
+            state &&
+            callExpression.arguments.length > 0
+          ) {
+            const firstArg = callExpression.arguments[0]
+            let functionNode:
+              | ts.ArrowFunction
+              | ts.FunctionExpression
+              | undefined
+
+            if (ts.isArrowFunction(firstArg)) {
+              functionNode = firstArg
+            } else if (ts.isFunctionExpression(firstArg)) {
+              functionNode = firstArg
+            }
+
+            if (functionNode) {
+              const servicesMeta = extractServicesFromFunction(functionNode)
+              state.sessionServicesMeta.set(variableName, servicesMeta.services)
+            }
+          }
+
+          return // Early return since we found a match
+        }
+      }
+    }
+
     if (variableTypeNode && ts.isTypeReferenceNode(variableTypeNode)) {
       const typeNameNode = variableTypeNode.typeName || null
 

package/src/index.ts

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

package/src/inspector.ts

@@ -1,4 +1,5 @@
 import * as ts from 'typescript'
+import { performance } from 'perf_hooks'
 import { visitSetup, visitRoutes } from './visit.js'
 import { TypesMap } from './types-map.js'
 import { InspectorState, InspectorLogger, InspectorOptions } from './types.js'
@@ -6,22 +7,13 @@ import { getFilesAndMethods } from './utils/get-files-and-methods.js'
 import { findCommonAncestor } from './utils/find-root-dir.js'
 import { aggregateRequiredServices } from './utils/post-process.js'
 
-export const inspect = (
-  logger: InspectorLogger,
-  routeFiles: string[],
-  options: InspectorOptions = {}
-): InspectorState => {
-  const program = ts.createProgram(routeFiles, {
-    target: ts.ScriptTarget.ESNext,
-    module: ts.ModuleKind.CommonJS,
-  })
-  const checker = program.getTypeChecker()
-  const sourceFiles = program.getSourceFiles()
-
-  // Infer root directory from source files
-  const rootDir = findCommonAncestor(routeFiles)
-
-  const state: InspectorState = {
+/**
+ * Creates an initial/empty inspector state with all required properties initialized
+ * @param rootDir - The root directory for the project
+ * @returns A fresh InspectorState with empty collections
+ */
+export function getInitialInspectorState(rootDir: string): InspectorState {
+  return {
     rootDir,
     singletonServicesTypeImportMap: new Map(),
     sessionServicesTypeImportMap: new Map(),
@@ -99,30 +91,89 @@ export const inspect = (
       usedFunctions: new Set(),
       usedMiddleware: new Set(),
       usedPermissions: new Set(),
+      allSingletonServices: [],
+      allSessionServices: [],
     },
   }
+}
+
+export const inspect = (
+  logger: InspectorLogger,
+  routeFiles: string[],
+  options: InspectorOptions = {}
+): InspectorState => {
+  const startProgram = performance.now()
+  const program = ts.createProgram(routeFiles, {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.CommonJS,
+    skipLibCheck: true,
+    skipDefaultLibCheck: true,
+    moduleResolution: ts.ModuleResolutionKind.Node10,
+    types: [],
+    allowJs: false,
+    checkJs: false,
+  })
+  logger.debug(
+    `Created program in ${(performance.now() - startProgram).toFixed(2)}ms`
+  )
+
+  const startChecker = performance.now()
+  const checker = program.getTypeChecker()
+  logger.debug(
+    `Got type checker in ${(performance.now() - startChecker).toFixed(2)}ms`
+  )
+
+  const startSourceFiles = performance.now()
+  const sourceFiles = program.getSourceFiles()
+  logger.debug(
+    `Got source files in ${(performance.now() - startSourceFiles).toFixed(2)}ms`
+  )
+
+  // Infer root directory from source files
+  const rootDir = findCommonAncestor(routeFiles)
+
+  const state = getInitialInspectorState(rootDir)
 
   // First sweep: add all functions
+  const startSetup = performance.now()
   for (const sourceFile of sourceFiles) {
     ts.forEachChild(sourceFile, (child) =>
       visitSetup(logger, checker, child, state, options)
     )
   }
+  logger.debug(
+    `Visit setup phase completed in ${(performance.now() - startSetup).toFixed(2)}ms`
+  )
 
-  // Second sweep: add all transports
-  for (const sourceFile of sourceFiles) {
-    ts.forEachChild(sourceFile, (child) =>
-      visitRoutes(logger, checker, child, state, options)
+  if (!options.setupOnly) {
+    // Second sweep: add all transports
+    const startRoutes = performance.now()
+    for (const sourceFile of sourceFiles) {
+      ts.forEachChild(sourceFile, (child) =>
+        visitRoutes(logger, checker, child, state, options)
+      )
+    }
+    logger.debug(
+      `Visit routes phase completed in ${(performance.now() - startRoutes).toFixed(2)}ms`
     )
   }
 
   // Populate filesAndMethods
+  const startFilesAndMethods = performance.now()
   const { result, errors } = getFilesAndMethods(state, options.types)
   state.filesAndMethods = result
   state.filesAndMethodsErrors = errors
+  logger.debug(
+    `Get files and methods completed in ${(performance.now() - startFilesAndMethods).toFixed(2)}ms`
+  )
 
-  // Post-processing: Aggregate required services from wired functions/middleware/permissions
-  aggregateRequiredServices(state)
+  if (!options.setupOnly) {
+    const startAggregate = performance.now()
+    aggregateRequiredServices(state)
+    logger.debug(
+      `Aggregate required services completed in ${(performance.now() - startAggregate).toFixed(2)}ms`
+    )
+  }
 
   return state
 }

package/src/types.ts

@@ -114,6 +114,7 @@ export type InspectorFilters = {
 }
 
 export type InspectorOptions = Partial<{
+  setupOnly: boolean
   types: Partial<{
     configFileType: string
     userSessionType: string
@@ -231,5 +232,7 @@ export interface InspectorState {
     usedFunctions: Set<string> // Function names actually wired/exposed
     usedMiddleware: Set<string> // Middleware names used by wired functions
     usedPermissions: Set<string> // Permission names used by wired functions
+    allSingletonServices: string[] // All services available in SingletonServices type
+    allSessionServices: string[] // All services available in Services type (excluding SingletonServices)
   }
 }

package/src/utils/get-files-and-methods.ts

@@ -54,9 +54,9 @@ const getMetaTypes = (
     const helpMessage =
       type === 'CoreConfig'
         ? `No ${type} found. Make sure you have exported a createConfig function in your codebase:\n\n` +
-          `export const createConfig: CreateConfig<Config> = async () => {\n` +
+          `export const createConfig = pikkuConfig(async () => {\n` +
           `  return {}\n` +
-          `}\n\n` +
+          `})\n\n` +
           `Possible issues:\n` +
           `- srcDirectories in pikku.config.json doesn't include the file with the createConfig method`
         : `No ${type} found`

package/src/utils/post-process.ts

@@ -4,6 +4,7 @@ import {
   MiddlewareMetadata,
   PermissionMetadata,
 } from '@pikku/core'
+import { extractTypeKeys } from './type-utils.js'
 
 /**
  * Helper to extract wire-level middleware/permission names from metadata.
@@ -28,7 +29,7 @@ export function extractWireNames(
  */
 function expandAndAddGroupServices(
   list: MiddlewareMetadata[] | PermissionMetadata[] | undefined,
-  state: InspectorState,
+  state: InspectorState | Omit<InspectorState, 'typesLookup'>,
   addServices: (services: FunctionServicesMeta | undefined) => void,
   isMiddleware: boolean
 ): void {
@@ -57,6 +58,38 @@ function expandAndAddGroupServices(
   }
 }
 
+/**
+ * Extracts all service names from SingletonServices and Services types.
+ * This provides the complete list of available services for code generation.
+ * Only runs if typesLookup is available (omitted in deserialized states).
+ */
+function extractAllServices(
+  state: InspectorState | Omit<InspectorState, 'typesLookup'>
+): void {
+  // Skip if typesLookup is not available (e.g., deserialized state)
+  if (!('typesLookup' in state)) {
+    return
+  }
+
+  // Extract all singleton services from the SingletonServices type
+  const singletonServicesTypes = state.typesLookup.get('SingletonServices')
+  if (singletonServicesTypes && singletonServicesTypes.length > 0) {
+    const singletonServiceNames = extractTypeKeys(singletonServicesTypes[0])
+    state.serviceAggregation.allSingletonServices = singletonServiceNames.sort()
+  }
+
+  // Extract all services from the Services type
+  const servicesTypes = state.typesLookup.get('Services')
+  if (servicesTypes && servicesTypes.length > 0) {
+    const allServiceNames = extractTypeKeys(servicesTypes[0])
+    // Session services are those in Services but not in SingletonServices
+    const singletonSet = new Set(state.serviceAggregation.allSingletonServices)
+    state.serviceAggregation.allSessionServices = allServiceNames
+      .filter((name) => !singletonSet.has(name))
+      .sort()
+  }
+}
+
 /**
  * Aggregates all required services from wired functions, middleware, and permissions.
  * Must be called after AST traversal completes.
@@ -64,7 +97,12 @@ function expandAndAddGroupServices(
  * Note: usedFunctions, usedMiddleware, and usedPermissions are tracked directly
  * in the add-* methods during AST traversal for efficiency.
  */
-export function aggregateRequiredServices(state: InspectorState): void {
+export function aggregateRequiredServices(
+  state: InspectorState | Omit<InspectorState, 'typesLookup'>
+): void {
+  // First, extract all available services from types
+  extractAllServices(state)
+
   const { requiredServices, usedFunctions, usedMiddleware, usedPermissions } =
     state.serviceAggregation
 

package/src/utils/serialize-inspector-state.ts

@@ -162,6 +162,8 @@ export interface SerializableInspectorState {
     usedFunctions: string[]
     usedMiddleware: string[]
     usedPermissions: string[]
+    allSingletonServices: string[]
+    allSessionServices: string[]
   }
 }
 
@@ -271,6 +273,8 @@ export function serializeInspectorState(
       usedFunctions: Array.from(state.serviceAggregation.usedFunctions),
       usedMiddleware: Array.from(state.serviceAggregation.usedMiddleware),
       usedPermissions: Array.from(state.serviceAggregation.usedPermissions),
+      allSingletonServices: state.serviceAggregation.allSingletonServices,
+      allSessionServices: state.serviceAggregation.allSessionServices,
     },
   }
 }
@@ -370,6 +374,8 @@ export function deserializeInspectorState(
       usedFunctions: new Set(data.serviceAggregation.usedFunctions),
       usedMiddleware: new Set(data.serviceAggregation.usedMiddleware),
       usedPermissions: new Set(data.serviceAggregation.usedPermissions),
+      allSingletonServices: data.serviceAggregation.allSingletonServices,
+      allSessionServices: data.serviceAggregation.allSessionServices,
     },
   }
 }

package/src/utils/type-utils.ts

@@ -37,20 +37,22 @@ export function getPropertyAssignmentInitializer(
     ) {
       if (!checker) return prop.name // best effort without a checker
 
-      let sym = checker.getSymbolAtLocation(prop.name)
+      // Use the proper TypeScript API for shorthand property resolution
+      let sym = checker.getShorthandAssignmentValueSymbol(prop)
       if (sym && sym.flags & ts.SymbolFlags.Alias) {
         sym = checker.getAliasedSymbol(sym)
       }
 
       const decl = sym?.declarations?.[0]
 
-      // const foo = () => {}
+      // const foo = () => {} or const foo = pikkuFunc(...)
       if (
         decl &&
         ts.isVariableDeclaration(decl) &&
         decl.initializer &&
         (ts.isArrowFunction(decl.initializer) ||
-          ts.isFunctionExpression(decl.initializer))
+          ts.isFunctionExpression(decl.initializer) ||
+          ts.isCallExpression(decl.initializer))
       ) {
         return decl.initializer
       }

package/src/visit.ts

@@ -70,8 +70,8 @@ export const visitSetup = (
   )
 
   addFileWithFactory(node, checker, state.configFactories, 'CreateConfig')
-  addRPCInvocations(node, state, logger)
 
+  addRPCInvocations(node, state, logger)
   addMiddleware(logger, node, checker, state, options)
   addPermission(logger, node, checker, state, options)