@pikku/inspector 0.12.74 → 0.12.81

package/src/utils/filter-utils.ts

@@ -1,161 +0,0 @@
-import type { InspectorFilters, InspectorLogger } from '../types.js'
-import type { PikkuWiringTypes } from '@pikku/core/types'
-
-/**
- * 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.wires || filters.wires.length === 0) &&
-    (!filters.excludeWires || filters.excludeWires.length === 0) &&
-    (!filters.directories || filters.directories.length === 0) &&
-    (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
-    (!filters.httpMethods || filters.httpMethods.length === 0)
-  ) {
-    return true
-  }
-
-  // Check wire include filter
-  if (filters.wires && filters.wires.length > 0) {
-    if (!filters.wires.includes(meta.type)) {
-      logger.debug(`⒡ Filtered by wire include: ${meta.type}:${meta.name}`)
-      return false
-    }
-  }
-
-  // Check wire exclude filter
-  if (filters.excludeWires && filters.excludeWires.length > 0) {
-    if (filters.excludeWires.includes(meta.type)) {
-      logger.debug(`⒡ Filtered by wire exclude: ${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

@@ -1,68 +0,0 @@
-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/find-zod-transform.test.ts

@@ -1,70 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import * as z from 'zod'
-import { findZodTransform } from './find-zod-transform.js'
-
-test('a schema with no transform is reported as clean', () => {
-  assert.equal(findZodTransform(z.object({ id: z.string() })), undefined)
-  assert.equal(findZodTransform(z.string().min(1).trim()), undefined)
-  // a refinement narrows the value, it does not change its shape
-  assert.equal(
-    findZodTransform(z.object({ id: z.string() }).refine(() => true)),
-    undefined
-  )
-})
-
-test('a transform on the schema itself is found at the root', () => {
-  assert.equal(
-    findZodTransform(z.object({ id: z.string() }).transform((v) => v)),
-    ''
-  )
-})
-
-test('a transform on a field is found by path', () => {
-  assert.equal(
-    findZodTransform(
-      z.object({
-        id: z.string(),
-        when: z.string().transform((s) => new Date(s)),
-      })
-    ),
-    '.when'
-  )
-})
-
-test('a transform is found through wrappers, arrays and unions', () => {
-  assert.equal(
-    findZodTransform(
-      z.object({ tags: z.array(z.string().transform((s) => s.trim())) })
-    ),
-    '.tags[]'
-  )
-  assert.equal(
-    findZodTransform(z.object({ n: z.string().transform(Number).optional() })),
-    '.n'
-  )
-  assert.equal(
-    findZodTransform(
-      z.object({ v: z.union([z.string(), z.number().transform(String)]) })
-    ),
-    '.v|1'
-  )
-  assert.equal(
-    findZodTransform(
-      z.object({
-        m: z.record(
-          z.string(),
-          z.string().transform((s) => s)
-        ),
-      })
-    ),
-    '.m[]'
-  )
-})
-
-test('a self-referencing schema terminates instead of recursing forever', () => {
-  const node: z.ZodType = z.lazy(() =>
-    z.object({ name: z.string(), children: z.array(node) })
-  )
-  assert.equal(findZodTransform(node), undefined)
-})

package/src/utils/find-zod-transform.ts

@@ -1,103 +0,0 @@
-/**
- * Locate a `.transform()` anywhere inside a Zod schema.
- *
- * A transform is why a schema cannot be a function's `input`: the value the
- * caller sends and the value the function receives are different, and a wire
- * contract has to describe one shape. Zod says so twice, in two different
- * places, and neither says it usefully on its own — `toJSONSchema` with
- * `unrepresentable: 'any'` quietly yields `{}`, a schema that accepts
- * everything, and `zodToTs` throws about TypeScript rather than about the
- * wiring. Finding it up front lets the diagnostic name the schema, the path,
- * and the call.
- *
- * Zod 4 models `x.transform(fn)` as a `pipe` whose `out` is a `transform`, so
- * the walk looks for that node rather than for the method.
- */
-
-/** Max nodes visited, so a pathological or cyclic schema cannot hang the walk. */
-const MAX_NODES = 10_000
-
-interface ZodNode {
-  _zod?: { def?: Record<string, any> }
-}
-
-const isNode = (value: unknown): value is ZodNode =>
-  typeof value === 'object' &&
-  value !== null &&
-  typeof (value as ZodNode)._zod?.def?.type === 'string'
-
-/**
- * The path to the first `.transform()` found — `''` when the transform is the
- * schema itself, `'.user.email'` when it is nested — or `undefined` when there
- * is none.
- */
-export function findZodTransform(schema: unknown): string | undefined {
-  const seen = new Set<unknown>()
-  let budget = MAX_NODES
-
-  const walk = (node: unknown, path: string): string | undefined => {
-    if (budget-- <= 0 || !isNode(node) || seen.has(node)) return undefined
-    seen.add(node)
-
-    const def = node._zod!.def!
-    if (def.type === 'transform') return path
-
-    const children: Array<[unknown, string]> = []
-    switch (def.type) {
-      case 'object':
-      case 'interface':
-        for (const [key, child] of Object.entries(def.shape ?? {})) {
-          children.push([child, `${path}.${key}`])
-        }
-        break
-      case 'array':
-      case 'set':
-        children.push([def.element, `${path}[]`])
-        break
-      case 'tuple':
-        for (const [i, child] of (def.items ?? []).entries()) {
-          children.push([child, `${path}[${i}]`])
-        }
-        if (def.rest) children.push([def.rest, `${path}[]`])
-        break
-      case 'union':
-        for (const [i, child] of (def.options ?? []).entries()) {
-          children.push([child, `${path}|${i}`])
-        }
-        break
-      case 'intersection':
-        children.push([def.left, path], [def.right, path])
-        break
-      case 'record':
-      case 'map':
-        children.push(
-          [def.keyType, `${path}[key]`],
-          [def.valueType, `${path}[]`]
-        )
-        break
-      case 'pipe':
-        // `.transform()` itself: report the pipe's own path, not `out`'s.
-        children.push([def.in, path], [def.out, path])
-        break
-      default:
-        // optional, nullable, default, prefault, nonoptional, readonly, catch,
-        // promise, lazy, success — every wrapper Zod spells `innerType`.
-        if (def.innerType) children.push([def.innerType, path])
-        if (def.getter) {
-          try {
-            children.push([def.getter(), path])
-          } catch {
-            // A lazy schema that cannot be forced tells us nothing; skip it.
-          }
-        }
-    }
-
-    for (const [child, childPath] of children) {
-      const found = walk(child, childPath)
-      if (found !== undefined) return found
-    }
-    return undefined
-  }
-
-  return walk(schema, '')
-}

package/src/utils/get-exported-variable-name.ts

@@ -1,48 +0,0 @@
-import * as ts from 'typescript'
-
-const isExportedVariableStatement = (
-  statement: ts.Statement
-): statement is ts.VariableStatement =>
-  ts.isVariableStatement(statement) &&
-  (statement.modifiers?.some(
-    (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword
-  ) ??
-    false)
-
-export const getExportedVariableName = (
-  node: ts.Node,
-  sourceFile: ts.SourceFile | undefined
-): string | null => {
-  if (!sourceFile) {
-    return null
-  }
-
-  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
-    for (const statement of sourceFile.statements) {
-      if (!isExportedVariableStatement(statement)) continue
-      for (const declaration of statement.declarationList.declarations) {
-        if (declaration === node) {
-          return node.name.text
-        }
-      }
-    }
-  }
-
-  if (!ts.isCallExpression(node)) {
-    return null
-  }
-
-  for (const statement of sourceFile.statements) {
-    if (!isExportedVariableStatement(statement)) continue
-    for (const declaration of statement.declarationList.declarations) {
-      if (
-        ts.isIdentifier(declaration.name) &&
-        declaration.initializer === node
-      ) {
-        return declaration.name.text
-      }
-    }
-  }
-
-  return null
-}

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

@@ -1,157 +0,0 @@
-import type {
-  PathToNameAndType,
-  InspectorState,
-  InspectorOptions,
-} from '../types.js'
-
-interface Meta {
-  file: string
-  variable: string
-  type: string
-  typePath: string
-}
-
-export type FilesAndMethods = {
-  userSessionType: Meta
-  wireServicesType: Meta
-  singletonServicesType: Meta
-  pikkuConfigType: Meta
-  pikkuConfigFactory: Meta
-  singletonServicesFactory: Meta
-  wireServicesFactory: Meta
-  serverLifecycleFactory: 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 = pikkuConfig(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,
-    wireServicesTypeImportMap,
-    userSessionTypeImportMap,
-    configTypeImportMap,
-    wireServicesFactories,
-    singletonServicesFactories,
-    configFactories,
-    serverLifecycleFactories,
-  }: InspectorState,
-  {
-    configFileType,
-    userSessionType,
-    singletonServicesFactoryType,
-    wireServicesFactoryType,
-  }: 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
-    ),
-    wireServicesType: getMetaTypes(
-      'CoreServices',
-      wireServicesTypeImportMap,
-      undefined,
-      errors
-    ),
-    pikkuConfigType: getMetaTypes(
-      'CoreConfig',
-      configTypeImportMap,
-      undefined,
-      errors
-    ),
-    pikkuConfigFactory: getMetaTypes(
-      'CoreConfig',
-      configFactories,
-      configFileType,
-      errors
-    ),
-    singletonServicesFactory: getMetaTypes(
-      'CreateSingletonServices',
-      singletonServicesFactories,
-      singletonServicesFactoryType,
-      errors
-    ),
-    wireServicesFactory: getMetaTypes(
-      'CreateWireServices',
-      wireServicesFactories,
-      wireServicesFactoryType,
-      errors
-    ),
-    serverLifecycleFactory: getMetaTypes(
-      'ServerLifecycle',
-      serverLifecycleFactories
-    ),
-  }
-
-  return { result, errors }
-}