@pikku/inspector 0.12.75 → 0.12.81

package/src/utils/detect-schema-vendor.test.ts

@@ -1,123 +0,0 @@
-import { test, describe, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import * as ts from 'typescript'
-
-import { detectSchemaVendorOrError } from './detect-schema-vendor.js'
-
-let projectDir: string
-let program: ts.Program
-let checker: ts.TypeChecker
-let sourceFile: ts.SourceFile
-
-const criticals: string[] = []
-const logger = {
-  debug() {},
-  info() {},
-  warn() {},
-  error() {},
-  critical(_code: unknown, message: string) {
-    criticals.push(message)
-  },
-} as any
-
-const initializerIdentifier = (name: string): ts.Identifier => {
-  let found: ts.Identifier | undefined
-  const visit = (node: ts.Node) => {
-    if (
-      ts.isVariableDeclaration(node) &&
-      ts.isIdentifier(node.name) &&
-      node.name.text === name &&
-      node.initializer &&
-      ts.isIdentifier(node.initializer)
-    ) {
-      found = node.initializer
-    }
-    ts.forEachChild(node, visit)
-  }
-  visit(sourceFile)
-  assert.ok(found, `no identifier initializer found for '${name}'`)
-  return found
-}
-
-before(() => {
-  projectDir = mkdtempSync(join(tmpdir(), 'pikku-schema-vendor-'))
-  mkdirSync(join(projectDir, 'src'))
-  writeFileSync(
-    join(projectDir, 'src', 'schemas.ts'),
-    [
-      // Imported from a file that does not exist — exactly what a schema built
-      // from an ungenerated '.pikku/db/zod.gen.ts' looks like to the checker.
-      `import { UngeneratedSchema } from './not-written-yet.js'`,
-      `export const unresolved = UngeneratedSchema`,
-      `const plainObject = { a: 1 }`,
-      `export const resolvedButNotASchema = plainObject`,
-      '',
-    ].join('\n')
-  )
-
-  program = ts.createProgram([join(projectDir, 'src', 'schemas.ts')], {
-    target: ts.ScriptTarget.ESNext,
-    module: ts.ModuleKind.NodeNext,
-    moduleResolution: ts.ModuleResolutionKind.NodeNext,
-    strict: true,
-    skipLibCheck: true,
-    noEmit: true,
-  })
-  checker = program.getTypeChecker()
-  sourceFile = program.getSourceFile(join(projectDir, 'src', 'schemas.ts'))!
-})
-
-after(() => {
-  rmSync(projectDir, { recursive: true, force: true })
-})
-
-describe('detectSchemaVendorOrError', () => {
-  test('reports a type the checker could not resolve as a resolution failure', () => {
-    criticals.length = 0
-
-    const vendor = detectSchemaVendorOrError(
-      initializerIdentifier('unresolved'),
-      checker,
-      logger,
-      `Function 'createTodo' input`,
-      'src/schemas.ts'
-    )
-
-    assert.equal(vendor, undefined)
-    assert.equal(criticals.length, 1)
-    const [message] = criticals
-    assert.match(message, /could not be TYPED/)
-    assert.match(message, /UngeneratedSchema/)
-    assert.match(message, /pikku db generate/)
-    // The unactionable advice must NOT be given for a type that simply failed
-    // to resolve — the schema may well already be zod.
-    assert.doesNotMatch(
-      message,
-      /Ensure your schema is imported from a supported validation library/
-    )
-  })
-
-  test('still reports a resolvable non-vendor type as an unsupported library', () => {
-    criticals.length = 0
-
-    const vendor = detectSchemaVendorOrError(
-      initializerIdentifier('resolvedButNotASchema'),
-      checker,
-      logger,
-      `Function 'createTodo' input`,
-      'src/schemas.ts'
-    )
-
-    assert.equal(vendor, undefined)
-    assert.equal(criticals.length, 1)
-    const [message] = criticals
-    assert.match(
-      message,
-      /Ensure your schema is imported from a supported validation library/
-    )
-    assert.doesNotMatch(message, /could not be TYPED/)
-  })
-})

package/src/utils/detect-schema-vendor.ts

@@ -1,120 +0,0 @@
-import * as ts from 'typescript'
-import type { SchemaVendor, InspectorLogger } from '../types.js'
-import { ErrorCode } from '../error-codes.js'
-
-/**
- * Whether the checker could type the identifier at all.
- *
- * `any` here is not a schema written in an exotic library — it is TypeScript telling us
- * it could not resolve the declaration, which happens when the schema comes from a file
- * outside the program (not matched by tsconfig `include`) or from a generated file that
- * has not been written yet (`.pikku/db/zod.gen.ts` before `pikku db generate` runs).
- * The distinction matters because the two have opposite fixes, and conflating them told
- * users to "import from a supported validation library" about a plain `z.object`.
- */
-const isUnresolved = (type: ts.Type): boolean =>
-  (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0
-
-/**
- * Detect the schema vendor by tracing the type back to its library origin.
- * This handles locally-defined schemas like `export const MySchema = z.object({...})`
- * by checking where the type itself originates from.
- *
- * Supports multiple schema libraries in the same project (e.g., during migration
- * from one library to another).
- */
-export const detectSchemaVendor = (
-  identifier: ts.Identifier,
-  checker: ts.TypeChecker
-): SchemaVendor => {
-  const type = checker.getTypeAtLocation(identifier)
-  if (!type) return 'unknown'
-
-  // Check the type's symbol declarations to find the library origin
-  const checkTypeOrigin = (t: ts.Type): SchemaVendor | null => {
-    const symbol = t.getSymbol() || t.aliasSymbol
-    if (symbol) {
-      const decls = symbol.getDeclarations()
-      if (decls) {
-        for (const decl of decls) {
-          const fileName = decl.getSourceFile().fileName
-          if (fileName.includes('node_modules/zod')) return 'zod'
-          if (fileName.includes('node_modules/valibot')) return 'valibot'
-          if (fileName.includes('node_modules/arktype')) return 'arktype'
-          if (fileName.includes('node_modules/@effect/schema')) return 'effect'
-        }
-      }
-    }
-
-    // Check base types for class/interface hierarchies
-    const baseTypes = t.getBaseTypes?.()
-    if (baseTypes) {
-      for (const baseType of baseTypes) {
-        const result = checkTypeOrigin(baseType)
-        if (result) return result
-      }
-    }
-
-    return null
-  }
-
-  const vendor = checkTypeOrigin(type)
-  if (vendor) return vendor
-
-  // Fallback: check type arguments (for generic types like z.ZodObject<...>)
-  if ((type as ts.TypeReference).typeArguments) {
-    for (const arg of (type as ts.TypeReference).typeArguments || []) {
-      const result = checkTypeOrigin(arg)
-      if (result) return result
-    }
-  }
-
-  return 'unknown'
-}
-
-/**
- * Detect schema vendor and log a fatal error if unknown.
- * Returns the vendor if successful, or undefined if unknown (after logging error).
- *
- * @param identifier - The TypeScript identifier for the schema variable
- * @param checker - TypeScript type checker
- * @param logger - Inspector logger for error reporting
- * @param context - Description of what the schema is for (e.g., "Credential 'myCredential'")
- * @param sourceFile - Source file path for error message
- */
-export const detectSchemaVendorOrError = (
-  identifier: ts.Identifier,
-  checker: ts.TypeChecker,
-  logger: InspectorLogger,
-  context: string,
-  sourceFile: string
-): Exclude<SchemaVendor, 'unknown'> | undefined => {
-  const vendor = detectSchemaVendor(identifier, checker)
-  if (vendor === 'unknown') {
-    // Two different failures used to share one message. Reporting the wrong one is not a
-    // cosmetic problem: the schema is dropped either way (`inputSchemaName: null`, no
-    // generated schema file), so the message is the only thing standing between the user
-    // and a function that silently validates nothing — and "use a supported validation
-    // library" is unactionable when the schema already IS `z.object({...})`.
-    if (isUnresolved(checker.getTypeAtLocation(identifier))) {
-      logger.critical(
-        ErrorCode.INLINE_SCHEMA,
-        `${context} schema '${identifier.text}' could not be TYPED from '${sourceFile}' — ` +
-          `TypeScript resolved it to 'any', so its vendor cannot be traced. This is a ` +
-          `resolution problem, not a schema problem: the file it is imported from is either ` +
-          `outside your tsconfig 'include', or has not been generated yet (a schema built ` +
-          `from '.pikku/db/zod.gen.ts' needs 'pikku db generate' to have run first). ` +
-          `Fix the import so the type resolves, then re-run.`
-      )
-      return undefined
-    }
-    logger.critical(
-      ErrorCode.INLINE_SCHEMA,
-      `${context} schema vendor could not be determined from '${sourceFile}'. ` +
-        `Supported vendors: zod, valibot, arktype, @effect/schema. ` +
-        `Ensure your schema is imported from a supported validation library.`
-    )
-    return undefined
-  }
-  return vendor
-}

package/src/utils/does-type-extend-core-type.ts

@@ -1,53 +0,0 @@
-import type * as ts from 'typescript'
-
-export const doesTypeExtendsCore = (
-  type: ts.Type,
-  checker: ts.TypeChecker,
-  visitedTypes: Set<ts.Type>,
-  coreType: string
-): boolean => {
-  if (!type || !checker) return false
-
-  // Avoid infinite recursion by checking if we've already visited this type
-  if (visitedTypes.has(type)) {
-    return false
-  }
-  visitedTypes.add(type)
-
-  const typeSymbol = type.getSymbol()
-  if (typeSymbol) {
-    // Check if the type is the core type
-    if (typeSymbol.getName() === coreType) {
-      return true
-    }
-
-    // For interface and class types, check their base types
-    if (type.isClassOrInterface()) {
-      const baseTypes = type.getBaseTypes() || []
-      for (const baseType of baseTypes) {
-        if (doesTypeExtendsCore(baseType, checker, visitedTypes, coreType)) {
-          return true
-        }
-      }
-    }
-  }
-
-  // For type aliases, get the aliased type
-  if (type.aliasSymbol) {
-    const aliasedType = checker.getDeclaredTypeOfSymbol(type.aliasSymbol)
-    if (doesTypeExtendsCore(aliasedType, checker, visitedTypes, coreType)) {
-      return true
-    }
-  }
-
-  // For union and intersection types, check all constituent types
-  if (type.isUnionOrIntersection()) {
-    for (const subType of type.types) {
-      if (doesTypeExtendsCore(subType, checker, visitedTypes, coreType)) {
-        return true
-      }
-    }
-  }
-
-  return false
-}

package/src/utils/ensure-function-metadata.ts

@@ -1,385 +0,0 @@
-import * as ts from 'typescript'
-import type { InspectorState } from '../types.js'
-import { funcIdToTypeName } from './extract-function-name.js'
-import { getCommonWireMetaData } from './get-property-value.js'
-import { resolveMiddleware } from './middleware.js'
-import { resolvePermissions } from './permissions.js'
-
-function isVoidLike(type: ts.Type): boolean {
-  return !!(
-    type.flags &
-    (ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike)
-  )
-}
-
-function isPromiseOfVoid(checker: ts.TypeChecker, type: ts.Type): boolean {
-  if (!type?.symbol) return false
-  const isPromise =
-    type.symbol.name === 'Promise' &&
-    checker.getFullyQualifiedName(type.symbol).includes('Promise')
-  if (!isPromise) return false
-  const inner =
-    type.aliasTypeArguments?.[0] ??
-    (type as ts.TypeReference).typeArguments?.[0]
-  return !!inner && isVoidLike(inner)
-}
-
-function unwrapPromise(checker: ts.TypeChecker, type: ts.Type): ts.Type {
-  if (type.isUnion()) {
-    const nonVoid = type.types.filter(
-      (t) => !isVoidLike(t) && !isPromiseOfVoid(checker, t)
-    )
-    if (nonVoid.length === 1) {
-      return unwrapPromise(checker, nonVoid[0]!)
-    }
-    if (nonVoid.length > 1) {
-      return unwrapPromise(checker, nonVoid[0]!)
-    }
-    return type
-  }
-  if (!type?.symbol) return type
-  const isPromise =
-    type.symbol.name === 'Promise' &&
-    checker.getFullyQualifiedName(type.symbol).includes('Promise')
-  if (isPromise && type.aliasTypeArguments?.length === 1) {
-    return type.aliasTypeArguments[0]!
-  }
-  if (isPromise && (type as ts.TypeReference).typeArguments?.length === 1) {
-    return (type as ts.TypeReference).typeArguments![0]!
-  }
-  return type
-}
-
-function resolveTypeName(
-  checker: ts.TypeChecker,
-  type: ts.Type,
-  state: InspectorState,
-  funcName: string,
-  direction: 'Input' | 'Output'
-): string | null {
-  if (type.flags & (ts.TypeFlags.VoidLike | ts.TypeFlags.Null)) return null
-
-  const typeStr = checker.typeToString(
-    type,
-    undefined,
-    ts.TypeFormatFlags.NoTruncation
-  )
-  if (
-    !typeStr ||
-    typeStr === 'void' ||
-    typeStr === 'undefined' ||
-    typeStr === 'null'
-  )
-    return null
-
-  const isSimpleName = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(typeStr)
-  if (isSimpleName) {
-    const symbol = type.aliasSymbol || type.getSymbol()
-    if (symbol) {
-      const decl = symbol.getDeclarations()?.[0]
-      if (decl) {
-        const path = decl.getSourceFile().fileName
-        if (!state.functions.typesMap.exists(typeStr, path)) {
-          state.functions.typesMap.addType(typeStr, path)
-        }
-      }
-    }
-    return typeStr
-  }
-
-  const aliasName = funcIdToTypeName(funcName) + direction
-  state.functions.typesMap.addCustomType(aliasName, typeStr, [])
-  return aliasName
-}
-
-function getFirstCallSignature(type: ts.Type): ts.Signature | undefined {
-  const sigs = type.getCallSignatures()
-  if (sigs.length > 0) return sigs[0]
-  if (type.isUnion()) {
-    for (const member of type.types) {
-      const memberSigs = member.getCallSignatures()
-      if (memberSigs.length > 0) return memberSigs[0]
-    }
-  }
-  return undefined
-}
-
-function resolveFromConfigTypeArgs(
-  state: InspectorState,
-  pikkuFuncId: string,
-  configType: ts.Type,
-  checker: ts.TypeChecker,
-  meta: NonNullable<InspectorState['functions']['meta'][string]>
-): void {
-  const typeArgs =
-    configType.aliasTypeArguments ??
-    (configType as ts.TypeReference).typeArguments
-  if (!typeArgs || typeArgs.length < 2) return
-
-  const inputType = typeArgs[0]!
-  const outputType = typeArgs[1]!
-
-  if (!meta.inputs || meta.inputs.length === 0) {
-    const inputName = resolveTypeName(
-      checker,
-      inputType,
-      state,
-      pikkuFuncId,
-      'Input'
-    )
-    if (inputName) {
-      meta.inputs = [inputName]
-      meta.inputSchemaName = inputName
-    }
-  }
-
-  if (!meta.outputs || meta.outputs.length === 0) {
-    const resolvedOutput = unwrapPromise(checker, outputType)
-    const outputName = resolveTypeName(
-      checker,
-      resolvedOutput,
-      state,
-      pikkuFuncId,
-      'Output'
-    )
-    if (outputName) {
-      meta.outputs = [outputName]
-      meta.outputSchemaName = outputName
-    }
-  }
-}
-
-function resolveFuncConfigTypes(
-  state: InspectorState,
-  pikkuFuncId: string,
-  funcInitializer: ts.Node,
-  checker: ts.TypeChecker
-): void {
-  const meta = state.functions.meta[pikkuFuncId]
-  if (!meta || (meta.inputs && meta.inputs.length > 0)) return
-
-  const configType = checker.getTypeAtLocation(funcInitializer)
-  const funcProp = configType.getProperty('func')
-  if (!funcProp) return
-
-  const funcType = checker.getTypeOfSymbolAtLocation(funcProp, funcInitializer)
-  const sig = getFirstCallSignature(funcType)
-  if (!sig) return
-  const params = sig.getParameters()
-  if (params.length >= 2) {
-    const inputType = checker.getTypeOfSymbolAtLocation(
-      params[1]!,
-      funcInitializer
-    )
-    const inputName = resolveTypeName(
-      checker,
-      inputType,
-      state,
-      pikkuFuncId,
-      'Input'
-    )
-    if (inputName) {
-      meta.inputs = [inputName]
-      meta.inputSchemaName = inputName
-    }
-  }
-
-  const rawReturnType = checker.getReturnTypeOfSignature(sig)
-  const outputType = unwrapPromise(checker, rawReturnType)
-  const outputName = resolveTypeName(
-    checker,
-    outputType,
-    state,
-    pikkuFuncId,
-    'Output'
-  )
-  if (outputName) {
-    meta.outputs = [outputName]
-    meta.outputSchemaName = outputName
-  }
-
-  resolveFromConfigTypeArgs(state, pikkuFuncId, configType, checker, meta)
-}
-
-function resolveToPikkuFuncCall(
-  node: ts.Node,
-  checker: ts.TypeChecker
-): ts.CallExpression | null {
-  if (
-    ts.isCallExpression(node) &&
-    ts.isIdentifier(node.expression) &&
-    node.expression.text.startsWith('pikku')
-  ) {
-    return node
-  }
-
-  if (ts.isIdentifier(node)) {
-    const sym = checker.getSymbolAtLocation(node)
-    if (sym) {
-      let resolved = sym
-      if (resolved.flags & ts.SymbolFlags.Alias) {
-        resolved = checker.getAliasedSymbol(resolved) ?? resolved
-      }
-      const decl = resolved.declarations?.[0]
-      if (decl && ts.isVariableDeclaration(decl) && decl.initializer) {
-        return resolveToPikkuFuncCall(decl.initializer, checker)
-      }
-    }
-  }
-
-  return null
-}
-
-/**
- * Ensures that function metadata exists for a given pikkuFuncId.
- * Creates stub metadata if it doesn't exist (useful for inline functions).
- * When funcInitializer and checker are provided, resolves types and
- * extracts tags/middleware/permissions from the pikkuFunc() config.
- */
-export function ensureFunctionMetadata(
-  state: InspectorState,
-  pikkuFuncId: string,
-  fallbackName?: string,
-  funcInitializer?: ts.Node,
-  checker?: ts.TypeChecker,
-  isHelper?: boolean
-): void {
-  if (!state.functions.meta[pikkuFuncId]) {
-    state.functions.meta[pikkuFuncId] = {
-      pikkuFuncId,
-      functionType: isHelper ? 'helper' : 'inline',
-      name: fallbackName || pikkuFuncId,
-      services: { optimized: false, services: [] },
-      inputSchemaName: null,
-      outputSchemaName: null,
-      inputs: [],
-      outputs: [],
-      middleware: undefined,
-    }
-  }
-
-  const meta = state.functions.meta[pikkuFuncId]!
-
-  if (funcInitializer && checker) {
-    let pikkuFuncCall: ts.CallExpression | null = null
-
-    if (ts.isCallExpression(funcInitializer)) {
-      pikkuFuncCall = funcInitializer
-      resolveFuncConfigTypes(state, pikkuFuncId, pikkuFuncCall, checker)
-      if (!state.typesLookup.has(pikkuFuncId)) {
-        populateTypesLookup(state, pikkuFuncId, pikkuFuncCall, checker)
-      }
-    } else {
-      pikkuFuncCall = resolveToPikkuFuncCall(funcInitializer, checker)
-    }
-
-    if (pikkuFuncCall) {
-      const firstArg = pikkuFuncCall.arguments[0]
-      if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-        if (!meta.tags) {
-          const { tags } = getCommonWireMetaData(
-            firstArg,
-            'Function',
-            fallbackName || pikkuFuncId,
-            undefined,
-            checker
-          )
-          if (tags) {
-            meta.tags = tags
-          }
-        }
-        if (!meta.middleware) {
-          meta.middleware = resolveMiddleware(
-            state,
-            firstArg,
-            meta.tags,
-            checker
-          )
-        }
-        if (!meta.permissions) {
-          meta.permissions = resolvePermissions(
-            state,
-            firstArg,
-            meta.tags,
-            checker
-          )
-        }
-      }
-    }
-  }
-}
-
-/**
- * Register metadata for a `func:` inlined into a wiring (queue/scheduler/
- * trigger/gateway/…).
- *
- * An inline function has no exported name, so `addFunctions` skips it (it bails
- * on `__temp_` ids) and only the wiring's context-based id exists. Without this
- * the wiring points at a function that was never registered and the worker
- * resolves to nothing at runtime ("Missing generated metadata for ...").
- *
- * The stub also carries no session info, so the runtime would treat it as
- * session-required and every invocation would fail with "Authentication
- * required". Derive `sessionless` from the helper the function was built with —
- * the same rule `addFunctions` applies to named ones (`!== 'pikkuFunc'`).
- */
-export function ensureInlineWiringFunction(
-  state: InspectorState,
-  pikkuFuncId: string,
-  fallbackName: string | undefined,
-  funcInitializer: ts.Node,
-  checker: ts.TypeChecker,
-  isHelper?: boolean
-): void {
-  ensureFunctionMetadata(
-    state,
-    pikkuFuncId,
-    fallbackName,
-    funcInitializer,
-    checker,
-    isHelper
-  )
-
-  const meta = state.functions.meta[pikkuFuncId]
-  if (
-    meta &&
-    meta.sessionless === undefined &&
-    ts.isCallExpression(funcInitializer) &&
-    ts.isIdentifier(funcInitializer.expression)
-  ) {
-    meta.sessionless = funcInitializer.expression.text !== 'pikkuFunc'
-  }
-}
-
-function populateTypesLookup(
-  state: InspectorState,
-  pikkuFuncId: string,
-  funcInitializer: ts.CallExpression,
-  checker: ts.TypeChecker
-): void {
-  const typeArgs = funcInitializer.typeArguments
-  if (typeArgs && typeArgs.length >= 1) {
-    const inputType = checker.getTypeFromTypeNode(typeArgs[0]!)
-    state.typesLookup.set(pikkuFuncId, [inputType])
-    return
-  }
-
-  const configType = checker.getTypeAtLocation(funcInitializer)
-  const funcProp = configType.getProperty('func')
-  if (!funcProp) return
-
-  const funcType = checker.getTypeOfSymbolAtLocation(funcProp, funcInitializer)
-  const sig = getFirstCallSignature(funcType)
-  if (!sig) return
-
-  const params = sig.getParameters()
-  if (params.length >= 2) {
-    const inputType = checker.getTypeOfSymbolAtLocation(
-      params[1]!,
-      funcInitializer
-    )
-    if (!(inputType.flags & ts.TypeFlags.VoidLike)) {
-      state.typesLookup.set(pikkuFuncId, [inputType])
-    }
-  }
-}