@pikku/inspector 0.9.5 → 0.10.0

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

@@ -0,0 +1,151 @@
+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
+  pikkuConfigType: 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,
+    configTypeImportMap,
+    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
+    ),
+    pikkuConfigType: getMetaTypes(
+      'CoreConfig',
+      configTypeImportMap,
+      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/{get-property-value.ts → utils/get-property-value.ts}

@@ -1,5 +1,6 @@
 import { PikkuDocs } from '@pikku/core'
 import * as ts from 'typescript'
+import { ErrorCode } from '../error-codes.js'
 
 export const getPropertyValue = (
   obj: ts.ObjectLiteralExpression,
@@ -91,3 +92,29 @@ export const getPropertyValue = (
 
   return null
 }
+
+/**
+ * Gets the 'tags' property from an object and validates it's an array.
+ * Logs a critical error if tags is not an array but still returns the value.
+ * @param logger - Optional logger instance; if not provided, uses console.error
+ */
+export const getPropertyTags = (
+  obj: ts.ObjectLiteralExpression,
+  wiringType: string,
+  wiringName: string | null,
+  logger?: { critical: (code: ErrorCode, message: string) => void }
+): string[] | undefined => {
+  const tagsValue = getPropertyValue(obj, 'tags')
+
+  if (tagsValue !== null && !Array.isArray(tagsValue)) {
+    const errorMsg = `${wiringType} '${wiringName}' has invalid 'tags' property - must be an array of strings.`
+    if (logger) {
+      logger.critical(ErrorCode.INVALID_TAGS_TYPE, errorMsg)
+    } else {
+      console.error(errorMsg)
+    }
+    // Return undefined but don't stop processing - error will be caught by the exit handler
+  }
+
+  return Array.isArray(tagsValue) ? tagsValue : undefined
+}

package/src/utils/middleware.ts

@@ -0,0 +1,241 @@
+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,
+  rootDir: string
+): 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, rootDir)
+      names.push(pikkuFuncName)
+    } else if (ts.isCallExpression(element)) {
+      // Handle call expressions like rateLimiter(10) or logCommandInfoAndTime({...})
+      // Extract the function being called (e.g., 'rateLimiter' from 'rateLimiter(10)')
+      const { pikkuFuncName } = extractFunctionName(
+        element.expression,
+        checker,
+        rootDir
+      )
+      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,
+      state.rootDir
+    )
+    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,
+      state.rootDir
+    )
+    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
+  )
+}