@pikku/inspector 0.8.0 → 0.8.1

package/src/utils.test.ts

@@ -0,0 +1,484 @@
+import { test, describe } from 'node:test'
+import { strict as assert } from 'node:assert'
+import { matchesFilters } from './utils.js'
+import { InspectorFilters } from './types.js'
+import { PikkuEventTypes } from '@pikku/core'
+
+describe('matchesFilters', () => {
+  // Mock logger for testing
+  const mockLogger = {
+    info: () => {},
+    error: () => {},
+    warn: () => {},
+    debug: () => {},
+  }
+
+  describe('Empty filters', () => {
+    test('should return true when no filters are provided', () => {
+      const filters: InspectorFilters = {}
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return true when all filter arrays are empty', () => {
+      const filters: InspectorFilters = {
+        tags: [],
+        types: [],
+        directories: [],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+  })
+
+  describe('Tag filtering', () => {
+    test('should return true when tags match', () => {
+      const filters: InspectorFilters = {
+        tags: ['api', 'public'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'internal'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when tags do not match', () => {
+      const filters: InspectorFilters = {
+        tags: ['api', 'public'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['internal', 'private'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should return false when function has no tags but filter requires tags', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: undefined },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should return false when function has empty tags but filter requires tags', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: [] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+  })
+
+  describe('Type filtering', () => {
+    test('should return true when type matches', () => {
+      const filters: InspectorFilters = {
+        types: ['http', 'channel'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when type does not match', () => {
+      const filters: InspectorFilters = {
+        types: ['channel', 'queue'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle all PikkuEventTypes correctly', () => {
+      const eventTypes = [
+        PikkuEventTypes.http,
+        PikkuEventTypes.channel,
+        PikkuEventTypes.queue,
+        PikkuEventTypes.scheduler,
+        PikkuEventTypes.rpc,
+        PikkuEventTypes.mcp,
+      ]
+
+      eventTypes.forEach((eventType) => {
+        const filters: InspectorFilters = {
+          types: [eventType],
+        }
+
+        const result = matchesFilters(
+          filters,
+          { tags: ['test'] },
+          { type: eventType, name: 'test-route' },
+          mockLogger
+        )
+
+        assert.equal(result, true, `Should match for type: ${eventType}`)
+      })
+    })
+  })
+
+  describe('Directory filtering', () => {
+    test('should return true when directory matches', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api', 'src/internal'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when directory does not match', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api', 'src/internal'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/public/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle Windows paths correctly', () => {
+      const filters: InspectorFilters = {
+        directories: ['src\\api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: 'C:\\project\\src\\api\\routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should handle mixed path separators', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: 'C:\\project\\src\\api\\routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when filePath is not provided but directory filter exists', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: 'test-route' }, // no filePath
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle partial path matches', () => {
+      const filters: InspectorFilters = {
+        directories: ['api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/v1/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+  })
+
+  describe('Combined filtering', () => {
+    test('should return true when all filters pass', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+        types: ['http'],
+        directories: ['src/api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'public'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when type filter fails (even if others pass)', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+        types: ['channel'],
+        directories: ['src/api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'public'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should return false when directory filter fails (even if others pass)', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+        types: ['http'],
+        directories: ['src/internal'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'public'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should return false when tag filter fails (even if others pass)', () => {
+      const filters: InspectorFilters = {
+        tags: ['internal'],
+        types: ['http'],
+        directories: ['src/api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'public'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+  })
+
+  describe('Edge cases', () => {
+    test('should handle undefined params', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: undefined },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle empty meta name', () => {
+      const filters: InspectorFilters = {
+        types: ['channel'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.http, name: '' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle special characters in paths', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api-v2'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api-v2/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should handle case sensitivity in directory paths', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/API'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/api/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle multiple matching tags', () => {
+      const filters: InspectorFilters = {
+        tags: ['api', 'v1'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api', 'public', 'v1'] },
+        { type: PikkuEventTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should handle multiple matching types', () => {
+      const filters: InspectorFilters = {
+        types: ['http', 'channel'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        { type: PikkuEventTypes.channel, name: 'test-channel' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should handle multiple matching directories', () => {
+      const filters: InspectorFilters = {
+        directories: ['src/api', 'src/internal'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['test'] },
+        {
+          type: PikkuEventTypes.http,
+          name: 'test-route',
+          filePath: '/project/src/internal/routes.ts',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+  })
+})

package/src/utils.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import { InspectorFilters } from './types.js'
+import { InspectorFilters, InspectorLogger } from './types.js'
 import { PikkuEventTypes } from '@pikku/core'
 
 type ExtractedFunctionName = {
@@ -847,16 +847,66 @@ export const matchesFilters = (
   meta: {
     type: PikkuEventTypes
     name: string
-  }
+    filePath?: string
+  },
+  logger: InspectorLogger
 ) => {
-  if (Object.keys(filters).length === 0 || filters.tags?.length === 0) {
+  // If no filters are provided, allow everything
+  if (Object.keys(filters).length === 0) {
     return true
   }
 
-  if (filters.tags?.some((tag) => params.tags?.includes(tag))) {
+  // If all filter arrays are empty, allow everything
+  if (
+    (!filters.tags || filters.tags.length === 0) &&
+    (!filters.types || filters.types.length === 0) &&
+    (!filters.directories || filters.directories.length === 0)
+  ) {
     return true
   }
 
-  console.debug(`⒡ Filtered: ${meta.type}:${meta.name}`)
-  return false
+  // Check type filter
+  if (filters.types && filters.types.length > 0) {
+    if (!filters.types.includes(meta.type)) {
+      logger.debug(`⒡ Filtered by type: ${meta.type}:${meta.name}`)
+      return false
+    }
+  }
+
+  // Check directory filter
+  if (filters.directories && filters.directories.length > 0) {
+    if (!meta.filePath) {
+      logger.debug(
+        `⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`
+      )
+      return false
+    }
+
+    const matchesDirectory = filters.directories.some((dir) => {
+      // Normalize paths for comparison
+      const normalizedFilePath = meta.filePath!.replace(/\\/g, '/')
+      const normalizedDir = dir.replace(/\\/g, '/')
+      return normalizedFilePath.includes(normalizedDir)
+    })
+
+    if (!matchesDirectory) {
+      logger.debug(
+        `⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`
+      )
+      return false
+    }
+  }
+
+  // Check tag filter
+  if (filters.tags && filters.tags.length > 0) {
+    if (
+      !params.tags ||
+      !filters.tags.some((tag) => params.tags!.includes(tag))
+    ) {
+      logger.debug(`⒡ Filtered by tags: ${meta.type}:${meta.name}`)
+      return false
+    }
+  }
+
+  return true
 }

package/src/visit.ts

@@ -7,7 +7,7 @@ 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 } from './types.js'
+import { InspectorFilters, InspectorState, InspectorLogger } from './types.js'
 import { addFunctions } from './add-functions.js'
 import { addChannel } from './add-channel.js'
 
@@ -15,7 +15,8 @@ export const visitSetup = (
   checker: ts.TypeChecker,
   node: ts.Node,
   state: InspectorState,
-  filters: InspectorFilters
+  filters: InspectorFilters,
+  logger: InspectorLogger
 ) => {
   addFileExtendsCoreType(
     node,
@@ -53,23 +54,28 @@ export const visitSetup = (
   )
 
   addFileWithFactory(node, checker, state.configFactories, 'CreateConfig')
-  addFunctions(node, checker, state, filters)
+  addFunctions(node, checker, state, filters, logger)
 
-  ts.forEachChild(node, (child) => visitSetup(checker, child, state, filters))
+  ts.forEachChild(node, (child) =>
+    visitSetup(checker, child, state, filters, logger)
+  )
 }
 
 export const visitRoutes = (
   checker: ts.TypeChecker,
   node: ts.Node,
   state: InspectorState,
-  filters: InspectorFilters
+  filters: InspectorFilters,
+  logger: InspectorLogger
 ) => {
-  addHTTPRoute(node, checker, state, filters)
-  addSchedule(node, checker, state, filters)
-  addQueueWorker(node, checker, state, filters)
-  addChannel(node, checker, state, filters)
-  addMCPResource(node, checker, state, filters)
-  addMCPTool(node, checker, state, filters)
-  addMCPPrompt(node, checker, state, filters)
-  ts.forEachChild(node, (child) => visitRoutes(checker, child, state, filters))
+  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)
+  ts.forEachChild(node, (child) =>
+    visitRoutes(checker, child, state, filters, logger)
+  )
 }