@pikku/inspector 0.9.6-next.0 → 0.10.1

package/src/utils/filter-utils.test.ts

@@ -2,7 +2,7 @@ import { test, describe } from 'node:test'
 import { strict as assert } from 'node:assert'
 import { PikkuWiringTypes } from '@pikku/core'
 import { InspectorFilters } from '../types'
-import { matchesFilters } from './filter-utils'
+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

@@ -1,13 +1,54 @@
 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[] },
+  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
 ) => {
@@ -18,9 +59,12 @@ export const matchesFilters = (
 
   // 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.directories || filters.directories.length === 0) &&
+    (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
+    (!filters.httpMethods || filters.httpMethods.length === 0)
   ) {
     return true
   }
@@ -68,5 +112,41 @@ export const matchesFilters = (
     }
   }
 
+  // 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)
+}

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

@@ -15,6 +15,7 @@ export type FilesAndMethods = {
   userSessionType: Meta
   sessionServicesType: Meta
   singletonServicesType: Meta
+  pikkuConfigType: Meta
   pikkuConfigFactory: Meta
   singletonServicesFactory: Meta
   sessionServicesFactory: Meta
@@ -53,9 +54,9 @@ const getMetaTypes = (
     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` +
+          `export const createConfig = pikkuConfig(async () => {\n` +
           `  return {}\n` +
-          `}\n\n` +
+          `})\n\n` +
           `Possible issues:\n` +
           `- srcDirectories in pikku.config.json doesn't include the file with the createConfig method`
         : `No ${type} found`
@@ -87,6 +88,7 @@ export const getFilesAndMethods = (
     singletonServicesTypeImportMap,
     sessionServicesTypeImportMap,
     userSessionTypeImportMap,
+    configTypeImportMap,
     sessionServicesFactories,
     singletonServicesFactories,
     configFactories,
@@ -119,6 +121,12 @@ export const getFilesAndMethods = (
       undefined,
       errors
     ),
+    pikkuConfigType: getMetaTypes(
+      'CoreConfig',
+      configTypeImportMap,
+      undefined,
+      errors
+    ),
     pikkuConfigFactory: getMetaTypes(
       'CoreConfig',
       configFactories,

package/src/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

@@ -10,7 +10,8 @@ import { InspectorState } from '../types.js'
  */
 export function extractMiddlewarePikkuNames(
   arrayNode: ts.Expression,
-  checker: ts.TypeChecker
+  checker: ts.TypeChecker,
+  rootDir: string
 ): string[] {
   if (!ts.isArrayLiteralExpression(arrayNode)) {
     return []
@@ -20,12 +21,16 @@ export function extractMiddlewarePikkuNames(
   for (const element of arrayNode.elements) {
     if (ts.isIdentifier(element)) {
       // Resolve the identifier to its pikkuFuncName
-      const { pikkuFuncName } = extractFunctionName(element, checker)
+      const { pikkuFuncName } = extractFunctionName(element, checker, rootDir)
       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)
+      // 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)
     }
   }
@@ -111,7 +116,8 @@ export function resolveHTTPMiddleware(
   if (explicitMiddlewareNode) {
     const middlewareNames = extractMiddlewarePikkuNames(
       explicitMiddlewareNode,
-      checker
+      checker,
+      state.rootDir
     )
     for (const name of middlewareNames) {
       const meta = state.middleware.meta[name]
@@ -156,7 +162,8 @@ function resolveTagAndExplicitMiddleware(
   if (explicitMiddlewareNode) {
     const middlewareNames = extractMiddlewarePikkuNames(
       explicitMiddlewareNode,
-      checker
+      checker,
+      state.rootDir
     )
     for (const name of middlewareNames) {
       const meta = state.middleware.meta[name]