@pikku/inspector 0.9.5 → 0.9.6-next.0

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

@@ -0,0 +1,143 @@
+import {
+  PathToNameAndType,
+  InspectorState,
+  InspectorOptions,
+} from '../types.js'
+
+interface Meta {
+  file: string
+  variable: string
+  type: string
+  typePath: string
+}
+
+export type FilesAndMethods = {
+  userSessionType: Meta
+  sessionServicesType: Meta
+  singletonServicesType: Meta
+  pikkuConfigFactory: Meta
+  singletonServicesFactory: Meta
+  sessionServicesFactory: Meta
+}
+
+export type FilesAndMethodsErrors = Map<string, PathToNameAndType>
+
+const getMetaTypes = (
+  type: string,
+  map: PathToNameAndType,
+  desiredType?: string,
+  errors?: FilesAndMethodsErrors
+): Meta | undefined => {
+  if (desiredType) {
+    for (const [file, meta] of map.entries()) {
+      for (const { type: entryType, variable, typePath } of meta) {
+        if (entryType === desiredType) {
+          if (entryType === null || typePath === null) {
+            throw new Error(
+              `Unknown state due to metaType calculation: entryType or typePath is null for ${desiredType} in ${file}`
+            )
+          }
+          return { file, variable, type: entryType, typePath }
+        }
+      }
+    }
+    if (errors) {
+      errors.set(`No ${desiredType} found that extends ${type}`, map)
+    }
+    return
+  }
+
+  const totalValues = Array.from(map.values()).flat()
+
+  if (totalValues.length === 0) {
+    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` +
+          `  return {}\n` +
+          `}\n\n` +
+          `Possible issues:\n` +
+          `- srcDirectories in pikku.config.json doesn't include the file with the createConfig method`
+        : `No ${type} found`
+    if (errors) {
+      errors.set(helpMessage, map)
+    }
+  } else if (totalValues.length > 1) {
+    if (errors) {
+      errors.set(`More than one ${type} found`, map)
+    }
+  } else {
+    const entry = Array.from(map.entries())[0]
+    if (entry) {
+      const [file, [{ type: entryType, variable, typePath }]] = entry
+      if (entryType === null || typePath === null) {
+        throw new Error(
+          `Unknown state due to metaType calculation: entryType or typePath is null for ${type} in ${file}`
+        )
+      }
+      return { file, type: entryType, variable, typePath }
+    }
+  }
+
+  return
+}
+
+export const getFilesAndMethods = (
+  {
+    singletonServicesTypeImportMap,
+    sessionServicesTypeImportMap,
+    userSessionTypeImportMap,
+    sessionServicesFactories,
+    singletonServicesFactories,
+    configFactories,
+  }: InspectorState,
+  {
+    configFileType,
+    userSessionType,
+    singletonServicesFactoryType,
+    sessionServicesFactoryType,
+  }: InspectorOptions['types'] = {}
+): { result: Partial<FilesAndMethods>; errors: FilesAndMethodsErrors } => {
+  const errors: FilesAndMethodsErrors = new Map()
+
+  const result: Partial<FilesAndMethods> = {
+    userSessionType: getMetaTypes(
+      'CoreUserSession',
+      userSessionTypeImportMap,
+      userSessionType,
+      errors
+    ),
+    singletonServicesType: getMetaTypes(
+      'CoreSingletonServices',
+      singletonServicesTypeImportMap,
+      undefined,
+      errors
+    ),
+    sessionServicesType: getMetaTypes(
+      'CoreServices',
+      sessionServicesTypeImportMap,
+      undefined,
+      errors
+    ),
+    pikkuConfigFactory: getMetaTypes(
+      'CoreConfig',
+      configFactories,
+      configFileType,
+      errors
+    ),
+    singletonServicesFactory: getMetaTypes(
+      'CreateSingletonServices',
+      singletonServicesFactories,
+      singletonServicesFactoryType,
+      errors
+    ),
+    sessionServicesFactory: getMetaTypes(
+      'CreateSessionServices',
+      sessionServicesFactories,
+      sessionServicesFactoryType,
+      errors
+    ),
+  }
+
+  return { result, errors }
+}

package/src/utils/middleware.ts

@@ -0,0 +1,234 @@
+import * as ts from 'typescript'
+import { MiddlewareMetadata } from '@pikku/core'
+import { extractFunctionName } from './extract-function-name.js'
+import { InspectorState } from '../types.js'
+
+/**
+ * Extract middleware pikkuFuncNames from an array literal expression
+ * Resolves each identifier to its pikkuFuncName using extractFunctionName
+ * Also handles call expressions (like logCommandInfoAndTime({...}))
+ */
+export function extractMiddlewarePikkuNames(
+  arrayNode: ts.Expression,
+  checker: ts.TypeChecker
+): string[] {
+  if (!ts.isArrayLiteralExpression(arrayNode)) {
+    return []
+  }
+
+  const names: string[] = []
+  for (const element of arrayNode.elements) {
+    if (ts.isIdentifier(element)) {
+      // Resolve the identifier to its pikkuFuncName
+      const { pikkuFuncName } = extractFunctionName(element, checker)
+      names.push(pikkuFuncName)
+    } else if (ts.isCallExpression(element)) {
+      // Handle call expressions like logCommandInfoAndTime({...})
+      // These create inline middleware, so we use the call expression itself as the name
+      const { pikkuFuncName } = extractFunctionName(element, checker)
+      names.push(pikkuFuncName)
+    }
+  }
+  return names
+}
+
+/**
+ * Get middleware array from an object literal expression property
+ * Returns the initializer node for the 'middleware' property if it exists
+ */
+export function getMiddlewareNode(
+  obj: ts.ObjectLiteralExpression
+): ts.Expression | undefined {
+  const middlewareProp = obj.properties.find(
+    (p) =>
+      ts.isPropertyAssignment(p) &&
+      ts.isIdentifier(p.name) &&
+      p.name.text === 'middleware'
+  ) as ts.PropertyAssignment | undefined
+
+  return middlewareProp?.initializer
+}
+
+/**
+ * Check if a route matches a pattern with wildcards
+ * Pattern can be exact match or use * as wildcard
+ * e.g., '/api/*' matches '/api/users', '/api/posts/123', etc.
+ */
+export function routeMatchesPattern(route: string, pattern: string): boolean {
+  if (route === pattern) return true
+
+  // Convert pattern to regex: replace * with .*
+  const regexPattern = pattern
+    .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escape regex special chars except *
+    .replace(/\*/g, '.*') // Replace * with .*
+
+  const regex = new RegExp(`^${regexPattern}$`)
+  return regex.test(route)
+}
+
+/**
+ * Resolve middleware for an HTTP wiring based on:
+ * 1. Global HTTP middleware (addd([...]))
+ * 2. Route-specific HTTP middleware (addHTTPMiddleware('/pattern', [...]))
+ * 3. Tag-based middleware (addMiddleware('tag', [...]))
+ * 4. Explicit wiring middleware (wireHTTP({ middleware: [...] }))
+ * Returns undefined if no middleware is found, otherwise returns array with at least one item
+ */
+export function resolveHTTPMiddleware(
+  state: InspectorState,
+  route: string,
+  tags: string[] | undefined,
+  explicitMiddlewareNode: ts.Expression | undefined,
+  checker: ts.TypeChecker
+): MiddlewareMetadata[] | undefined {
+  const resolved: MiddlewareMetadata[] = []
+
+  // 1. HTTP route middleware groups (includes '*' for global)
+  for (const [pattern, _groupMeta] of state.http.routeMiddleware.entries()) {
+    if (routeMatchesPattern(route, pattern)) {
+      // Just reference the group by route pattern
+      resolved.push({
+        type: 'http',
+        route: pattern,
+      })
+    }
+  }
+
+  // 2. Tag-based middleware groups
+  if (tags && tags.length > 0) {
+    for (const tag of tags) {
+      if (state.middleware.tagMiddleware.has(tag)) {
+        // Just reference the group by tag
+        resolved.push({
+          type: 'tag',
+          tag,
+        })
+      }
+    }
+  }
+
+  // 3. Explicit wire middleware (inline is OK here)
+  if (explicitMiddlewareNode) {
+    const middlewareNames = extractMiddlewarePikkuNames(
+      explicitMiddlewareNode,
+      checker
+    )
+    for (const name of middlewareNames) {
+      const meta = state.middleware.meta[name]
+      resolved.push({
+        type: 'wire',
+        name,
+        inline: meta?.exportedName === null,
+      })
+    }
+  }
+
+  return resolved.length > 0 ? resolved : undefined
+}
+
+/**
+ * Resolve tag-based and explicit middleware (common logic for wires and functions)
+ * 1. Tag-based middleware (addMiddleware('tag', [...]))
+ * 2. Explicit middleware (wireHTTP/pikkuFunc({ middleware: [...] }))
+ */
+function resolveTagAndExplicitMiddleware(
+  state: InspectorState,
+  tags: string[] | undefined,
+  explicitMiddlewareNode: ts.Expression | undefined,
+  checker: ts.TypeChecker
+): MiddlewareMetadata[] {
+  const resolved: MiddlewareMetadata[] = []
+
+  // 1. Tag-based middleware groups
+  if (tags && tags.length > 0) {
+    for (const tag of tags) {
+      if (state.middleware.tagMiddleware.has(tag)) {
+        // Just reference the group by tag
+        resolved.push({
+          type: 'tag',
+          tag,
+        })
+      }
+    }
+  }
+
+  // 2. Explicit middleware (inline is OK here - used directly in wire/function)
+  if (explicitMiddlewareNode) {
+    const middlewareNames = extractMiddlewarePikkuNames(
+      explicitMiddlewareNode,
+      checker
+    )
+    for (const name of middlewareNames) {
+      const meta = state.middleware.meta[name]
+      resolved.push({
+        type: 'wire',
+        name,
+        inline: meta?.exportedName === null,
+      })
+    }
+  }
+
+  return resolved
+}
+
+/**
+ * Resolve middleware for a function based on:
+ * 1. Tag-based middleware (addMiddleware('tag', [...]))
+ * 2. Explicit function middleware (pikkuFunc({ middleware: [...] }))
+ * Returns undefined if no middleware is found, otherwise returns array with at least one item
+ */
+function resolveFunctionMiddlewareInternal(
+  state: InspectorState,
+  tags: string[] | undefined,
+  explicitMiddlewareNode: ts.Expression | undefined,
+  checker: ts.TypeChecker
+): MiddlewareMetadata[] | undefined {
+  const resolved = resolveTagAndExplicitMiddleware(
+    state,
+    tags,
+    explicitMiddlewareNode,
+    checker
+  )
+
+  return resolved.length > 0 ? resolved : undefined
+}
+
+/**
+ * Convenience wrapper: Extract middleware node from object and resolve
+ * Use this in add-* files for cleaner code
+ */
+export function resolveMiddleware(
+  state: InspectorState,
+  obj: ts.ObjectLiteralExpression,
+  tags: string[] | undefined,
+  checker: ts.TypeChecker
+): MiddlewareMetadata[] | undefined {
+  const explicitMiddlewareNode = getMiddlewareNode(obj)
+  return resolveFunctionMiddlewareInternal(
+    state,
+    tags,
+    explicitMiddlewareNode,
+    checker
+  )
+}
+
+/**
+ * Convenience wrapper for HTTP: Extract middleware and resolve with HTTP-specific logic
+ * Use this in add-http-route.ts for cleaner code
+ */
+export function resolveHTTPMiddlewareFromObject(
+  state: InspectorState,
+  route: string,
+  obj: ts.ObjectLiteralExpression,
+  tags: string[] | undefined,
+  checker: ts.TypeChecker
+): MiddlewareMetadata[] | undefined {
+  const explicitMiddlewareNode = getMiddlewareNode(obj)
+  return resolveHTTPMiddleware(
+    state,
+    route,
+    tags,
+    explicitMiddlewareNode,
+    checker
+  )
+}

package/src/utils/type-utils.ts

@@ -0,0 +1,74 @@
+import * as ts from 'typescript'
+
+export const extractTypeKeys = (type: ts.Type): string[] => {
+  return type.getProperties().map((symbol) => symbol.getName())
+}
+
+export function getPropertyAssignmentInitializer(
+  obj: ts.ObjectLiteralExpression,
+  propName: string,
+  followShorthand = false,
+  checker?: ts.TypeChecker
+): ts.Expression | undefined {
+  for (const prop of obj.properties) {
+    // ①  foo: () => {}
+    if (
+      ts.isPropertyAssignment(prop) &&
+      ts.isIdentifier(prop.name) &&
+      prop.name.text === propName
+    ) {
+      return prop.initializer
+    }
+
+    // ②  foo() { … }
+    if (
+      ts.isMethodDeclaration(prop) &&
+      ts.isIdentifier(prop.name) &&
+      prop.name.text === propName
+    ) {
+      return prop.name // the method node *is* the function
+    }
+
+    // ③  { foo }  (shorthand)
+    if (
+      followShorthand &&
+      ts.isShorthandPropertyAssignment(prop) &&
+      prop.name.text === propName
+    ) {
+      if (!checker) return prop.name // best effort without a checker
+
+      let sym = checker.getSymbolAtLocation(prop.name)
+      if (sym && sym.flags & ts.SymbolFlags.Alias) {
+        sym = checker.getAliasedSymbol(sym)
+      }
+
+      const decl = sym?.declarations?.[0]
+
+      // const foo = () => {}
+      if (
+        decl &&
+        ts.isVariableDeclaration(decl) &&
+        decl.initializer &&
+        (ts.isArrowFunction(decl.initializer) ||
+          ts.isFunctionExpression(decl.initializer))
+      ) {
+        return decl.initializer
+      }
+
+      // function foo() {}
+      if (
+        decl &&
+        (ts.isFunctionDeclaration(decl) ||
+          ts.isArrowFunction(decl) ||
+          ts.isFunctionExpression(decl))
+      ) {
+        return decl as ts.Expression
+      }
+
+      // fallback – just give back the identifier
+      return prop.name
+    }
+  }
+
+  return undefined
+}

package/src/visit.ts

@@ -1,45 +1,57 @@
 import * as ts from 'typescript'
-import { addFileWithFactory } from './add-file-with-factory.js'
-import { addFileExtendsCoreType } from './add-file-extends-core-type.js'
-import { addHTTPRoute } from './add-http-route.js'
-import { addSchedule } from './add-schedule.js'
-import { addQueueWorker } from './add-queue-worker.js'
-import { addMCPResource } from './add-mcp-resource.js'
-import { addMCPTool } from './add-mcp-tool.js'
-import { addMCPPrompt } from './add-mcp-prompt.js'
-import { InspectorFilters, InspectorState, InspectorLogger } from './types.js'
-import { addFunctions } from './add-functions.js'
-import { addChannel } from './add-channel.js'
-import { addRPCInvocations } from './add-rpc-invocations.js'
-import { addMiddleware } from './add-middleware.js'
-import { addPermission } from './add-permission.js'
+import { addFileWithFactory } from './add/add-file-with-factory.js'
+import { addFileExtendsCoreType } from './add/add-file-extends-core-type.js'
+import { addHTTPRoute } from './add/add-http-route.js'
+import { addSchedule } from './add/add-schedule.js'
+import { addQueueWorker } from './add/add-queue-worker.js'
+import { addMCPResource } from './add/add-mcp-resource.js'
+import { addMCPTool } from './add/add-mcp-tool.js'
+import { addMCPPrompt } from './add/add-mcp-prompt.js'
+import { InspectorState, InspectorLogger, InspectorOptions } from './types.js'
+import { addFunctions } from './add/add-functions.js'
+import { addChannel } from './add/add-channel.js'
+import { addRPCInvocations } from './add/add-rpc-invocations.js'
+import { addMiddleware } from './add/add-middleware.js'
+import { addPermission } from './add/add-permission.js'
+import { addCLI } from './add/add-cli.js'
 
 export const visitSetup = (
+  logger: InspectorLogger,
   checker: ts.TypeChecker,
   node: ts.Node,
   state: InspectorState,
-  filters: InspectorFilters,
-  logger: InspectorLogger
+  options: InspectorOptions
 ) => {
   addFileExtendsCoreType(
     node,
     checker,
     state.singletonServicesTypeImportMap,
-    'CoreSingletonServices'
+    'CoreSingletonServices',
+    state
   )
 
   addFileExtendsCoreType(
     node,
     checker,
     state.sessionServicesTypeImportMap,
-    'CoreServices'
+    'CoreServices',
+    state
   )
 
   addFileExtendsCoreType(
     node,
     checker,
     state.userSessionTypeImportMap,
-    'CoreUserSession'
+    'CoreUserSession',
+    state
+  )
+
+  addFileExtendsCoreType(
+    node,
+    checker,
+    state.configTypeImportMap,
+    'CoreConfig',
+    state
   )
 
   addFileWithFactory(
@@ -59,30 +71,32 @@ export const visitSetup = (
   addFileWithFactory(node, checker, state.configFactories, 'CreateConfig')
   addRPCInvocations(node, state, logger)
 
+  addMiddleware(logger, node, checker, state, options)
+  addPermission(logger, node, checker, state, options)
+
   ts.forEachChild(node, (child) =>
-    visitSetup(checker, child, state, filters, logger)
+    visitSetup(logger, checker, child, state, options)
   )
 }
 
 export const visitRoutes = (
+  logger: InspectorLogger,
   checker: ts.TypeChecker,
   node: ts.Node,
   state: InspectorState,
-  filters: InspectorFilters,
-  logger: InspectorLogger
+  options: InspectorOptions
 ) => {
-  addFunctions(node, checker, state, logger)
-  addHTTPRoute(node, checker, state, filters, logger)
-  addSchedule(node, checker, state, filters, logger)
-  addQueueWorker(node, checker, state, filters, logger)
-  addChannel(node, checker, state, filters, logger)
-  addMCPResource(node, checker, state, filters, logger)
-  addMCPTool(node, checker, state, filters, logger)
-  addMCPPrompt(node, checker, state, filters, logger)
-  addMiddleware(node, checker, state, logger)
-  addPermission(node, checker, state, logger)
+  addFunctions(logger, node, checker, state, options)
+  addHTTPRoute(logger, node, checker, state, options)
+  addSchedule(logger, node, checker, state, options)
+  addQueueWorker(logger, node, checker, state, options)
+  addChannel(logger, node, checker, state, options)
+  addCLI(logger, node, checker, state, options)
+  addMCPResource(logger, node, checker, state, options)
+  addMCPTool(logger, node, checker, state, options)
+  addMCPPrompt(logger, node, checker, state, options)
 
   ts.forEachChild(node, (child) =>
-    visitRoutes(checker, child, state, filters, logger)
+    visitRoutes(logger, checker, child, state, options)
   )
 }