@pikku/inspector 0.9.5 → 0.10.0

package/src/{utils.test.ts → utils/filter-utils.test.ts}

@@ -1,8 +1,8 @@
 import { test, describe } from 'node:test'
 import { strict as assert } from 'node:assert'
-import { matchesFilters } from './utils.js'
-import { InspectorFilters } from './types.js'
 import { PikkuWiringTypes } from '@pikku/core'
+import { InspectorFilters } from '../types'
+import { matchesFilters, matchesWildcard } from './filter-utils'
 
 describe('matchesFilters', () => {
   // Mock logger for testing
@@ -481,4 +481,353 @@ describe('matchesFilters', () => {
       assert.equal(result, true)
     })
   })
+
+  describe('Name filtering', () => {
+    test('should return true when name matches exactly', () => {
+      const filters: InspectorFilters = {
+        names: ['email-worker', 'notification-worker'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { name: 'email-worker' },
+        { type: PikkuWiringTypes.queue, name: 'email-queue' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return true when name matches with wildcard', () => {
+      const filters: InspectorFilters = {
+        names: ['email-*'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { name: 'email-worker' },
+        { type: PikkuWiringTypes.queue, name: 'email-queue' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when name does not match wildcard', () => {
+      const filters: InspectorFilters = {
+        names: ['email-*'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { name: 'notification-worker' },
+        { type: PikkuWiringTypes.queue, name: 'notification-queue' },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should use meta.name when params.name is not provided', () => {
+      const filters: InspectorFilters = {
+        names: ['test-*'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        {},
+        { type: PikkuWiringTypes.http, name: 'test-route' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should prefer params.name over meta.name', () => {
+      const filters: InspectorFilters = {
+        names: ['email-*'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { name: 'email-worker' },
+        { type: PikkuWiringTypes.queue, name: 'other-name' },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+  })
+
+  describe('HTTP route filtering', () => {
+    test('should return true when httpRoute matches exactly', () => {
+      const filters: InspectorFilters = {
+        httpRoutes: ['/api/users', '/api/posts'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        {},
+        {
+          type: PikkuWiringTypes.http,
+          name: 'users-route',
+          httpRoute: '/api/users',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return true when httpRoute matches with wildcard', () => {
+      const filters: InspectorFilters = {
+        httpRoutes: ['/api/*'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        {},
+        {
+          type: PikkuWiringTypes.http,
+          name: 'users-route',
+          httpRoute: '/api/users',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when httpRoute does not match wildcard', () => {
+      const filters: InspectorFilters = {
+        httpRoutes: ['/api/*'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        {},
+        {
+          type: PikkuWiringTypes.http,
+          name: 'webhook-route',
+          httpRoute: '/webhooks/stripe',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should not filter when httpRoute is not provided in meta', () => {
+      const filters: InspectorFilters = {
+        httpRoutes: ['/api/*'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        {},
+        { type: PikkuWiringTypes.queue, name: 'worker' },
+        mockLogger
+      )
+
+      assert.equal(result, true) // Does not apply to non-HTTP
+    })
+
+    test('should match multiple route patterns', () => {
+      const filters: InspectorFilters = {
+        httpRoutes: ['/api/*', '/webhooks/*'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        {},
+        {
+          type: PikkuWiringTypes.http,
+          name: 'webhook-route',
+          httpRoute: '/webhooks/stripe',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+  })
+
+  describe('HTTP method filtering', () => {
+    test('should return true when httpMethod matches', () => {
+      const filters: InspectorFilters = {
+        httpMethods: ['GET', 'POST'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        {},
+        {
+          type: PikkuWiringTypes.http,
+          name: 'users-route',
+          httpMethod: 'GET',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when httpMethod does not match', () => {
+      const filters: InspectorFilters = {
+        httpMethods: ['GET', 'POST'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        {},
+        {
+          type: PikkuWiringTypes.http,
+          name: 'users-route',
+          httpMethod: 'DELETE',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should handle case-insensitive method matching', () => {
+      const filters: InspectorFilters = {
+        httpMethods: ['GET', 'POST'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        {},
+        {
+          type: PikkuWiringTypes.http,
+          name: 'users-route',
+          httpMethod: 'get',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should not filter when httpMethod is not provided in meta', () => {
+      const filters: InspectorFilters = {
+        httpMethods: ['GET'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        {},
+        { type: PikkuWiringTypes.queue, name: 'worker' },
+        mockLogger
+      )
+
+      assert.equal(result, true) // Does not apply to non-HTTP
+    })
+  })
+
+  describe('Combined filtering with new filters', () => {
+    test('should return true when all filters including new ones pass', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+        types: ['http'],
+        httpRoutes: ['/api/*'],
+        httpMethods: ['GET'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api'] },
+        {
+          type: PikkuWiringTypes.http,
+          name: 'users-route',
+          httpRoute: '/api/users',
+          httpMethod: 'GET',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, true)
+    })
+
+    test('should return false when httpRoute filter fails', () => {
+      const filters: InspectorFilters = {
+        tags: ['api'],
+        httpRoutes: ['/admin/*'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        { tags: ['api'] },
+        {
+          type: PikkuWiringTypes.http,
+          name: 'users-route',
+          httpRoute: '/api/users',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+
+    test('should return false when httpMethod filter fails', () => {
+      const filters: InspectorFilters = {
+        httpRoutes: ['/api/*'],
+        httpMethods: ['POST'],
+      }
+
+      const result = matchesFilters(
+        filters,
+        {},
+        {
+          type: PikkuWiringTypes.http,
+          name: 'users-route',
+          httpRoute: '/api/users',
+          httpMethod: 'GET',
+        },
+        mockLogger
+      )
+
+      assert.equal(result, false)
+    })
+  })
+})
+
+describe('matchesWildcard', () => {
+  test('should match exact strings', () => {
+    assert.equal(matchesWildcard('email-worker', 'email-worker'), true)
+    assert.equal(matchesWildcard('test', 'test'), true)
+  })
+
+  test('should not match different strings', () => {
+    assert.equal(matchesWildcard('email-worker', 'notification-worker'), false)
+    assert.equal(matchesWildcard('test', 'other'), false)
+  })
+
+  test('should match wildcard prefix', () => {
+    assert.equal(matchesWildcard('email-worker', 'email-*'), true)
+    assert.equal(matchesWildcard('email-sender', 'email-*'), true)
+    assert.equal(matchesWildcard('email', 'email-*'), false) // Needs prefix before *
+  })
+
+  test('should match wildcard for routes', () => {
+    assert.equal(matchesWildcard('/api/users', '/api/*'), true)
+    assert.equal(matchesWildcard('/api/posts', '/api/*'), true)
+    assert.equal(matchesWildcard('/webhooks/stripe', '/api/*'), false)
+  })
+
+  test('should handle empty prefix with wildcard', () => {
+    assert.equal(matchesWildcard('anything', '*'), true)
+    assert.equal(matchesWildcard('', '*'), true)
+  })
+
+  test('should handle exact match when no wildcard', () => {
+    assert.equal(matchesWildcard('test', 'test'), true)
+    assert.equal(matchesWildcard('test', 'test*'), false) // Has suffix after exact match
+  })
+
+  test('should handle special characters in prefix', () => {
+    assert.equal(matchesWildcard('api-v2-users', 'api-v2-*'), true)
+    assert.equal(matchesWildcard('api.v2.users', 'api.v2.*'), true)
+  })
 })

package/src/utils/filter-utils.ts

@@ -0,0 +1,152 @@
+import { InspectorFilters, InspectorLogger } from '../types.js'
+import { PikkuWiringTypes } from '@pikku/core'
+
+/**
+ * Match a value against a pattern with wildcard support
+ * Supports "*" at the beginning, end, or both (e.g., "send*", "*Payment", "*process*")
+ * @param value - The value to check
+ * @param pattern - The pattern with optional "*" wildcard(s)
+ */
+export function matchesWildcard(value: string, pattern: string): boolean {
+  // If pattern is just '*', match everything
+  if (pattern === '*') {
+    return true
+  }
+
+  const startsWithWildcard = pattern.startsWith('*')
+  const endsWithWildcard = pattern.endsWith('*')
+
+  if (startsWithWildcard && endsWithWildcard) {
+    // Pattern like "*middle*" - check if value contains the middle part
+    const middle = pattern.slice(1, -1)
+    if (middle === '') {
+      return true // Pattern is "**", match everything
+    }
+    return value.includes(middle)
+  } else if (startsWithWildcard) {
+    // Pattern like "*suffix" - check if value ends with suffix and has content before
+    const suffix = pattern.slice(1)
+    return value.endsWith(suffix) && value.length > suffix.length
+  } else if (endsWithWildcard) {
+    // Pattern like "prefix*" - check if value starts with prefix and has content after
+    const prefix = pattern.slice(0, -1)
+    return value.startsWith(prefix) && value.length > prefix.length
+  }
+
+  // No wildcard, exact match
+  return value === pattern
+}
+
+export const matchesFilters = (
+  filters: InspectorFilters,
+  params: {
+    tags?: string[]
+    name?: string // Wire/function name for name filter
+  },
+  meta: {
+    type: PikkuWiringTypes
+    name: string
+    filePath?: string
+    httpRoute?: string // For HTTP route filtering
+    httpMethod?: string // For HTTP method filtering
+  },
+  logger: InspectorLogger
+) => {
+  // If no filters are provided, allow everything
+  if (Object.keys(filters).length === 0) {
+    return true
+  }
+
+  // If all filter arrays are empty, allow everything
+  if (
+    (!filters.names || filters.names.length === 0) &&
+    (!filters.tags || filters.tags.length === 0) &&
+    (!filters.types || filters.types.length === 0) &&
+    (!filters.directories || filters.directories.length === 0) &&
+    (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
+    (!filters.httpMethods || filters.httpMethods.length === 0)
+  ) {
+    return true
+  }
+
+  // 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
+    }
+  }
+
+  // Check name filter (with wildcard support)
+  if (filters.names && filters.names.length > 0) {
+    const nameToMatch = params.name || meta.name
+    const nameMatches = filters.names.some((pattern) =>
+      matchesWildcard(nameToMatch, pattern)
+    )
+    if (!nameMatches) {
+      logger.debug(`⒡ Filtered by name: ${meta.type}:${meta.name}`)
+      return false
+    }
+  }
+
+  // Check HTTP route filter (with wildcard support)
+  if (filters.httpRoutes && filters.httpRoutes.length > 0 && meta.httpRoute) {
+    const routeMatches = filters.httpRoutes.some((pattern) =>
+      matchesWildcard(meta.httpRoute!, pattern)
+    )
+    if (!routeMatches) {
+      logger.debug(`⒡ Filtered by HTTP route: ${meta.httpRoute}`)
+      return false
+    }
+  }
+
+  // Check HTTP method filter
+  if (
+    filters.httpMethods &&
+    filters.httpMethods.length > 0 &&
+    meta.httpMethod
+  ) {
+    const normalizedMethod = meta.httpMethod.toUpperCase()
+    if (!filters.httpMethods.includes(normalizedMethod)) {
+      logger.debug(`⒡ Filtered by HTTP method: ${meta.httpMethod}`)
+      return false
+    }
+  }
+
+  return true
+}

package/src/utils/find-root-dir.ts

@@ -0,0 +1,68 @@
+import path from 'path'
+
+/**
+ * Finds the common ancestor directory of all the given file paths.
+ * This is used to determine the project root directory.
+ *
+ * @param filePaths - Array of absolute file paths
+ * @returns The common ancestor directory path
+ *
+ * @example
+ * findCommonAncestor([
+ *   '/Users/yasser/git/pikku/pikku/src/functions/a.ts',
+ *   '/Users/yasser/git/pikku/pikku/src/routes/b.ts'
+ * ])
+ * // Returns: '/Users/yasser/git/pikku/pikku'
+ */
+export function findCommonAncestor(filePaths: string[]): string {
+  if (filePaths.length === 0) {
+    return process.cwd()
+  }
+
+  if (filePaths.length === 1) {
+    return path.dirname(filePaths[0]!)
+  }
+
+  // Normalize all paths and get their directory parts
+  const normalizedPaths = filePaths.map((p) =>
+    path.dirname(path.normalize(p)).split(path.sep)
+  )
+
+  // Start with the first path's parts
+  const firstPath = normalizedPaths[0]!
+  let commonParts: string[] = []
+
+  // Check each part of the first path
+  for (let i = 0; i < firstPath.length; i++) {
+    const part = firstPath[i]!
+
+    // Check if this part exists in all other paths at the same position
+    const existsInAll = normalizedPaths.every(
+      (pathParts) => pathParts[i] === part
+    )
+
+    if (existsInAll) {
+      commonParts.push(part)
+    } else {
+      break
+    }
+  }
+
+  // If no common parts, return root
+  if (commonParts.length === 0) {
+    return path.sep
+  }
+
+  return commonParts.join(path.sep)
+}
+
+/**
+ * Converts an absolute file path to a relative path from the root directory.
+ *
+ * @param absolutePath - The absolute file path
+ * @param rootDir - The root directory to make the path relative to
+ * @returns A relative path from rootDir to the file
+ */
+export function toRelativePath(absolutePath: string, rootDir: string): string {
+  return path.relative(rootDir, absolutePath)
+}