@pikku/inspector 0.12.74 → 0.12.81

package/src/utils/extract-node-value.test.ts

@@ -1,117 +0,0 @@
-import { test, describe } from 'node:test'
-import { strict as assert } from 'node:assert'
-import * as ts from 'typescript'
-import { extractDescription, extractStringLiteral } from './extract-node-value'
-
-const createChecker = (source: string) => {
-  const sourceFile = ts.createSourceFile(
-    'test.ts',
-    source,
-    ts.ScriptTarget.Latest,
-    true,
-    ts.ScriptKind.TS
-  )
-  const host = ts.createCompilerHost({})
-  const originalGetSourceFile = host.getSourceFile
-  host.getSourceFile = (fileName, target) => {
-    if (fileName === 'test.ts') return sourceFile
-    return originalGetSourceFile.call(host, fileName, target)
-  }
-  const program = ts.createProgram(['test.ts'], {}, host)
-  return { checker: program.getTypeChecker(), sourceFile }
-}
-
-const findObjectLiteral = (
-  node: ts.Node
-): ts.ObjectLiteralExpression | undefined => {
-  if (ts.isObjectLiteralExpression(node)) return node
-  let result: ts.ObjectLiteralExpression | undefined
-  ts.forEachChild(node, (child) => {
-    if (!result) result = findObjectLiteral(child)
-  })
-  return result
-}
-
-describe('extractDescription', () => {
-  test('returns null when node is undefined', () => {
-    const { checker } = createChecker('')
-    assert.equal(extractDescription(undefined, checker), null)
-  })
-
-  test('extracts string literal description', () => {
-    const { checker, sourceFile } = createChecker(
-      `const opts = { description: 'my step' }`
-    )
-    const obj = findObjectLiteral(sourceFile)!
-    assert.equal(extractDescription(obj, checker), 'my step')
-  })
-
-  test('extracts concatenated string literals in description', () => {
-    const { checker, sourceFile } = createChecker(
-      `const data = { description: 'line one ' + 'line two' }`
-    )
-    const obj = findObjectLiteral(sourceFile)!
-    assert.equal(extractDescription(obj, checker), 'line one line two')
-  })
-
-  test('extracts deeply nested concatenation in description', () => {
-    const { checker, sourceFile } = createChecker(
-      `const data = { description: 'a' + 'b' + 'c' }`
-    )
-    const obj = findObjectLiteral(sourceFile)!
-    assert.equal(extractDescription(obj, checker), 'abc')
-  })
-
-  test('returns null for non-object node', () => {
-    const { checker, sourceFile } = createChecker(`const x = 42`)
-    assert.equal(extractDescription(sourceFile, checker), null)
-  })
-})
-
-describe('extractStringLiteral — concatenation/template symmetry', () => {
-  const findInitializer = (node: ts.Node): ts.Expression | undefined => {
-    if (ts.isVariableDeclaration(node) && node.initializer) {
-      return node.initializer
-    }
-    let result: ts.Expression | undefined
-    ts.forEachChild(node, (child) => {
-      if (!result) result = findInitializer(child)
-    })
-    return result
-  }
-
-  test('a `+` operand that cannot be statically resolved becomes a ${...} placeholder', () => {
-    const { checker, sourceFile } = createChecker(
-      `const x = 'Enrich event ' + (event.id ?? event.name)`
-    )
-    const init = findInitializer(sourceFile)!
-    assert.equal(
-      extractStringLiteral(init, checker),
-      'Enrich event ${event.id ?? event.name}'
-    )
-  })
-
-  test('`+` concatenation and template literal produce the same display string', () => {
-    const concat = createChecker(
-      `const x = 'Enrich event ' + (event.id ?? event.name)`
-    )
-    const template = createChecker(
-      'const x = `Enrich event ${event.id ?? event.name}`'
-    )
-    const concatValue = extractStringLiteral(
-      findInitializer(concat.sourceFile)!,
-      concat.checker
-    )
-    const templateValue = extractStringLiteral(
-      findInitializer(template.sourceFile)!,
-      template.checker
-    )
-    assert.equal(concatValue, templateValue)
-  })
-
-  test('still resolves fully-static concatenation exactly', () => {
-    const { checker, sourceFile } = createChecker(`const x = 'a' + 'b' + 'c'`)
-    const init = findInitializer(sourceFile)!
-    assert.equal(extractStringLiteral(init, checker), 'abc')
-  })
-})

package/src/utils/extract-node-value.ts

@@ -1,172 +0,0 @@
-import * as ts from 'typescript'
-
-/**
- * Extract string literal value from a TypeScript node.
- * Handles string literals, template literals (including placeholders),
- * and constant variable references.
- */
-export function extractStringLiteral(
-  node: ts.Node,
-  checker: ts.TypeChecker
-): string {
-  if (ts.isStringLiteral(node)) {
-    return node.text
-  }
-
-  if (ts.isNoSubstitutionTemplateLiteral(node)) {
-    return node.text
-  }
-
-  if (ts.isTemplateExpression(node)) {
-    // reconstruct: `head + ${expr} + middle + ${expr} + tail`
-    let result = node.head.text
-    for (const span of node.templateSpans) {
-      const exprText = span.expression.getText()
-      result += '${' + exprText + '}' + span.literal.text
-    }
-    return result
-  }
-
-  // Unwrap type assertions: `expr as Type` or `<Type>expr`
-  if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
-    return extractStringLiteral(node.expression, checker)
-  }
-
-  if (
-    ts.isBinaryExpression(node) &&
-    node.operatorToken.kind === ts.SyntaxKind.PlusToken
-  ) {
-    return (
-      extractConcatOperand(node.left, checker) +
-      extractConcatOperand(node.right, checker)
-    )
-  }
-
-  // Try to evaluate constant identifiers
-  if (ts.isIdentifier(node)) {
-    const symbol = checker.getSymbolAtLocation(node)
-    if (
-      symbol?.valueDeclaration &&
-      ts.isVariableDeclaration(symbol.valueDeclaration)
-    ) {
-      const init = symbol.valueDeclaration.initializer
-      if (init) {
-        return extractStringLiteral(init, checker)
-      }
-    }
-  }
-
-  throw new Error('Unable to extract string literal from node')
-}
-
-/**
- * Resolve one operand of a `+` string concatenation.
- *
- * An operand that can't be statically resolved (e.g. `a ?? b`) becomes a
- * `${...}` placeholder rather than throwing — mirroring the TemplateExpression
- * branch above, so `'x ' + expr` and `` `x ${expr}` `` produce the same string.
- * This keeps an unresolvable display name from aborting the whole extraction.
- */
-function extractConcatOperand(node: ts.Node, checker: ts.TypeChecker): string {
-  try {
-    return extractStringLiteral(node, checker)
-  } catch {
-    const inner = ts.isParenthesizedExpression(node) ? node.expression : node
-    return '${' + inner.getText() + '}'
-  }
-}
-
-/**
- * Check if node is string-like (string literal or template expression)
- */
-export function isStringLike(node: ts.Node, checker: ts.TypeChecker): boolean {
-  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-    return true
-  }
-  // Check if it's a template string with substitutions
-  if (ts.isTemplateExpression(node)) {
-    return true
-  }
-  // Unwrap type assertions: `expr as Type` or `<Type>expr`
-  if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
-    return isStringLike(node.expression, checker)
-  }
-  return false
-}
-
-/**
- * Check if node is function-like (arrow, function expression, or function declaration)
- */
-export function isFunctionLike(node: ts.Node): boolean {
-  return (
-    ts.isArrowFunction(node) ||
-    ts.isFunctionExpression(node) ||
-    ts.isFunctionDeclaration(node)
-  )
-}
-
-/**
- * Extract number literal value from a node
- */
-export function extractNumberLiteral(node: ts.Node): number | null {
-  if (ts.isNumericLiteral(node)) {
-    return Number(node.text)
-  }
-  return null
-}
-
-/**
- * Extract a property value from an object literal expression
- * Returns the extracted value or null if not found/cannot extract
- */
-export function extractPropertyString(
-  objNode: ts.ObjectLiteralExpression,
-  propertyName: string,
-  checker: ts.TypeChecker
-): string | null {
-  for (const prop of objNode.properties) {
-    if (
-      ts.isPropertyAssignment(prop) &&
-      ts.isIdentifier(prop.name) &&
-      prop.name.text === propertyName
-    ) {
-      return extractStringLiteral(prop.initializer, checker)
-    }
-  }
-  return null
-}
-
-/**
- * Extract description from options object
- */
-export function extractDescription(
-  optionsNode: ts.Node | undefined,
-  checker: ts.TypeChecker
-): string | null {
-  if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
-    return null
-  }
-  try {
-    return extractPropertyString(optionsNode, 'description', checker)
-  } catch {
-    return null
-  }
-}
-
-/**
- * Extract duration value (number or string)
- */
-export function extractDuration(
-  node: ts.Node,
-  checker: ts.TypeChecker
-): string | number | null {
-  const numValue = extractNumberLiteral(node)
-  if (numValue !== null) {
-    return numValue
-  }
-  try {
-    return extractStringLiteral(node, checker)
-  } catch {
-    return null
-  }
-}

package/src/utils/extract-secret-usage.test.ts

@@ -1,81 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-import ts from 'typescript'
-import { extractSecretUsage } from './extract-secret-usage.js'
-
-const usageOf = (source: string) =>
-  extractSecretUsage(
-    ts.createSourceFile('/services.ts', source, ts.ScriptTarget.ESNext, true)
-  )
-
-describe('extractSecretUsage', () => {
-  test('collects a literal getSecret key', () => {
-    const usage = usageOf(`await secrets.getSecret('STRIPE_KEY')`)
-    assert.deepEqual(usage.keys, ['STRIPE_KEY'])
-    assert.deepEqual(usage.dynamic, [])
-  })
-
-  test('collects hasSecret and template literals with no substitutions', () => {
-    const usage = usageOf(
-      'await secrets.hasSecret(`NOTION_TOKEN`)\nawait secrets.getSecret("A")'
-    )
-    assert.deepEqual(usage.keys, ['A', 'NOTION_TOKEN'])
-  })
-
-  test('collects every key of a getSecrets array', () => {
-    const usage = usageOf(`await secrets.getSecrets(['B', 'A'])`)
-    assert.deepEqual(usage.keys, ['A', 'B'])
-  })
-
-  test('flags a computed key as dynamic', () => {
-    const usage = usageOf(`await secrets.getSecret(name)`)
-    assert.deepEqual(usage.keys, [])
-    assert.equal(usage.dynamic.length, 1)
-    assert.match(usage.dynamic[0]!, /^1:name$/)
-  })
-
-  test('flags a template literal with a substitution as dynamic', () => {
-    const usage = usageOf('await secrets.getSecret(`PREFIX_${suffix}`)')
-    assert.deepEqual(usage.keys, [])
-    assert.equal(usage.dynamic.length, 1)
-  })
-
-  test('flags a non-array getSecrets argument as dynamic', () => {
-    const usage = usageOf(`await secrets.getSecrets(keys)`)
-    assert.equal(usage.dynamic.length, 1)
-  })
-
-  test('records both the literal and the dynamic keys of one call', () => {
-    const usage = usageOf(`await secrets.getSecrets(['A', other])`)
-    assert.deepEqual(usage.keys, ['A'])
-    assert.equal(usage.dynamic.length, 1)
-  })
-
-  test('finds reads nested inside a factory body', () => {
-    const usage = usageOf(`
-      export const createSingletonServices = async ({ secrets }) => {
-        const key = await secrets.getSecret('DEEP_KEY')
-        return { thing: new Thing(key) }
-      }
-    `)
-    assert.deepEqual(usage.keys, ['DEEP_KEY'])
-  })
-
-  test('deduplicates a key read twice', () => {
-    const usage = usageOf(
-      `await secrets.getSecret('A'); await secrets.getSecret('A')`
-    )
-    assert.deepEqual(usage.keys, ['A'])
-  })
-
-  test('ignores unrelated calls', () => {
-    const usage = usageOf(`await variables.get('HOME'); logger.info('hi')`)
-    assert.deepEqual(usage.keys, [])
-    assert.deepEqual(usage.dynamic, [])
-  })
-
-  test('reports the line a dynamic read is on', () => {
-    const usage = usageOf(`const a = 1\nconst b = 2\nsecrets.getSecret(name)`)
-    assert.match(usage.dynamic[0]!, /^3:/)
-  })
-})

package/src/utils/extract-secret-usage.ts

@@ -1,73 +0,0 @@
-import ts from 'typescript'
-
-export type SecretUsage = {
-  /** Secret ids read with a string literal, so statically known. */
-  keys: string[]
-  /** Reads whose key could not be resolved statically, as `line:source`. */
-  dynamic: string[]
-}
-
-const SINGLE_KEY_METHODS = new Set(['getSecret', 'hasSecret'])
-const KEY_LIST_METHODS = new Set(['getSecrets'])
-
-const literalKey = (node: ts.Expression): string | undefined => {
-  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-    return node.text
-  }
-  return undefined
-}
-
-/** Secret reads in a file, whether the key is statically known or not. */
-export const extractSecretUsage = (sourceFile: ts.SourceFile): SecretUsage => {
-  const keys = new Set<string>()
-  const dynamic = new Set<string>()
-
-  const record = (node: ts.CallExpression, argument?: ts.Expression) => {
-    const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart())
-    dynamic.add(`${line + 1}:${(argument ?? node).getText()}`)
-  }
-
-  const visit = (node: ts.Node): void => {
-    if (
-      ts.isCallExpression(node) &&
-      ts.isPropertyAccessExpression(node.expression)
-    ) {
-      const method = node.expression.name.text
-      const [firstArgument] = node.arguments
-
-      if (SINGLE_KEY_METHODS.has(method)) {
-        if (!firstArgument) {
-          record(node)
-        } else {
-          const key = literalKey(firstArgument)
-          if (key === undefined) {
-            record(node, firstArgument)
-          } else {
-            keys.add(key)
-          }
-        }
-      } else if (KEY_LIST_METHODS.has(method)) {
-        if (firstArgument && ts.isArrayLiteralExpression(firstArgument)) {
-          for (const element of firstArgument.elements) {
-            const key = literalKey(element)
-            if (key === undefined) {
-              record(node, element)
-            } else {
-              keys.add(key)
-            }
-          }
-        } else {
-          record(node, firstArgument)
-        }
-      }
-    }
-    ts.forEachChild(node, visit)
-  }
-
-  visit(sourceFile)
-
-  return {
-    keys: [...keys].sort(),
-    dynamic: [...dynamic].sort(),
-  }
-}

package/src/utils/extract-services.ts

@@ -1,70 +0,0 @@
-import * as ts from 'typescript'
-import type {
-  FunctionServicesMeta,
-  FunctionWiresMeta,
-} from '@pikku/core/function'
-/**
- * Extract services from a function's first parameter destructuring pattern
- */
-export function extractServicesFromFunction(
-  handlerNode: ts.FunctionExpression | ts.ArrowFunction
-): FunctionServicesMeta {
-  const services: FunctionServicesMeta = {
-    optimized: true,
-    services: [],
-  }
-
-  const firstParam = handlerNode.parameters[0]
-  if (firstParam) {
-    if (ts.isObjectBindingPattern(firstParam.name)) {
-      for (const elem of firstParam.name.elements) {
-        const original =
-          elem.propertyName && ts.isIdentifier(elem.propertyName)
-            ? elem.propertyName.text
-            : ts.isIdentifier(elem.name)
-              ? elem.name.text
-              : undefined
-        if (original) {
-          services.services.push(original)
-        }
-      }
-    } else if (
-      ts.isIdentifier(firstParam.name) &&
-      !firstParam.name.text.startsWith('_')
-    ) {
-      services.optimized = false
-    }
-  }
-
-  return services
-}
-
-export function extractUsedWires(
-  handlerNode: ts.FunctionExpression | ts.ArrowFunction,
-  paramIndex: number
-): FunctionWiresMeta {
-  const param = handlerNode.parameters[paramIndex]
-  if (param && ts.isObjectBindingPattern(param.name)) {
-    const wires: string[] = []
-    for (const elem of param.name.elements) {
-      const propertyName =
-        elem.propertyName && ts.isIdentifier(elem.propertyName)
-          ? elem.propertyName.text
-          : ts.isIdentifier(elem.name)
-            ? elem.name.text
-            : undefined
-      if (propertyName) {
-        wires.push(propertyName)
-      }
-    }
-    return { optimized: true, wires }
-  }
-  if (
-    param &&
-    ts.isIdentifier(param.name) &&
-    !param.name.text.startsWith('_')
-  ) {
-    return { optimized: false, wires: [] }
-  }
-  return { optimized: true, wires: [] }
-}

package/src/utils/extract-surface-usage.test.ts

@@ -1,147 +0,0 @@
-import assert from 'node:assert'
-import { describe, test } from 'node:test'
-import ts from 'typescript'
-
-import {
-  accumulateSurfaceUsage,
-  surfaceUsageArea,
-  type SurfaceUsageCounts,
-} from './extract-surface-usage.js'
-
-const countsFor = (
-  files: Array<{ area: string; source: string }>
-): SurfaceUsageCounts => {
-  const counts: SurfaceUsageCounts = {}
-  files.forEach(({ area, source }, index) => {
-    const file = `src/file-${index}.ts`
-    accumulateSurfaceUsage(
-      ts.createSourceFile(
-        `/project/${file}`,
-        source,
-        ts.ScriptTarget.Latest,
-        true
-      ),
-      { area, file },
-      counts
-    )
-  })
-  return counts
-}
-
-describe('accumulateSurfaceUsage', () => {
-  test('counts an import site per named import', () => {
-    const counts = countsFor([
-      {
-        area: 'src',
-        source:
-          "import { pikkuFunc, pikkuSessionlessFunc } from '#pikku/function'\n",
-      },
-      { area: 'src', source: "import { pikkuFunc } from '#pikku/function'\n" },
-    ])
-
-    assert.deepStrictEqual(counts['#pikku/function'], {
-      pikkuFunc: {
-        imports: 2,
-        seenIn: ['src'],
-        files: ['src/file-0.ts', 'src/file-1.ts'],
-      },
-      pikkuSessionlessFunc: {
-        imports: 1,
-        seenIn: ['src'],
-        files: ['src/file-0.ts'],
-      },
-    })
-  })
-
-  test('counts a deep specifier against the leaf it belongs to', () => {
-    const counts = countsFor([
-      {
-        area: 'src',
-        source:
-          "import { pikkuWorkflowFunc } from '#pikku/workflow/pikku-workflow-types.gen.js'\n",
-      },
-      {
-        area: 'workers',
-        source: "import { pikkuWorkflowFunc } from '#pikku/workflow'\n",
-      },
-    ])
-
-    assert.deepStrictEqual(counts['#pikku/workflow'], {
-      pikkuWorkflowFunc: {
-        imports: 2,
-        seenIn: ['src', 'workers'],
-        files: ['src/file-0.ts', 'src/file-1.ts'],
-      },
-    })
-  })
-
-  test('records the aliased name, not the local one', () => {
-    const counts = countsFor([
-      {
-        area: 'src',
-        source: "import { cors as allowAll } from '#pikku/http'\n",
-      },
-    ])
-
-    assert.deepStrictEqual(counts['#pikku/http'], {
-      cors: { imports: 1, seenIn: ['src'], files: ['src/file-0.ts'] },
-    })
-  })
-
-  test('counts a re-export as a use of the leaf', () => {
-    const counts = countsFor([
-      { area: 'src', source: "export { wireHTTP } from '#pikku/http'\n" },
-    ])
-
-    assert.deepStrictEqual(counts['#pikku/http']!.wireHTTP!.imports, 1)
-  })
-
-  test('ignores imports from anywhere else', () => {
-    const counts = countsFor([
-      {
-        area: 'src',
-        source: [
-          "import { z } from 'zod'",
-          "import { thing } from './local.js'",
-          "import * as everything from '#pikku/function'",
-          "import bootstrap from '#pikku/pikku-bootstrap.gen.js'",
-        ].join('\n'),
-      },
-    ])
-
-    assert.deepStrictEqual(counts, {})
-  })
-})
-
-describe('surfaceUsageArea', () => {
-  test('falls back to the top-level source directory in a single package', () => {
-    assert.strictEqual(
-      surfaceUsageArea('/project/src/wirings/todo.ts', '/project', new Map()),
-      'src'
-    )
-  })
-
-  test('does not label everything with the root package name', () => {
-    const cache = new Map<string, string | null>([
-      ['/project/src/wirings', null],
-      ['/project/src', null],
-    ])
-
-    assert.strictEqual(
-      surfaceUsageArea('/project/src/wirings/todo.ts', '/project', cache),
-      'src'
-    )
-  })
-
-  test('prefers the workspace package a file belongs to', () => {
-    const cache = new Map<string, string | null>([
-      ['/project/packages/api/src', null],
-      ['/project/packages/api', '@app/api'],
-    ])
-
-    assert.strictEqual(
-      surfaceUsageArea('/project/packages/api/src/todo.ts', '/project', cache),
-      '@app/api'
-    )
-  })
-})