@pikku/inspector 0.12.75 → 0.12.81

package/src/utils/resolve-addon-package.ts

@@ -1,106 +0,0 @@
-import * as ts from 'typescript'
-import { existsSync, readFileSync } from 'fs'
-import { dirname, join, parse } from 'path'
-
-const packageNameCache = new Map<string, string | null>()
-
-const findPackageNameForFile = (filePath: string): string | null => {
-  if (packageNameCache.has(filePath)) {
-    return packageNameCache.get(filePath)!
-  }
-  const root = parse(filePath).root
-  let dir = dirname(filePath)
-  while (dir && dir !== root) {
-    const pkgPath = join(dir, 'package.json')
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
-        const name = typeof pkg.name === 'string' ? pkg.name : null
-        packageNameCache.set(filePath, name)
-        return name
-      } catch {
-        packageNameCache.set(filePath, null)
-        return null
-      }
-    }
-    const parent = dirname(dir)
-    if (parent === dir) break
-    dir = parent
-  }
-  packageNameCache.set(filePath, null)
-  return null
-}
-
-/**
- * Resolve the addon package name from an imported identifier.
- * Checks if the identifier's import module specifier matches any
- * configured addon package — and if the import is relative (because
- * the identifier resolves to a source file inside the addon package
- * itself), walks up to the nearest package.json to obtain the real
- * package name.
- */
-export const resolveAddonName = (
-  identifier: ts.Identifier,
-  checker: ts.TypeChecker,
-  wireAddonDeclarations?: Map<
-    string,
-    {
-      package: string
-      rpcEndpoint?: string
-      secretOverrides?: Record<string, string>
-      variableOverrides?: Record<string, string>
-      credentialOverrides?: Record<string, string>
-    }
-  >
-): string | null => {
-  if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
-    return null
-  }
-
-  const sym = checker.getSymbolAtLocation(identifier)
-  if (!sym) return null
-
-  const decl = sym.declarations?.[0]
-  if (!decl) return null
-
-  let candidatePackage: string | null = null
-
-  if (ts.isImportSpecifier(decl)) {
-    // ImportSpecifier -> NamedImports -> ImportClause -> ImportDeclaration
-    const importDecl = decl.parent?.parent?.parent
-    if (
-      importDecl &&
-      ts.isImportDeclaration(importDecl) &&
-      ts.isStringLiteral(importDecl.moduleSpecifier)
-    ) {
-      candidatePackage = importDecl.moduleSpecifier.text
-    }
-  }
-
-  // Bare package import path
-  if (candidatePackage && !candidatePackage.startsWith('.')) {
-    for (const addonDecl of wireAddonDeclarations.values()) {
-      if (
-        addonDecl.package === candidatePackage ||
-        candidatePackage.startsWith(`${addonDecl.package}/`)
-      ) {
-        return addonDecl.package
-      }
-    }
-  }
-
-  // Fall back to package.json lookup based on the declaration's source file.
-  // This catches the case where the identifier resolves into an addon
-  // package's own internal source (relative import inside that package).
-  const declFile = decl.getSourceFile()?.fileName
-  if (declFile) {
-    const pkgName = findPackageNameForFile(declFile)
-    if (pkgName) {
-      for (const addonDecl of wireAddonDeclarations.values()) {
-        if (addonDecl.package === pkgName) return addonDecl.package
-      }
-    }
-  }
-
-  return null
-}

package/src/utils/resolve-core-type.test.ts

@@ -1,142 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-import ts from 'typescript'
-import { aggregateRequiredServices } from './post-process.js'
-import type { InspectorState, PathToNameAndType } from '../types.js'
-
-const SOURCE_FILE = '/application-types.ts'
-
-/**
- * Builds the slice of inspector state that service extraction reads: the
- * `typesLookup` entry the AST walk records under whatever the project named its
- * interface, and the import map that points at that name.
- */
-const stateWithCoreTypes = (
-  source: string,
-  singletonName: string,
-  wireName: string
-): InspectorState => {
-  const host: ts.CompilerHost = {
-    ...ts.createCompilerHost({}),
-    getSourceFile: (name, languageVersion) =>
-      name === SOURCE_FILE
-        ? ts.createSourceFile(name, source, languageVersion, true)
-        : undefined,
-    fileExists: (name) => name === SOURCE_FILE,
-    readFile: (name) => (name === SOURCE_FILE ? source : undefined),
-  }
-  const program = ts.createProgram([SOURCE_FILE], { noLib: true }, host)
-  const checker = program.getTypeChecker()
-  const sourceFile = program.getSourceFile(SOURCE_FILE)!
-
-  const typesLookup = new Map<string, ts.Type[]>()
-  const importMapFor = (name: string): PathToNameAndType => {
-    const declaration = sourceFile.statements.find(
-      (statement): statement is ts.InterfaceDeclaration =>
-        ts.isInterfaceDeclaration(statement) && statement.name.text === name
-    )!
-    typesLookup.set(name, [checker.getTypeAtLocation(declaration)])
-    return new Map([
-      [SOURCE_FILE, [{ variable: name, type: name, typePath: SOURCE_FILE }]],
-    ])
-  }
-
-  return {
-    typesLookup,
-    singletonServicesTypeImportMap: importMapFor(singletonName),
-    wireServicesTypeImportMap: importMapFor(wireName),
-    serviceAggregation: {
-      requiredServices: new Set<string>(),
-      usedFunctions: new Set<string>(),
-      usedMiddleware: new Set<string>(),
-      usedPermissions: new Set<string>(),
-      allSingletonServices: [],
-      allWireServices: [],
-    },
-    functions: { meta: {} },
-    middleware: { definitions: {}, tagMiddleware: new Map() },
-    permissions: { definitions: {} },
-    http: {
-      meta: {
-        get: {},
-        post: {},
-        put: {},
-        patch: {},
-        delete: {},
-        head: {},
-        options: {},
-      },
-      routeMiddleware: new Map(),
-    },
-    channels: { meta: {} },
-    queueWorkers: { meta: {} },
-    scheduledTasks: { meta: {} },
-    mcpEndpoints: { toolsMeta: {}, promptsMeta: {}, resourcesMeta: {} },
-    agents: { agentsMeta: {} },
-    workflows: { meta: {}, graphMeta: {} },
-    wireServicesMeta: new Map(),
-    rpc: { internalMeta: {}, exposedMeta: {} },
-    scopes: { definitions: [] },
-    addonFunctions: {},
-    addonRequiredParentServices: [],
-  } as unknown as InspectorState
-}
-
-const CONVENTIONAL = `
-  interface SingletonServices { logger: string; kysely: string }
-  interface Services { logger: string; kysely: string; http: string }
-`
-
-const RENAMED = `
-  interface AppSingletonServices { logger: string; kysely: string }
-  interface AppServices { logger: string; kysely: string; http: string }
-`
-
-describe('service extraction resolves core types by declaration, not by name', () => {
-  test('the conventional names still resolve', () => {
-    const state = stateWithCoreTypes(
-      CONVENTIONAL,
-      'SingletonServices',
-      'Services'
-    )
-    aggregateRequiredServices(state)
-    assert.deepEqual(state.serviceAggregation.allSingletonServices, [
-      'kysely',
-      'logger',
-    ])
-    assert.deepEqual(state.serviceAggregation.allWireServices, ['http'])
-  })
-
-  test('a project that renamed its interfaces resolves the same way', () => {
-    const state = stateWithCoreTypes(
-      RENAMED,
-      'AppSingletonServices',
-      'AppServices'
-    )
-    aggregateRequiredServices(state)
-    assert.deepEqual(
-      state.serviceAggregation.allSingletonServices,
-      ['kysely', 'logger'],
-      'a renamed SingletonServices must not silently resolve to no services'
-    )
-    assert.deepEqual(state.serviceAggregation.allWireServices, ['http'])
-  })
-
-  test('no declaration at all leaves the lists empty for PKU724 to catch', () => {
-    const state = stateWithCoreTypes(
-      CONVENTIONAL,
-      'SingletonServices',
-      'Services'
-    )
-    state.singletonServicesTypeImportMap = new Map()
-    state.wireServicesTypeImportMap = new Map()
-    // Left at their initial empty value on purpose: `extractAllServices` only
-    // assigns when a type resolves, so seeding them here would make the
-    // assertions below true no matter what it did. `typesLookup` still holds
-    // both interfaces under their conventional names — resolving one from
-    // there is exactly the bug this guards.
-    aggregateRequiredServices(state)
-    assert.deepEqual(state.serviceAggregation.allSingletonServices, [])
-    assert.deepEqual(state.serviceAggregation.allWireServices, [])
-  })
-})

package/src/utils/resolve-core-type.ts

@@ -1,35 +0,0 @@
-import type ts from 'typescript'
-import type { PathToNameAndType } from '../types.js'
-
-/**
- * Resolves the one interface extending a core type (`CoreConfig`,
- * `CoreSingletonServices`, `CoreServices`) to the `ts.Type` the AST walk
- * recorded for it.
- *
- * `typesLookup` is keyed by whatever the project named the interface, so
- * reading it under a hardcoded `'SingletonServices'` only works for projects
- * that follow the scaffold's naming. A project that renamed the interface still
- * satisfies every required-type check and then resolves to no services at all,
- * which surfaces far downstream as PKU724 or as every service turning optional.
- * The import map carries the real name, so no name matching is needed.
- *
- * A project is only ever meant to declare one of each: `getMetaTypes` records
- * `More than one ... found` when it sees a second, which `checkRequiredTypes`
- * then reports. That check is the caller's to run, and extraction happens
- * first, so where two declarations do exist this takes the first in traversal
- * order rather than diagnosing the ambiguity itself.
- */
-export const resolveCoreType = (
-  typesLookup: Map<string, ts.Type[]>,
-  importMap: PathToNameAndType
-): ts.Type | undefined => {
-  for (const entries of importMap.values()) {
-    for (const { type } of entries) {
-      const resolved = type ? typesLookup.get(type)?.[0] : undefined
-      if (resolved) {
-        return resolved
-      }
-    }
-  }
-  return undefined
-}

package/src/utils/resolve-deploy-target.test.ts

@@ -1,135 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert'
-import {
-  IncompatibleDeployTargetError,
-  resolveDeployTarget,
-} from './resolve-deploy-target.js'
-
-describe('resolveDeployTarget', () => {
-  test('default → serverless', () => {
-    assert.strictEqual(resolveDeployTarget({}, new Set()), 'serverless')
-  })
-
-  test('explicit deploy: server → server', () => {
-    assert.strictEqual(
-      resolveDeployTarget({ deploy: 'server' }, new Set()),
-      'server'
-    )
-  })
-
-  test('explicit deploy: serverless with no incompatible svc → serverless', () => {
-    assert.strictEqual(
-      resolveDeployTarget(
-        { deploy: 'serverless', services: { services: ['kysely'] } as any },
-        new Set(['fs'])
-      ),
-      'serverless'
-    )
-  })
-
-  test('serverlessIncompatible service forces server even without deploy flag', () => {
-    assert.strictEqual(
-      resolveDeployTarget(
-        { services: { services: ['metaService'] } as any },
-        new Set(['metaService'])
-      ),
-      'server'
-    )
-  })
-
-  test('serverlessIncompatible takes precedence over explicit deploy: server', () => {
-    assert.strictEqual(
-      resolveDeployTarget(
-        {
-          deploy: 'server',
-          services: { services: ['metaService'] } as any,
-        },
-        new Set(['metaService'])
-      ),
-      'server'
-    )
-  })
-
-  test('explicit deploy: serverless + incompatible svc → throws', () => {
-    assert.throws(
-      () =>
-        resolveDeployTarget(
-          {
-            deploy: 'serverless',
-            services: { services: ['metaService', 'unrelated'] } as any,
-          },
-          new Set(['metaService']),
-          'myFunction'
-        ),
-      (err: unknown) => {
-        assert.ok(err instanceof IncompatibleDeployTargetError)
-        assert.strictEqual(err.functionName, 'myFunction')
-        assert.deepStrictEqual(err.incompatibleServices, ['metaService'])
-        assert.match(err.message, /serverless-incompatible/)
-        assert.match(err.message, /myFunction/)
-        return true
-      }
-    )
-  })
-
-  test('multiple incompatible services are all reported', () => {
-    assert.throws(
-      () =>
-        resolveDeployTarget(
-          {
-            deploy: 'serverless',
-            services: {
-              services: ['metaService', 'localContent'],
-            } as any,
-          },
-          new Set(['metaService', 'localContent']),
-          'multiSvc'
-        ),
-      (err: unknown) => {
-        assert.ok(err instanceof IncompatibleDeployTargetError)
-        assert.deepStrictEqual(err.incompatibleServices, [
-          'metaService',
-          'localContent',
-        ])
-        return true
-      }
-    )
-  })
-
-  test('handles funcMeta with no services field', () => {
-    assert.strictEqual(
-      resolveDeployTarget({ deploy: 'server' }, new Set(['metaService'])),
-      'server'
-    )
-  })
-
-  test('defaultTarget: server overrides the serverless default', () => {
-    assert.strictEqual(
-      resolveDeployTarget({}, new Set(), '<unknown>', 'server'),
-      'server'
-    )
-  })
-
-  test('explicit deploy flag wins over defaultTarget', () => {
-    assert.strictEqual(
-      resolveDeployTarget({ deploy: 'serverless' }, new Set(), 'fn', 'server'),
-      'serverless'
-    )
-    assert.strictEqual(
-      resolveDeployTarget({ deploy: 'server' }, new Set(), 'fn', 'serverless'),
-      'server'
-    )
-  })
-
-  test('serverlessIncompatible still forces server regardless of defaultTarget', () => {
-    assert.strictEqual(
-      resolveDeployTarget(
-        { services: { services: ['metaService'] } as any },
-        new Set(['metaService']),
-        'fn',
-        'serverless'
-      ),
-      'server'
-    )
-  })
-})

package/src/utils/resolve-deploy-target.ts

@@ -1,65 +0,0 @@
-import type { FunctionMeta } from '@pikku/core/services'
-
-/**
- * Thrown when a function's explicit `deploy: 'serverless'` conflicts
- * with one of its services being declared `serverlessIncompatible`.
- * The user has to either remove the explicit flag (let it auto-resolve
- * to 'server'), or set `deploy: 'server'` explicitly.
- */
-export class IncompatibleDeployTargetError extends Error {
-  constructor(
-    public readonly functionName: string,
-    public readonly incompatibleServices: string[]
-  ) {
-    super(
-      `Function '${functionName}' is declared deploy: 'serverless' but uses ` +
-        `serverless-incompatible service(s) [${incompatibleServices.join(', ')}]. ` +
-        `Either remove deploy: 'serverless' (will auto-resolve to 'server'), ` +
-        `or set deploy: 'server' explicitly.`
-    )
-    this.name = 'IncompatibleDeployTargetError'
-  }
-}
-
-/**
- * Determine the effective deploy target for a function.
- *
- * Resolution order:
- *   1. If any of the function's services is in `serverlessIncompatible`:
- *      - throw if the function explicitly declares `deploy: 'serverless'`
- *      - otherwise target is 'server'
- *   2. Explicit `funcMeta.deploy: 'serverless' | 'server'`
- *   3. `defaultTarget` (sourced from `pikku.config.json` →
- *      `deploy.defaultTarget`, falling back to 'serverless')
- *
- * Used both by the per-unit deploy analyzer (when bucketing functions
- * into deployment units) and by `filterInspectorState` (when
- * `pikku all --deploy <target>` is used to emit a target-scoped set
- * of gen files).
- */
-export function resolveDeployTarget(
-  funcMeta: Pick<FunctionMeta, 'deploy' | 'services'>,
-  serverlessIncompatible: Set<string>,
-  functionName = '<unknown>',
-  defaultTarget: 'serverless' | 'server' = 'serverless'
-): 'serverless' | 'server' {
-  // Service compatibility wins over the explicit flag — a serverless
-  // bundle of a function that needs (e.g.) node:fs would crash at runtime.
-  const incompatibleHits: string[] = []
-  if (funcMeta.services?.services) {
-    for (const svc of funcMeta.services.services) {
-      if (serverlessIncompatible.has(svc)) incompatibleHits.push(svc)
-    }
-  }
-
-  if (incompatibleHits.length > 0) {
-    if (funcMeta.deploy === 'serverless') {
-      throw new IncompatibleDeployTargetError(functionName, incompatibleHits)
-    }
-    return 'server'
-  }
-
-  if (funcMeta.deploy === 'server') return 'server'
-  if (funcMeta.deploy === 'serverless') return 'serverless'
-  return defaultTarget
-}

package/src/utils/resolve-function-meta.ts

@@ -1,25 +0,0 @@
-import type { FunctionMeta, FunctionsMeta } from '@pikku/core/services'
-
-/**
- * Look up function metadata by pikkuFuncId, checking both local functions
- * and addon functions. Addon functions use namespaced IDs like 'namespace:funcName'.
- */
-export function resolveFunctionMeta(
-  state: {
-    functions: { meta: FunctionsMeta }
-    addonFunctions: Record<string, FunctionsMeta>
-  },
-  pikkuFuncId: string
-): FunctionMeta | undefined {
-  // Check local functions first
-  const local = state.functions.meta[pikkuFuncId]
-  if (local) return local
-
-  // Check addon functions (namespaced like 'swaggerPetstore:addPet')
-  const colonIndex = pikkuFuncId.indexOf(':')
-  if (colonIndex === -1) return undefined
-
-  const namespace = pikkuFuncId.substring(0, colonIndex)
-  const funcName = pikkuFuncId.substring(colonIndex + 1)
-  return state.addonFunctions[namespace]?.[funcName]
-}

package/src/utils/resolve-function-types.ts

@@ -1,42 +0,0 @@
-import type { TypesMap } from '../types-map.js'
-import type { FunctionsMeta } from '@pikku/core/services'
-
-export function resolveFunctionIOTypes(
-  pikkuFuncId: string,
-  functionsMeta: FunctionsMeta,
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-): { inputType: string; outputType: string } {
-  const functionMeta = functionsMeta[pikkuFuncId]
-  if (!functionMeta) {
-    throw new Error(
-      `Function ${pikkuFuncId} not found in functionsMeta. Please check your configuration.`
-    )
-  }
-
-  const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined
-  const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
-
-  let inputType = 'null'
-  if (input) {
-    try {
-      inputType = typesMap.getTypeMeta(input).uniqueName
-    } catch {
-      inputType = input
-    }
-  }
-
-  let outputType = 'null'
-  if (output) {
-    try {
-      outputType = typesMap.getTypeMeta(output).uniqueName
-    } catch {
-      outputType = output
-    }
-  }
-
-  requiredTypes.add(inputType)
-  requiredTypes.add(outputType)
-
-  return { inputType, outputType }
-}

package/src/utils/resolve-identifier.ts

@@ -1,46 +0,0 @@
-import * as ts from 'typescript'
-
-/**
- * Resolve an identifier to its definition, optionally unwrapping
- * known "define" wrapper functions (e.g. defineHTTPRoutes, defineCLICommands).
- *
- * When the identifier resolves to a variable whose initializer is a call
- * to one of the `unwrapFunctionNames`, the first argument of that call
- * is returned instead.
- */
-export function resolveIdentifier(
-  node: ts.Identifier,
-  checker: ts.TypeChecker,
-  unwrapFunctionNames?: string[]
-): ts.Node | undefined {
-  const symbol = checker.getSymbolAtLocation(node)
-  if (!symbol) return undefined
-
-  // Handle aliased symbols (imports)
-  let resolvedSymbol = symbol
-  if (resolvedSymbol.flags & ts.SymbolFlags.Alias) {
-    resolvedSymbol = checker.getAliasedSymbol(resolvedSymbol) ?? resolvedSymbol
-  }
-
-  const decl =
-    resolvedSymbol.valueDeclaration || resolvedSymbol.declarations?.[0]
-  if (!decl) return undefined
-
-  // Follow to the actual value (handles imports, variable declarations)
-  if (ts.isVariableDeclaration(decl) && decl.initializer) {
-    // Check if it's a call to one of the unwrap functions
-    if (
-      ts.isCallExpression(decl.initializer) &&
-      unwrapFunctionNames &&
-      unwrapFunctionNames.length > 0
-    ) {
-      const expr = decl.initializer.expression
-      if (ts.isIdentifier(expr) && unwrapFunctionNames.includes(expr.text)) {
-        return decl.initializer.arguments[0]
-      }
-    }
-    return decl.initializer
-  }
-
-  return undefined
-}

package/src/utils/resolve-ref-contract.ts

@@ -1,71 +0,0 @@
-import * as ts from 'typescript'
-
-export interface RefContractResolution<T> {
-  contract: T
-  /**
-   * Optional basePath override supplied by the consumer via the second
-   * argument, e.g. refHTTP('ns:routes', { basePath: '/ext' }). When undefined
-   * the addon contract's own basePath is preserved.
-   */
-  basePath?: string
-}
-
-const getStringProperty = (
-  obj: ts.ObjectLiteralExpression,
-  name: string
-): string | undefined => {
-  for (const prop of obj.properties) {
-    if (
-      ts.isPropertyAssignment(prop) &&
-      (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) &&
-      prop.name.text === name &&
-      ts.isStringLiteral(prop.initializer)
-    ) {
-      return prop.initializer.text
-    }
-  }
-  return undefined
-}
-
-/**
- * Resolve a refHTTP / refChannel / refCLI call expression against the addon
- * contracts already loaded (and namespaced) by loadAddonFunctionsMeta.
- *
- * The first string argument has the form 'namespace:contractName', mirroring
- * how ref('namespace:fn') references an addon function. Detection is purely
- * syntactic — no import resolution is required because the namespace and
- * contract name are carried in the string literal. An optional second object
- * argument may override mount details such as basePath.
- */
-export const resolveRefContract = <T>(
-  node: ts.Node,
-  helperName: 'refHTTP' | 'refChannel' | 'refCLI',
-  addonContracts: Record<string, Record<string, T>>
-): RefContractResolution<T> | null => {
-  if (!ts.isCallExpression(node)) return null
-  if (
-    !ts.isIdentifier(node.expression) ||
-    node.expression.text !== helperName
-  ) {
-    return null
-  }
-
-  const [arg, optionsArg] = node.arguments
-  if (!arg || !ts.isStringLiteral(arg)) return null
-
-  const separator = arg.text.indexOf(':')
-  if (separator === -1) return null
-
-  const namespace = arg.text.slice(0, separator)
-  const contractName = arg.text.slice(separator + 1)
-
-  const contract = addonContracts[namespace]?.[contractName]
-  if (contract === undefined) return null
-
-  let basePath: string | undefined
-  if (optionsArg && ts.isObjectLiteralExpression(optionsArg)) {
-    basePath = getStringProperty(optionsArg, 'basePath')
-  }
-
-  return { contract, basePath }
-}