@pikku/inspector 0.12.75 → 0.12.81

package/src/utils/get-property-value.test.ts

@@ -1,141 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert'
-import * as ts from 'typescript'
-import {
-  getArrayPropertyValue,
-  getRecordPropertyValue,
-} from './get-property-value.js'
-
-/**
- * Parses `const x = { ... }` and hands back the object literal.
- */
-const objectLiteral = (source: string): ts.ObjectLiteralExpression => {
-  const file = ts.createSourceFile(
-    'test.ts',
-    `const x = ${source}`,
-    ts.ScriptTarget.Latest,
-    true
-  )
-  const statement = file.statements[0] as ts.VariableStatement
-  const initializer = statement.declarationList.declarations[0]!.initializer
-  if (!initializer || !ts.isObjectLiteralExpression(initializer)) {
-    throw new Error('expected an object literal')
-  }
-  return initializer
-}
-
-const firstObjectLiteral = (src: string): ts.ObjectLiteralExpression => {
-  const sourceFile = ts.createSourceFile(
-    'test.ts',
-    src,
-    ts.ScriptTarget.Latest,
-    true
-  )
-  let found: ts.ObjectLiteralExpression | undefined
-  const walk = (node: ts.Node) => {
-    if (!found && ts.isObjectLiteralExpression(node)) {
-      found = node
-    }
-    ts.forEachChild(node, walk)
-  }
-  walk(sourceFile)
-  if (!found) {
-    throw new Error('no object literal in source')
-  }
-  return found
-}
-
-describe('getArrayPropertyValue', () => {
-  test('reads a plain array literal', () => {
-    const obj = objectLiteral(`{ tags: ['a', 'b'] }`)
-    assert.deepEqual(getArrayPropertyValue(obj, 'tags'), ['a', 'b'])
-  })
-
-  test('returns null when the property is absent', () => {
-    const obj = objectLiteral(`{ other: ['a'] }`)
-    assert.equal(getArrayPropertyValue(obj, 'tags'), null)
-  })
-
-  test('reads an array widened with `as const`', () => {
-    const obj = objectLiteral(`{ tags: ['a', 'b'] as const }`)
-    assert.deepEqual(
-      getArrayPropertyValue(obj, 'tags'),
-      ['a', 'b'],
-      '`as const` on an array is idiomatic and must not drop the value'
-    )
-  })
-
-  test('reads an array cast with `as any`', () => {
-    const obj = objectLiteral(`{ tags: ['a'] as any }`)
-    assert.deepEqual(
-      getArrayPropertyValue(obj, 'tags'),
-      ['a'],
-      'a cast must not let a value escape static validation'
-    )
-  })
-
-  test('reads an array through `satisfies`', () => {
-    const obj = objectLiteral(`{ tags: ['a'] satisfies string[] }`)
-    assert.deepEqual(getArrayPropertyValue(obj, 'tags'), ['a'])
-  })
-
-  test('reads an array through nested casts', () => {
-    const obj = objectLiteral(`{ tags: ['a'] as const as any }`)
-    assert.deepEqual(getArrayPropertyValue(obj, 'tags'), ['a'])
-  })
-
-  test('ignores non-string elements', () => {
-    const obj = objectLiteral(`{ tags: ['a', 1, foo] }`)
-    assert.deepEqual(getArrayPropertyValue(obj, 'tags'), ['a'])
-  })
-
-  test('returns null for a non-array initializer', () => {
-    const obj = objectLiteral(`{ tags: 'a' }`)
-    assert.equal(getArrayPropertyValue(obj, 'tags'), null)
-  })
-})
-
-describe('getRecordPropertyValue', () => {
-  test('extracts a string record', () => {
-    const obj = firstObjectLiteral(
-      `const x = { additionalParams: { access_type: 'offline', prompt: 'consent' } }`
-    )
-    assert.deepStrictEqual(getRecordPropertyValue(obj, 'additionalParams'), {
-      access_type: 'offline',
-      prompt: 'consent',
-    })
-  })
-
-  test('handles quoted keys', () => {
-    const obj = firstObjectLiteral(
-      `const x = { additionalParams: { 'token_access_type': 'offline' } }`
-    )
-    assert.deepStrictEqual(getRecordPropertyValue(obj, 'additionalParams'), {
-      token_access_type: 'offline',
-    })
-  })
-
-  test('returns null when the property is absent', () => {
-    const obj = firstObjectLiteral(`const x = { scopes: ['a'] }`)
-    assert.strictEqual(getRecordPropertyValue(obj, 'additionalParams'), null)
-  })
-
-  test('returns null for a non-literal initializer', () => {
-    const obj = firstObjectLiteral(`const x = { additionalParams: SOME_CONST }`)
-    assert.strictEqual(getRecordPropertyValue(obj, 'additionalParams'), null)
-  })
-
-  test('skips non-string values rather than coercing them', () => {
-    const obj = firstObjectLiteral(
-      `const x = { additionalParams: { a: 'keep', b: 42, c: true } }`
-    )
-    assert.deepStrictEqual(getRecordPropertyValue(obj, 'additionalParams'), {
-      a: 'keep',
-    })
-  })
-
-  test('returns null for an empty record', () => {
-    const obj = firstObjectLiteral(`const x = { additionalParams: {} }`)
-    assert.strictEqual(getRecordPropertyValue(obj, 'additionalParams'), null)
-  })
-})

package/src/utils/get-property-value.ts

@@ -1,331 +0,0 @@
-import * as ts from 'typescript'
-import { ErrorCode } from '../error-codes.js'
-import { extractStringLiteral } from './extract-node-value.js'
-
-/**
- * Extracts an array of strings from an object property.
- */
-/**
- * Unwraps `x as const` / `x as any` / `x satisfies T` down to the underlying
- * expression. Without this a cast makes the value invisible to the inspector,
- * so it is silently dropped from meta rather than validated — and `as const` on
- * an array is idiomatic enough that this is easy to hit by accident.
- */
-const unwrapAs = (node: ts.Expression): ts.Expression =>
-  ts.isAsExpression(node) || ts.isSatisfiesExpression(node)
-    ? unwrapAs(node.expression)
-    : node
-
-export const getArrayPropertyValue = (
-  obj: ts.ObjectLiteralExpression,
-  propertyName: string
-): string[] | null => {
-  const property = obj.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === propertyName
-  )
-
-  if (property && ts.isPropertyAssignment(property)) {
-    const initializer = unwrapAs(property.initializer)
-    if (ts.isArrayLiteralExpression(initializer)) {
-      return initializer.elements
-        .filter(ts.isStringLiteral)
-        .map((element) => element.text)
-    }
-  }
-
-  return null
-}
-
-/**
- * Extracts a string->string record from an object property.
- *
- * `getPropertyValue` falls through to `getText()` for an object literal, which
- * returns the raw source text rather than the record — so callers that need the
- * entries (e.g. oauth2 `additionalParams`) must use this instead.
- */
-export const getRecordPropertyValue = (
-  obj: ts.ObjectLiteralExpression,
-  propertyName: string
-): Record<string, string> | null => {
-  const property = obj.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === propertyName
-  )
-
-  if (!property || !ts.isPropertyAssignment(property)) {
-    return null
-  }
-  const initializer = property.initializer
-  if (!ts.isObjectLiteralExpression(initializer)) {
-    return null
-  }
-
-  const record: Record<string, string> = {}
-  for (const prop of initializer.properties) {
-    if (!ts.isPropertyAssignment(prop)) {
-      continue
-    }
-    const key = ts.isIdentifier(prop.name)
-      ? prop.name.text
-      : ts.isStringLiteral(prop.name)
-        ? prop.name.text
-        : null
-    if (key === null) {
-      continue
-    }
-    if (
-      ts.isStringLiteral(prop.initializer) ||
-      ts.isNoSubstitutionTemplateLiteral(prop.initializer)
-    ) {
-      record[key] = prop.initializer.text
-    }
-  }
-
-  return Object.keys(record).length > 0 ? record : null
-}
-
-/**
- * Wiring identity fields (`name`, `secretId`, `variableId`, …) are read
- * STATICALLY from source — a const or variable reference is keyed by its
- * identifier text, not its runtime value, so the wiring is silently skipped at
- * runtime (`metadata not found`). If the named property exists but is not an
- * inline literal, raise a fatal diagnostic so the build fails instead.
- */
-export const assertStringLiteralProperty = (
-  obj: ts.ObjectLiteralExpression,
-  propertyName: string,
-  wiringType: string,
-  logger?: { critical: (code: ErrorCode, message: string) => void }
-): void => {
-  const property = obj.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === propertyName
-  )
-  if (!property || !ts.isPropertyAssignment(property)) {
-    return
-  }
-  const init = property.initializer
-  const isStaticLiteral =
-    ts.isStringLiteral(init) ||
-    ts.isNoSubstitutionTemplateLiteral(init) ||
-    ts.isNumericLiteral(init)
-  if (isStaticLiteral) {
-    return
-  }
-  const errorMsg = `${wiringType} has a non-literal '${propertyName}': \`${init.getText()}\`. Wiring identity fields must be inline string literals — the inspector reads them statically from source, so a const or variable reference is keyed by its identifier text and the wiring is silently skipped at runtime. Inline the literal instead, e.g. ${propertyName}: 'my-wiring-name'.`
-  if (logger) {
-    logger.critical(ErrorCode.NON_LITERAL_WIRE_NAME, errorMsg)
-  } else {
-    console.error(errorMsg)
-  }
-}
-
-/**
- * Fold a node that is a compile-time constant string down to its value.
- *
- * The fallback below this is `getText()`, which returns the node's *source*.
- * For a lone `'…'` that is indistinguishable from the value, so nobody noticed
- * that anything written as an expression comes through raw: a `description`
- * split across lines as `'Fetch the thing ' + 'from upstream'` reaches
- * `infra.json` with the quotes and the `+` still in it, and is rendered that
- * way in the fabric console.
- *
- * Deliberately checker-free, unlike `extractStringLiteral`. Every value this
- * resolves is a literal in the same expression, so no symbol resolution is
- * needed, and `getPropertyValue` is called from a dozen places that have no
- * checker to hand. Anything it cannot fold — an identifier, a template with a
- * substitution — returns `undefined` and takes the old path, so this only ever
- * turns a wrong answer into a right one.
- */
-const foldStaticString = (node: ts.Node): string | undefined => {
-  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-    return node.text
-  }
-  if (ts.isParenthesizedExpression(node)) {
-    return foldStaticString(node.expression)
-  }
-  if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
-    return foldStaticString(node.expression)
-  }
-  if (
-    ts.isBinaryExpression(node) &&
-    node.operatorToken.kind === ts.SyntaxKind.PlusToken
-  ) {
-    const left = foldStaticString(node.left)
-    if (left === undefined) return undefined
-    const right = foldStaticString(node.right)
-    if (right === undefined) return undefined
-    return left + right
-  }
-  return undefined
-}
-
-export const getPropertyValue = (
-  obj: ts.ObjectLiteralExpression,
-  propertyName: string
-): string | string[] | number | null | boolean => {
-  const property = obj.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === propertyName
-  )
-
-  if (property && ts.isPropertyAssignment(property)) {
-    const initializer = property.initializer
-
-    // Special handling for 'query' -> expect an array of strings
-    if (
-      ['query', 'tags'].includes(propertyName) &&
-      ts.isArrayLiteralExpression(initializer)
-    ) {
-      const stringArray = initializer.elements
-        .map((element) => {
-          if (ts.isStringLiteral(element)) {
-            return element.text
-          }
-          return null
-        })
-        .filter((item) => item !== null) as string[] // Filter non-null and assert type
-
-      return stringArray.length > 0 ? stringArray : null
-    }
-
-    // booleans -> true/false
-    if (initializer.kind === ts.SyntaxKind.TrueKeyword) {
-      return true
-    }
-
-    if (initializer.kind === ts.SyntaxKind.FalseKeyword) {
-      return false
-    }
-
-    if (ts.isNumericLiteral(initializer)) {
-      if (propertyName === 'name' || propertyName === 'schedule') {
-        return initializer.text
-      }
-      return Number(initializer.text)
-    }
-
-    const staticString = foldStaticString(initializer)
-    if (staticString !== undefined) {
-      return staticString
-    }
-
-    return initializer.getText()
-  }
-
-  return null
-}
-
-/**
- * Extracts common wire metadata (title, tags, summary, description, errors) directly from an object
- * @param obj - The TypeScript object literal expression to extract metadata from
- * @param wiringType - The type of wiring (e.g., 'HTTP route', 'Channel', 'Queue worker')
- * @param wiringName - The name/identifier of the wiring (e.g., route path, channel name)
- * @param logger - Optional logger instance; if not provided, uses console.error
- * @returns Object containing the common wire metadata fields
- */
-export const getCommonWireMetaData = (
-  obj: ts.ObjectLiteralExpression,
-  wiringType: string,
-  wiringName: string | null,
-  logger?: { critical: (code: ErrorCode, message: string) => void },
-  checker?: ts.TypeChecker
-): {
-  disabled?: true
-  title?: string
-  tags?: string[]
-  summary?: string
-  description?: string
-  errors?: string[]
-} => {
-  const metadata: {
-    disabled?: true
-    title?: string
-    tags?: string[]
-    summary?: string
-    description?: string
-    errors?: string[]
-  } = {}
-
-  assertStringLiteralProperty(obj, 'name', wiringType, logger)
-
-  obj.properties.forEach((prop) => {
-    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
-      const propName = prop.name.text
-
-      if (
-        propName === 'disabled' &&
-        prop.initializer.kind === ts.SyntaxKind.TrueKeyword
-      ) {
-        metadata.disabled = true
-      } else if (propName === 'title') {
-        try {
-          metadata.title = checker
-            ? extractStringLiteral(prop.initializer, checker)
-            : ts.isStringLiteral(prop.initializer)
-              ? prop.initializer.text
-              : undefined
-        } catch {
-          // non-static title — skip
-        }
-      } else if (propName === 'summary') {
-        try {
-          metadata.summary = checker
-            ? extractStringLiteral(prop.initializer, checker)
-            : ts.isStringLiteral(prop.initializer)
-              ? prop.initializer.text
-              : undefined
-        } catch {
-          // non-static summary — skip
-        }
-      } else if (propName === 'description') {
-        try {
-          metadata.description = checker
-            ? extractStringLiteral(prop.initializer, checker)
-            : ts.isStringLiteral(prop.initializer)
-              ? prop.initializer.text
-              : undefined
-        } catch {
-          // non-static description — skip
-        }
-      } else if (propName === 'tags') {
-        if (ts.isArrayLiteralExpression(prop.initializer)) {
-          metadata.tags = prop.initializer.elements
-            .filter(ts.isStringLiteral)
-            .map((element) => element.text)
-        } else {
-          const errorMsg = `${wiringType} '${wiringName}' has invalid 'tags' property - must be an array of strings.`
-          if (logger) {
-            logger.critical(ErrorCode.INVALID_TAGS_TYPE, errorMsg)
-          } else {
-            console.error(errorMsg)
-          }
-        }
-      } else if (propName === 'errors') {
-        if (ts.isArrayLiteralExpression(prop.initializer)) {
-          metadata.errors = prop.initializer.elements
-            .filter(ts.isIdentifier)
-            .map((element) => element.text as unknown as string)
-        } else {
-          const errorMsg = `${wiringType} '${wiringName}' has invalid 'errors' property - must be an array of error identifiers.`
-          if (logger) {
-            logger.critical(ErrorCode.INVALID_TAGS_TYPE, errorMsg)
-          } else {
-            console.error(errorMsg)
-          }
-        }
-      }
-    }
-  })
-
-  return metadata
-}

package/src/utils/hash.ts

@@ -1,26 +0,0 @@
-import { createHash } from 'crypto'
-
-export function canonicalJSON(obj: unknown): string {
-  return JSON.stringify(sortDeep(obj))
-}
-
-function sortDeep(value: unknown): unknown {
-  if (value === null || value === undefined) {
-    return value
-  }
-  if (Array.isArray(value)) {
-    return value.map(sortDeep)
-  }
-  if (typeof value === 'object') {
-    const sorted: Record<string, unknown> = {}
-    for (const key of Object.keys(value as Record<string, unknown>).sort()) {
-      sorted[key] = sortDeep((value as Record<string, unknown>)[key])
-    }
-    return sorted
-  }
-  return value
-}
-
-export function hashString(input: string, length: number = 16): string {
-  return createHash('sha256').update(input).digest('hex').slice(0, length)
-}

package/src/utils/literal-properties.ts

@@ -1,97 +0,0 @@
-import * as ts from 'typescript'
-
-/**
- * Readers for object-literal properties that must be statically knowable.
- *
- * Declarations extracted this way are never evaluated — the CLI reads them from
- * source and writes them to JSON that a deployed stage carries without the app.
- * So a computed value is not "unsupported", it is unreadable, and every reader
- * here returns `undefined` for one rather than guessing.
- */
-
-export const getProperty = (
-  config: ts.ObjectLiteralExpression,
-  name: string
-): ts.Expression | undefined => {
-  const property = config.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
-      p.name.text === name
-  )
-  return property && ts.isPropertyAssignment(property)
-    ? property.initializer
-    : undefined
-}
-
-export const stringProperty = (
-  config: ts.ObjectLiteralExpression,
-  name: string
-): string | undefined => {
-  const value = getProperty(config, name)
-  return value && ts.isStringLiteralLike(value) ? value.text : undefined
-}
-
-export const numberProperty = (
-  config: ts.ObjectLiteralExpression,
-  name: string
-): number | undefined => {
-  const value = getProperty(config, name)
-  if (!value) {
-    return undefined
-  }
-  // `-1` parses as a unary minus over a literal, not as a literal. Reading it
-  // rather than ignoring it is what lets a negative be *rejected* by the caller
-  // instead of silently dropped and defaulted.
-  if (
-    ts.isPrefixUnaryExpression(value) &&
-    value.operator === ts.SyntaxKind.MinusToken &&
-    ts.isNumericLiteral(value.operand)
-  ) {
-    return -Number(value.operand.text)
-  }
-  return ts.isNumericLiteral(value) ? Number(value.text) : undefined
-}
-
-export const booleanProperty = (
-  config: ts.ObjectLiteralExpression,
-  name: string
-): boolean | undefined => {
-  const value = getProperty(config, name)
-  if (!value) {
-    return undefined
-  }
-  if (value.kind === ts.SyntaxKind.TrueKeyword) {
-    return true
-  }
-  if (value.kind === ts.SyntaxKind.FalseKeyword) {
-    return false
-  }
-  return undefined
-}
-
-/**
- * All-or-nothing: an array with one computed entry reads as unreadable rather
- * than as the entries that happened to be literals. A half-read `roles` or
- * `scopes` array is worse than none — it typechecks, runs, and grants less
- * than the source says.
- */
-export const stringArrayProperty = (
-  config: ts.ObjectLiteralExpression,
-  name: string
-): string[] | undefined => {
-  const value = getProperty(config, name)
-  if (!value || !ts.isArrayLiteralExpression(value)) {
-    return undefined
-  }
-  const values = value.elements
-    .filter(ts.isStringLiteralLike)
-    .map((e) => e.text)
-  return values.length === value.elements.length ? values : undefined
-}
-
-/** Unwraps `x as const` / `x satisfies T` so a cast is still extracted. */
-export const unwrapAs = (node: ts.Expression): ts.Expression =>
-  ts.isAsExpression(node) || ts.isSatisfiesExpression(node)
-    ? unwrapAs(node.expression)
-    : node