@pikku/inspector 0.11.2 → 0.12.1

package/src/utils/middleware.test.ts

@@ -0,0 +1,204 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { resolveAIMiddleware } from './middleware.js'
+import { getInitialInspectorState } from '../inspector.js'
+import * as ts from 'typescript'
+
+function createSourceFile(code: string): ts.SourceFile {
+  return ts.createSourceFile('test.ts', code, ts.ScriptTarget.ESNext, true)
+}
+
+function getObjectLiteral(
+  sourceFile: ts.SourceFile
+): ts.ObjectLiteralExpression {
+  let result: ts.ObjectLiteralExpression | undefined
+  ts.forEachChild(sourceFile, function visit(node) {
+    if (ts.isObjectLiteralExpression(node) && !result) {
+      result = node
+    }
+    ts.forEachChild(node, visit)
+  })
+  if (!result) throw new Error('No object literal found')
+  return result
+}
+
+function createMockChecker(): ts.TypeChecker {
+  return {} as any
+}
+
+describe('resolveAIMiddleware', () => {
+  test('should return undefined when no aiMiddleware property exists', () => {
+    const state = getInitialInspectorState('/test')
+    const src = createSourceFile('const x = { name: "test" }')
+    const obj = getObjectLiteral(src)
+    const checker = createMockChecker()
+
+    const result = resolveAIMiddleware(state, obj, checker)
+
+    assert.strictEqual(result, undefined)
+  })
+
+  test('should return undefined when aiMiddleware array is empty', () => {
+    const state = getInitialInspectorState('/test')
+    const src = createSourceFile('const x = { aiMiddleware: [] }')
+    const obj = getObjectLiteral(src)
+    const checker = createMockChecker()
+
+    const result = resolveAIMiddleware(state, obj, checker)
+
+    assert.strictEqual(result, undefined)
+  })
+
+  test('should resolve aiMiddleware identifiers as wire metadata', () => {
+    const state = getInitialInspectorState('/test')
+    state.aiMiddleware.definitions['myAIMW'] = {
+      services: { optimized: true, services: ['logger'] },
+      sourceFile: '/test/middleware.ts',
+      position: 0,
+      exportedName: 'myAIMW',
+    }
+
+    const code = 'const x = { aiMiddleware: [myAIMW] }'
+    const program = ts.createProgram({
+      rootNames: ['test.ts'],
+      options: { target: ts.ScriptTarget.ESNext },
+      host: {
+        ...ts.createCompilerHost({}),
+        getSourceFile: (name) => {
+          if (name === 'test.ts')
+            return ts.createSourceFile(name, code, ts.ScriptTarget.ESNext, true)
+          return undefined
+        },
+        fileExists: (name) => name === 'test.ts',
+        readFile: (name) => (name === 'test.ts' ? code : undefined),
+      },
+    })
+    const checker = program.getTypeChecker()
+    const sourceFile = program.getSourceFile('test.ts')!
+    const obj = getObjectLiteral(sourceFile)
+
+    const result = resolveAIMiddleware(state, obj, checker)
+
+    assert.ok(result)
+    assert.strictEqual(result.length, 1)
+    assert.deepStrictEqual(result[0], {
+      type: 'wire',
+      name: 'myAIMW',
+      inline: false,
+    })
+  })
+
+  test('should resolve multiple aiMiddleware entries', () => {
+    const state = getInitialInspectorState('/test')
+    state.aiMiddleware.definitions['firstMW'] = {
+      services: { optimized: true, services: ['logger'] },
+      sourceFile: '/test/middleware.ts',
+      position: 0,
+      exportedName: 'firstMW',
+    }
+    state.aiMiddleware.definitions['secondMW'] = {
+      services: { optimized: true, services: [] },
+      sourceFile: '/test/middleware.ts',
+      position: 100,
+      exportedName: 'secondMW',
+    }
+
+    const code = 'const x = { aiMiddleware: [firstMW, secondMW] }'
+    const program = ts.createProgram({
+      rootNames: ['test.ts'],
+      options: { target: ts.ScriptTarget.ESNext },
+      host: {
+        ...ts.createCompilerHost({}),
+        getSourceFile: (name) => {
+          if (name === 'test.ts')
+            return ts.createSourceFile(name, code, ts.ScriptTarget.ESNext, true)
+          return undefined
+        },
+        fileExists: (name) => name === 'test.ts',
+        readFile: (name) => (name === 'test.ts' ? code : undefined),
+      },
+    })
+    const checker = program.getTypeChecker()
+    const sourceFile = program.getSourceFile('test.ts')!
+    const obj = getObjectLiteral(sourceFile)
+
+    const result = resolveAIMiddleware(state, obj, checker)
+
+    assert.ok(result)
+    assert.strictEqual(result.length, 2)
+    assert.strictEqual(result[0].type, 'wire')
+    assert.strictEqual((result[0] as any).name, 'firstMW')
+    assert.strictEqual(result[1].type, 'wire')
+    assert.strictEqual((result[1] as any).name, 'secondMW')
+  })
+
+  test('should mark inline aiMiddleware (null exportedName)', () => {
+    const state = getInitialInspectorState('/test')
+    state.aiMiddleware.definitions['inlineMW'] = {
+      services: { optimized: true, services: [] },
+      sourceFile: '/test/middleware.ts',
+      position: 0,
+      exportedName: null,
+    }
+
+    const code = 'const x = { aiMiddleware: [inlineMW] }'
+    const program = ts.createProgram({
+      rootNames: ['test.ts'],
+      options: { target: ts.ScriptTarget.ESNext },
+      host: {
+        ...ts.createCompilerHost({}),
+        getSourceFile: (name) => {
+          if (name === 'test.ts')
+            return ts.createSourceFile(name, code, ts.ScriptTarget.ESNext, true)
+          return undefined
+        },
+        fileExists: (name) => name === 'test.ts',
+        readFile: (name) => (name === 'test.ts' ? code : undefined),
+      },
+    })
+    const checker = program.getTypeChecker()
+    const sourceFile = program.getSourceFile('test.ts')!
+    const obj = getObjectLiteral(sourceFile)
+
+    const result = resolveAIMiddleware(state, obj, checker)
+
+    assert.ok(result)
+    assert.strictEqual(result.length, 1)
+    assert.deepStrictEqual(result[0], {
+      type: 'wire',
+      name: 'inlineMW',
+      inline: true,
+    })
+  })
+
+  test('should handle aiMiddleware referencing unknown definitions', () => {
+    const state = getInitialInspectorState('/test')
+
+    const code = 'const x = { aiMiddleware: [unknownMW] }'
+    const program = ts.createProgram({
+      rootNames: ['test.ts'],
+      options: { target: ts.ScriptTarget.ESNext },
+      host: {
+        ...ts.createCompilerHost({}),
+        getSourceFile: (name) => {
+          if (name === 'test.ts')
+            return ts.createSourceFile(name, code, ts.ScriptTarget.ESNext, true)
+          return undefined
+        },
+        fileExists: (name) => name === 'test.ts',
+        readFile: (name) => (name === 'test.ts' ? code : undefined),
+      },
+    })
+    const checker = program.getTypeChecker()
+    const sourceFile = program.getSourceFile('test.ts')!
+    const obj = getObjectLiteral(sourceFile)
+
+    const result = resolveAIMiddleware(state, obj, checker)
+
+    assert.ok(result)
+    assert.strictEqual(result.length, 1)
+    assert.strictEqual(result[0].type, 'wire')
+    assert.strictEqual((result[0] as any).name, 'unknownMW')
+    assert.strictEqual((result[0] as any).inline, false)
+  })
+})

package/src/utils/middleware.ts

@@ -1,46 +1,61 @@
 import * as ts from 'typescript'
-import { MiddlewareMetadata } from '@pikku/core'
+import type { MiddlewareMetadata } from '@pikku/core'
 import { extractFunctionName } from './extract-function-name.js'
-import { InspectorState } from '../types.js'
+import type { 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(
+export interface MiddlewareRef {
+  definitionId: string
+  isFactoryCall: boolean
+}
+
+export function extractMiddlewareRefs(
   arrayNode: ts.Expression,
   checker: ts.TypeChecker,
   rootDir: string
-): string[] {
+): MiddlewareRef[] {
   if (!ts.isArrayLiteralExpression(arrayNode)) {
     return []
   }
 
-  const names: string[] = []
+  const refs: MiddlewareRef[] = []
   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)
+      const { pikkuFuncId } = extractFunctionName(element, checker, rootDir)
+      refs.push({
+        definitionId: pikkuFuncId.startsWith('__temp_')
+          ? element.text
+          : pikkuFuncId,
+        isFactoryCall: false,
+      })
     } 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(
+      const { pikkuFuncId } = extractFunctionName(
         element.expression,
         checker,
         rootDir
       )
-      names.push(pikkuFuncName)
+      refs.push({
+        definitionId:
+          pikkuFuncId.startsWith('__temp_') &&
+          ts.isIdentifier(element.expression)
+            ? element.expression.text
+            : pikkuFuncId,
+        isFactoryCall: true,
+      })
     }
   }
-  return names
+  return refs
+}
+
+export function extractMiddlewarePikkuNames(
+  arrayNode: ts.Expression,
+  checker: ts.TypeChecker,
+  rootDir: string
+): string[] {
+  return extractMiddlewareRefs(arrayNode, checker, rootDir).map(
+    (r) => r.definitionId
+  )
 }
 
-/**
- * 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 {
@@ -54,31 +69,17 @@ export function getMiddlewareNode(
   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 .*
+    .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*/g, '.*')
 
   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,
@@ -88,10 +89,8 @@ export function resolveHTTPMiddleware(
 ): 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,
@@ -99,11 +98,9 @@ export function resolveHTTPMiddleware(
     }
   }
 
-  // 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,
@@ -112,7 +109,6 @@ export function resolveHTTPMiddleware(
     }
   }
 
-  // 3. Explicit wire middleware (inline is OK here)
   if (explicitMiddlewareNode) {
     const middlewareNames = extractMiddlewarePikkuNames(
       explicitMiddlewareNode,
@@ -120,11 +116,11 @@ export function resolveHTTPMiddleware(
       state.rootDir
     )
     for (const name of middlewareNames) {
-      const meta = state.middleware.meta[name]
+      const def = state.middleware.definitions[name]
       resolved.push({
         type: 'wire',
         name,
-        inline: meta?.exportedName === null,
+        inline: def?.exportedName === null,
       })
     }
   }
@@ -132,11 +128,6 @@ export function resolveHTTPMiddleware(
   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,
@@ -145,11 +136,9 @@ function resolveTagAndExplicitMiddleware(
 ): 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,
@@ -158,7 +147,6 @@ function resolveTagAndExplicitMiddleware(
     }
   }
 
-  // 2. Explicit middleware (inline is OK here - used directly in wire/function)
   if (explicitMiddlewareNode) {
     const middlewareNames = extractMiddlewarePikkuNames(
       explicitMiddlewareNode,
@@ -166,11 +154,11 @@ function resolveTagAndExplicitMiddleware(
       state.rootDir
     )
     for (const name of middlewareNames) {
-      const meta = state.middleware.meta[name]
+      const def = state.middleware.definitions[name]
       resolved.push({
         type: 'wire',
         name,
-        inline: meta?.exportedName === null,
+        inline: def?.exportedName === null,
       })
     }
   }
@@ -178,12 +166,6 @@ function resolveTagAndExplicitMiddleware(
   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,
@@ -200,10 +182,6 @@ function resolveFunctionMiddlewareInternal(
   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,
@@ -219,10 +197,6 @@ export function resolveMiddleware(
   )
 }
 
-/**
- * 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,
@@ -239,3 +213,91 @@ export function resolveHTTPMiddlewareFromObject(
     checker
   )
 }
+
+function getAIMiddlewareNode(
+  obj: ts.ObjectLiteralExpression
+): ts.Expression | undefined {
+  const prop = obj.properties.find(
+    (p) =>
+      ts.isPropertyAssignment(p) &&
+      ts.isIdentifier(p.name) &&
+      p.name.text === 'aiMiddleware'
+  ) as ts.PropertyAssignment | undefined
+  return prop?.initializer
+}
+
+export function resolveAIMiddleware(
+  state: InspectorState,
+  obj: ts.ObjectLiteralExpression,
+  checker: ts.TypeChecker
+): MiddlewareMetadata[] | undefined {
+  const explicitNode = getAIMiddlewareNode(obj)
+  if (!explicitNode) return undefined
+
+  const names = extractMiddlewarePikkuNames(
+    explicitNode,
+    checker,
+    state.rootDir
+  )
+  const resolved: MiddlewareMetadata[] = names.map((name) => {
+    const def = state.aiMiddleware.definitions[name]
+    return {
+      type: 'wire' as const,
+      name,
+      inline: def?.exportedName === null,
+    }
+  })
+
+  return resolved.length > 0 ? resolved : undefined
+}
+
+function getChannelMiddlewareNode(
+  obj: ts.ObjectLiteralExpression
+): ts.Expression | undefined {
+  const prop = obj.properties.find(
+    (p) =>
+      ts.isPropertyAssignment(p) &&
+      ts.isIdentifier(p.name) &&
+      p.name.text === 'channelMiddleware'
+  ) as ts.PropertyAssignment | undefined
+  return prop?.initializer
+}
+
+export function resolveChannelMiddleware(
+  state: InspectorState,
+  obj: ts.ObjectLiteralExpression,
+  tags: string[] | undefined,
+  checker: ts.TypeChecker
+): MiddlewareMetadata[] | undefined {
+  const resolved: MiddlewareMetadata[] = []
+
+  if (tags && tags.length > 0) {
+    for (const tag of tags) {
+      if (state.channelMiddleware.tagMiddleware.has(tag)) {
+        resolved.push({
+          type: 'tag',
+          tag,
+        })
+      }
+    }
+  }
+
+  const explicitNode = getChannelMiddlewareNode(obj)
+  if (explicitNode) {
+    const names = extractMiddlewarePikkuNames(
+      explicitNode,
+      checker,
+      state.rootDir
+    )
+    for (const name of names) {
+      const def = state.channelMiddleware.definitions[name]
+      resolved.push({
+        type: 'wire',
+        name,
+        inline: def?.exportedName === null,
+      })
+    }
+  }
+
+  return resolved.length > 0 ? resolved : undefined
+}

package/src/utils/permissions.test.ts

@@ -54,7 +54,8 @@ describe('resolveHTTPPermissions', () => {
       sourceFile: '/test.ts',
       position: 0,
       services: { services: [], singletons: [] },
-      permissionCount: 1,
+      count: 1,
+      instanceIds: [],
       isFactory: true,
     }
     state.http.routePermissions.set('*', globalPermission)
@@ -79,7 +80,8 @@ describe('resolveHTTPPermissions', () => {
       sourceFile: '/test.ts',
       position: 0,
       services: { services: [], singletons: [] },
-      permissionCount: 1,
+      count: 1,
+      instanceIds: [],
       isFactory: true,
     }
     state.http.routePermissions.set('/api/*', apiPermission)
@@ -104,7 +106,8 @@ describe('resolveHTTPPermissions', () => {
       sourceFile: '/test.ts',
       position: 0,
       services: { services: [], singletons: [] },
-      permissionCount: 1,
+      count: 1,
+      instanceIds: [],
       isFactory: true,
     }
     state.permissions.tagPermissions.set('admin', adminPermission)
@@ -131,7 +134,8 @@ describe('resolveHTTPPermissions', () => {
       sourceFile: '/test.ts',
       position: 0,
       services: { services: [], singletons: [] },
-      permissionCount: 1,
+      count: 1,
+      instanceIds: [],
       isFactory: true,
     })
 
@@ -141,7 +145,8 @@ describe('resolveHTTPPermissions', () => {
       sourceFile: '/test.ts',
       position: 0,
       services: { services: [], singletons: [] },
-      permissionCount: 1,
+      count: 1,
+      instanceIds: [],
       isFactory: true,
     })
 
@@ -151,12 +156,13 @@ describe('resolveHTTPPermissions', () => {
       sourceFile: '/test.ts',
       position: 0,
       services: { services: [], singletons: [] },
-      permissionCount: 1,
+      count: 1,
+      instanceIds: [],
       isFactory: true,
     })
 
     // Setup explicit permission
-    state.permissions.meta['testPermission'] = {
+    state.permissions.definitions['testPermission'] = {
       services: { services: [], singletons: [] },
       sourceFile: '/test.ts',
       position: 0,
@@ -197,7 +203,8 @@ describe('resolvePermissions', () => {
       sourceFile: '/test.ts',
       position: 0,
       services: { services: [], singletons: [] },
-      permissionCount: 1,
+      count: 1,
+      instanceIds: [],
       isFactory: true,
     }
     state.permissions.tagPermissions.set('mcp', mcpPermission)
@@ -217,7 +224,8 @@ describe('resolvePermissions', () => {
       sourceFile: '/test.ts',
       position: 0,
       services: { services: [], singletons: [] },
-      permissionCount: 1,
+      count: 1,
+      instanceIds: [],
       isFactory: true,
     })
     state.permissions.tagPermissions.set('admin', {
@@ -225,7 +233,8 @@ describe('resolvePermissions', () => {
       sourceFile: '/test.ts',
       position: 0,
       services: { services: [], singletons: [] },
-      permissionCount: 1,
+      count: 1,
+      instanceIds: [],
       isFactory: true,
     })
     const mockObj = createMockObjectLiteral()
@@ -298,6 +307,13 @@ function createMockState(): InspectorState {
       meta: {},
       files: new Set(),
     },
+    workflows: {
+      meta: {},
+      files: new Map(),
+      graphMeta: {},
+      graphFiles: new Map(),
+      invokedWorkflows: new Set(),
+    },
     rpc: {
       internalMeta: {},
       internalFiles: new Map(),
@@ -316,11 +332,18 @@ function createMockState(): InspectorState {
       files: new Set(),
     },
     middleware: {
-      meta: {},
+      definitions: {},
+      instances: {},
+      tagMiddleware: new Map(),
+    },
+    channelMiddleware: {
+      definitions: {},
+      instances: {},
       tagMiddleware: new Map(),
     },
     permissions: {
-      meta: {},
+      definitions: {},
+      instances: {},
       tagPermissions: new Map(),
     },
   }