@pikku/inspector 0.10.1 → 0.10.2

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/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)