@pikku/inspector 0.12.75 → 0.12.82

package/src/add/add-trigger.ts

@@ -1,165 +0,0 @@
-import * as ts from 'typescript'
-import {
-  getPropertyValue,
-  getCommonWireMetaData,
-} from '../utils/get-property-value.js'
-import type { AddWiring } from '../types.js'
-import {
-  extractFunctionName,
-  makeContextBasedId,
-} from '../utils/extract-function-name.js'
-import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
-import { ensureInlineWiringFunction } from '../utils/ensure-function-metadata.js'
-import { resolveMiddleware } from '../utils/middleware.js'
-import { extractWireNames } from '../utils/post-process.js'
-import { resolveAddonName } from '../utils/resolve-addon-package.js'
-
-import { ErrorCode } from '../error-codes.js'
-export const addTrigger: AddWiring = (
-  logger,
-  node,
-  checker,
-  state,
-  options
-) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
-
-  if (!ts.isIdentifier(expression)) {
-    return
-  }
-
-  if (expression.text === 'wireTrigger') {
-    addWireTrigger(logger, node, checker, state, firstArg)
-  } else if (expression.text === 'wireTriggerSource') {
-    addWireTriggerSource(logger, node, checker, state, options, firstArg)
-  }
-}
-
-const addWireTrigger: (
-  logger: Parameters<AddWiring>[0],
-  node: ts.CallExpression,
-  checker: Parameters<AddWiring>[2],
-  state: Parameters<AddWiring>[3],
-  firstArg: ts.Expression | undefined
-) => void = (logger, node, checker, state, firstArg) => {
-  if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) {
-    return
-  }
-
-  const obj = firstArg
-
-  const nameValue = getPropertyValue(obj, 'name') as string | null
-  const { disabled, tags, summary, description, errors } =
-    getCommonWireMetaData(obj, 'Trigger', nameValue, logger, checker)
-
-  if (disabled) return
-
-  const funcInitializer = getPropertyAssignmentInitializer(
-    obj,
-    'func',
-    true,
-    checker
-  )
-  if (!funcInitializer) {
-    logger.critical(
-      ErrorCode.MISSING_FUNC,
-      `No valid 'func' property for trigger '${nameValue}'.`
-    )
-    return
-  }
-
-  const extracted = extractFunctionName(funcInitializer, checker, state.rootDir)
-  let pikkuFuncId = extracted.pikkuFuncId
-  if (pikkuFuncId.startsWith('__temp_') && nameValue) {
-    pikkuFuncId = makeContextBasedId('trigger', nameValue)
-  }
-
-  if (!nameValue) {
-    return
-  }
-
-  // Register metadata for a func inlined into the wiring (see helper).
-  ensureInlineWiringFunction(
-    state,
-    pikkuFuncId,
-    nameValue,
-    funcInitializer,
-    checker,
-    extracted.isHelper
-  )
-
-  // --- resolve middleware ---
-  const middleware = resolveMiddleware(state, obj, tags, checker)
-
-  // --- track used functions/middleware for service aggregation ---
-  state.serviceAggregation.usedFunctions.add(pikkuFuncId)
-  extractWireNames(middleware).forEach((name) =>
-    state.serviceAggregation.usedMiddleware.add(name)
-  )
-
-  state.triggers.files.add(node.getSourceFile().fileName)
-  state.triggers.meta[nameValue] = {
-    pikkuFuncId,
-    name: nameValue,
-    summary,
-    description,
-    errors,
-    tags,
-    middleware,
-  }
-}
-
-const addWireTriggerSource: (
-  logger: Parameters<AddWiring>[0],
-  node: ts.CallExpression,
-  checker: Parameters<AddWiring>[2],
-  state: Parameters<AddWiring>[3],
-  options: Parameters<AddWiring>[4],
-  firstArg: ts.Expression | undefined
-) => void = (logger, node, checker, state, options, firstArg) => {
-  if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) {
-    return
-  }
-
-  const obj = firstArg
-
-  const nameValue = getPropertyValue(obj, 'name') as string | null
-  if (!nameValue) {
-    return
-  }
-
-  const funcInitializer = getPropertyAssignmentInitializer(
-    obj,
-    'func',
-    true,
-    checker
-  )
-  if (!funcInitializer) {
-    logger.critical(
-      ErrorCode.MISSING_FUNC,
-      `No valid 'func' property for trigger source '${nameValue}'.`
-    )
-    return
-  }
-
-  if (ts.isIdentifier(funcInitializer)) {
-    const packageName = resolveAddonName(
-      funcInitializer,
-      checker,
-      state.rpc.wireAddonDeclarations
-    )
-    state.triggers.sourceMeta[nameValue] = {
-      name: nameValue,
-      pikkuFuncId: funcInitializer.text,
-      packageName: packageName || undefined,
-    }
-  }
-
-  state.triggers.files.add(node.getSourceFile().fileName)
-}

package/src/add/add-variable.ts

@@ -1,10 +0,0 @@
-import { createAddKeyedWiring } from './add-keyed-wiring.js'
-
-export const addVariable = createAddKeyedWiring({
-  functionName: 'defineVariable',
-  idField: 'variableId',
-  label: 'Variable',
-  schemaPrefix: 'VariableSchema',
-  flagField: 'optional',
-  getState: (state) => state.variables,
-})

package/src/add/add-wire-addon.test.ts

@@ -1,185 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, test, beforeEach } from 'node:test'
-import * as ts from 'typescript'
-import { addWireAddon } from './add-wire-addon.js'
-
-let state: any
-
-const logger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-} as any
-
-/** Parses a source snippet and runs addWireAddon over every call expression. */
-const inspect = (source: string) => {
-  const file = ts.createSourceFile(
-    'wiring.ts',
-    source,
-    ts.ScriptTarget.Latest,
-    true
-  )
-  const visit = (node: ts.Node) => {
-    addWireAddon(node, state, logger)
-    ts.forEachChild(node, visit)
-  }
-  visit(file)
-  return state.rpc.wireAddonDeclarations
-}
-
-beforeEach(() => {
-  state = {
-    rpc: {
-      wireAddonDeclarations: new Map(),
-      usedAddons: new Set(),
-      wireAddonFiles: new Set(),
-    },
-  }
-})
-
-describe('addWireAddon', () => {
-  test('captures the addon gates alongside its plumbing', () => {
-    const declarations = inspect(`
-      wireAddon({
-        name: 'console',
-        package: '@pikku/addon-console',
-        rpcEndpoint: '/rpc',
-        auth: true,
-        tags: ['admin', 'internal'],
-        scopes: ['admin'],
-      })
-    `)
-
-    assert.deepEqual(declarations.get('console'), {
-      package: '@pikku/addon-console',
-      rpcEndpoint: '/rpc',
-      mcp: undefined,
-      auth: true,
-      tags: ['admin', 'internal'],
-      scopes: ['admin'],
-      secretOverrides: undefined,
-      variableOverrides: undefined,
-      credentialOverrides: undefined,
-      secretGrants: undefined,
-      credentialGrants: undefined,
-      globalSecrets: undefined,
-      globalCredentials: undefined,
-    })
-  })
-
-  test('captures the secrets and credentials the host lends an addon', () => {
-    const declarations = inspect(`
-      wireAddon({
-        name: 'graph',
-        package: '@pikku/addon-graph',
-        secretGrants: ['STRIPE_KEY', 'GITHUB_TOKEN'],
-        credentialGrants: ['slack'],
-      })
-    `)
-
-    assert.deepEqual(declarations.get('graph').secretGrants, [
-      'STRIPE_KEY',
-      'GITHUB_TOKEN',
-    ])
-    assert.deepEqual(declarations.get('graph').credentialGrants, ['slack'])
-  })
-
-  test('drops a grant list that is not statically knowable', () => {
-    const declarations = inspect(`
-      wireAddon({
-        name: 'graph',
-        package: '@pikku/addon-graph',
-        secretGrants: someRuntimeList,
-      })
-    `)
-
-    assert.equal(declarations.get('graph').secretGrants, undefined)
-  })
-
-  test('captures the reason an addon was exempted from credential scoping', () => {
-    const declarations = inspect(`
-      wireAddon({
-        name: 'console',
-        package: '@pikku/addon-console',
-        globalCredentials: 'links credentials an operator names at runtime',
-      })
-    `)
-
-    assert.equal(
-      declarations.get('console').globalCredentials,
-      'links credentials an operator names at runtime'
-    )
-  })
-
-  test('captures the reason an addon was exempted from secret scoping', () => {
-    const declarations = inspect(`
-      wireAddon({
-        name: 'console',
-        package: '@pikku/addon-console',
-        globalSecrets: 'administers secrets an operator names at runtime',
-      })
-    `)
-
-    assert.equal(
-      declarations.get('console').globalSecrets,
-      'administers secrets an operator names at runtime'
-    )
-  })
-
-  test('a globalSecrets reason that is not a literal still reports the grant', () => {
-    // Unlike `scopes`, dropping this would under-report: the grant is real at
-    // runtime whatever the reason evaluates to. The source text is recorded so
-    // the manifest names the addon and points at where the reason comes from.
-    const declarations = inspect(`
-      wireAddon({ name: 'console', package: '@x/y', globalSecrets: REASON })
-    `)
-
-    assert.equal(declarations.get('console').globalSecrets, 'REASON')
-  })
-
-  test('leaves the gates undefined when none are declared', () => {
-    const declarations = inspect(`
-      wireAddon({ name: 'console', package: '@pikku/addon-console' })
-    `)
-
-    const declaration = declarations.get('console')
-    assert.equal(declaration.auth, undefined)
-    assert.equal(declaration.tags, undefined)
-    assert.equal(declaration.scopes, undefined)
-  })
-
-  test('records auth: false rather than dropping it', () => {
-    const declarations = inspect(`
-      wireAddon({ name: 'console', package: '@x/y', auth: false })
-    `)
-
-    assert.equal(declarations.get('console').auth, false)
-  })
-
-  test('drops a scopes array that is not statically knowable', () => {
-    // A partial list would read as the complete set of gates, so an array with
-    // any non-literal entry is reported as unknown instead.
-    const declarations = inspect(`
-      wireAddon({ name: 'console', package: '@x/y', scopes: ['admin', ...EXTRA] })
-    `)
-
-    assert.equal(declarations.get('console').scopes, undefined)
-  })
-
-  test('drops a scopes value that is a reference rather than an array', () => {
-    const declarations = inspect(`
-      wireAddon({ name: 'console', package: '@x/y', scopes: ADMIN_SCOPES })
-    `)
-
-    assert.equal(declarations.get('console').scopes, undefined)
-  })
-
-  test('keeps an explicitly empty scopes array distinct from an absent one', () => {
-    const declarations = inspect(`
-      wireAddon({ name: 'console', package: '@x/y', scopes: [] })
-    `)
-
-    assert.deepEqual(declarations.get('console').scopes, [])
-  })
-})

package/src/add/add-wire-addon.ts

@@ -1,146 +0,0 @@
-import * as ts from 'typescript'
-import type { InspectorState, InspectorLogger } from '../types.js'
-
-function parseStringArray(node: ts.Expression): string[] | undefined {
-  if (!ts.isArrayLiteralExpression(node)) return undefined
-  const values: string[] = []
-  for (const element of node.elements) {
-    // A non-literal entry (a spread, a const reference) is not statically
-    // knowable. Dropping the whole array rather than a silent partial keeps a
-    // consumer from reading a short list as the complete set of gates.
-    if (!ts.isStringLiteral(element)) return undefined
-    values.push(element.text)
-  }
-  return values
-}
-
-function parseStringRecord(
-  obj: ts.ObjectLiteralExpression
-): Record<string, string> {
-  const result: Record<string, string> = {}
-  for (const prop of obj.properties) {
-    if (!ts.isPropertyAssignment(prop)) continue
-    const keyNode = prop.name
-    const key = ts.isIdentifier(keyNode)
-      ? keyNode.text
-      : ts.isStringLiteral(keyNode)
-        ? keyNode.text
-        : undefined
-    if (key && ts.isStringLiteral(prop.initializer)) {
-      result[key] = prop.initializer.text
-    }
-  }
-  return result
-}
-
-/**
- * Detect wireAddon({ name: '...', package: '...' }) call expressions and
- * populate state.rpc.wireAddonDeclarations and state.rpc.usedAddons.
- */
-export function addWireAddon(
-  node: ts.Node,
-  state: InspectorState,
-  logger: InspectorLogger
-) {
-  if (!ts.isCallExpression(node)) return
-
-  const { expression, arguments: args } = node
-  if (!ts.isIdentifier(expression) || expression.text !== 'wireAddon') return
-
-  const [firstArg] = args
-  if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) return
-
-  let name: string | undefined
-  let pkg: string | undefined
-  let rpcEndpoint: string | undefined
-  let mcp: boolean | undefined
-  let auth: boolean | undefined
-  let tags: string[] | undefined
-  let scopes: string[] | undefined
-  let secretOverrides: Record<string, string> | undefined
-  let variableOverrides: Record<string, string> | undefined
-  let credentialOverrides: Record<string, string> | undefined
-  let secretGrants: string[] | undefined
-  let credentialGrants: string[] | undefined
-  let globalSecrets: string | undefined
-  let globalCredentials: string | undefined
-
-  for (const prop of firstArg.properties) {
-    if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue
-
-    const key = prop.name.text
-    if (key === 'name' && ts.isStringLiteral(prop.initializer)) {
-      name = prop.initializer.text
-    } else if (key === 'package' && ts.isStringLiteral(prop.initializer)) {
-      pkg = prop.initializer.text
-    } else if (key === 'rpcEndpoint' && ts.isStringLiteral(prop.initializer)) {
-      rpcEndpoint = prop.initializer.text
-    } else if (
-      key === 'mcp' &&
-      (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
-        prop.initializer.kind === ts.SyntaxKind.FalseKeyword)
-    ) {
-      mcp = prop.initializer.kind === ts.SyntaxKind.TrueKeyword
-    } else if (
-      key === 'auth' &&
-      (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
-        prop.initializer.kind === ts.SyntaxKind.FalseKeyword)
-    ) {
-      auth = prop.initializer.kind === ts.SyntaxKind.TrueKeyword
-    } else if (key === 'tags') {
-      tags = parseStringArray(prop.initializer)
-    } else if (key === 'scopes') {
-      scopes = parseStringArray(prop.initializer)
-    } else if (
-      key === 'secretOverrides' &&
-      ts.isObjectLiteralExpression(prop.initializer)
-    ) {
-      secretOverrides = parseStringRecord(prop.initializer)
-    } else if (
-      key === 'variableOverrides' &&
-      ts.isObjectLiteralExpression(prop.initializer)
-    ) {
-      variableOverrides = parseStringRecord(prop.initializer)
-    } else if (
-      key === 'credentialOverrides' &&
-      ts.isObjectLiteralExpression(prop.initializer)
-    ) {
-      credentialOverrides = parseStringRecord(prop.initializer)
-    } else if (key === 'secretGrants') {
-      secretGrants = parseStringArray(prop.initializer)
-    } else if (key === 'credentialGrants') {
-      credentialGrants = parseStringArray(prop.initializer)
-    } else if (key === 'globalSecrets') {
-      // The grant is real at runtime whatever the reason evaluates to, so a
-      // non-literal is recorded as its source text rather than dropped.
-      globalSecrets = ts.isStringLiteral(prop.initializer)
-        ? prop.initializer.text
-        : prop.initializer.getText()
-    } else if (key === 'globalCredentials') {
-      globalCredentials = ts.isStringLiteral(prop.initializer)
-        ? prop.initializer.text
-        : prop.initializer.getText()
-    }
-  }
-
-  if (!name || !pkg) return
-
-  logger.debug(`• Found wireAddon: ${name} → ${pkg}`)
-  state.rpc.wireAddonDeclarations.set(name, {
-    package: pkg,
-    rpcEndpoint,
-    mcp,
-    auth,
-    tags,
-    scopes,
-    secretOverrides,
-    variableOverrides,
-    credentialOverrides,
-    secretGrants,
-    credentialGrants,
-    globalSecrets,
-    globalCredentials,
-  })
-  state.rpc.usedAddons.add(name)
-  state.rpc.wireAddonFiles.add(node.getSourceFile().fileName)
-}

package/src/add/add-wire-remote-addon.ts

@@ -1,80 +0,0 @@
-import * as ts from 'typescript'
-import type { InspectorState, InspectorLogger } from '../types.js'
-
-/**
- * Detect wireRemoteAddon({ name: '...', package: '...' }) call expressions and
- * record the namespace as a **remote** addon declaration. Only name + package
- * are needed for codegen (serverUrl/auth are runtime closures resolved by the
- * RPC runner); the `remote` marker tells the consumer's RPC-map generator to
- * import the addon's `.remote.gen` map instead of `.internal.gen`.
- */
-export function addWireRemoteAddon(
-  node: ts.Node,
-  state: InspectorState,
-  logger: InspectorLogger
-) {
-  if (!ts.isCallExpression(node)) return
-
-  const { expression, arguments: args } = node
-  if (!ts.isIdentifier(expression) || expression.text !== 'wireRemoteAddon')
-    return
-
-  const [firstArg] = args
-  if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) return
-
-  let name: string | undefined
-  let pkg: string | undefined
-  // The auth binding is a runtime closure; we only extract the statically
-  // knowable slot names so `pikku verify` can check they exist in the
-  // consumer's own wirings. `hasAuth` distinguishes "public" (omitted) from
-  // "bound via a custom resolve()" (present but no static id).
-  let hasAuth = false
-  let authCredentialId: string | undefined
-  let authSecretId: string | undefined
-
-  for (const prop of firstArg.properties) {
-    if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue
-    const key = prop.name.text
-    if (key === 'name' && ts.isStringLiteral(prop.initializer)) {
-      name = prop.initializer.text
-    } else if (key === 'package' && ts.isStringLiteral(prop.initializer)) {
-      pkg = prop.initializer.text
-    } else if (
-      key === 'auth' &&
-      ts.isObjectLiteralExpression(prop.initializer)
-    ) {
-      hasAuth = true
-      for (const authProp of prop.initializer.properties) {
-        if (
-          !ts.isPropertyAssignment(authProp) ||
-          !ts.isIdentifier(authProp.name)
-        )
-          continue
-        if (
-          authProp.name.text === 'credentialId' &&
-          ts.isStringLiteral(authProp.initializer)
-        ) {
-          authCredentialId = authProp.initializer.text
-        } else if (
-          authProp.name.text === 'secretId' &&
-          ts.isStringLiteral(authProp.initializer)
-        ) {
-          authSecretId = authProp.initializer.text
-        }
-      }
-    }
-  }
-
-  if (!name || !pkg) return
-
-  logger.debug(`• Found wireRemoteAddon: ${name} → ${pkg} (remote)`)
-  state.rpc.wireAddonDeclarations.set(name, {
-    package: pkg,
-    remote: true,
-    hasAuth,
-    authCredentialId,
-    authSecretId,
-  })
-  state.rpc.usedAddons.add(name)
-  state.rpc.wireAddonFiles.add(node.getSourceFile().fileName)
-}