@pikku/inspector 0.12.75 → 0.12.82

package/src/add/add-feature.ts

@@ -1,253 +0,0 @@
-import * as ts from 'typescript'
-import { extractFunctionName } from '../utils/extract-function-name.js'
-import { ErrorCode } from '../error-codes.js'
-import type {
-  AddWiring,
-  InspectorFeature,
-  InspectorFeatureEntry,
-} from '../types.js'
-
-/**
- * Reads a fully literal expression into a plain value.
- *
- * Used for a `{ scenario, data }` entry's `data`, which is gherkin's
- * `Examples:` row. Anything not literal yields `undefined` — a computed row
- * belongs to the runtime-resolved portion, not to the extracted meta.
- */
-const literalValue = (node: ts.Expression): unknown => {
-  if (ts.isStringLiteralLike(node)) {
-    return node.text
-  }
-  if (ts.isNumericLiteral(node)) {
-    return Number(node.text)
-  }
-  if (node.kind === ts.SyntaxKind.TrueKeyword) {
-    return true
-  }
-  if (node.kind === ts.SyntaxKind.FalseKeyword) {
-    return false
-  }
-  if (node.kind === ts.SyntaxKind.NullKeyword) {
-    return null
-  }
-  if (
-    ts.isPrefixUnaryExpression(node) &&
-    node.operator === ts.SyntaxKind.MinusToken &&
-    ts.isNumericLiteral(node.operand)
-  ) {
-    return -Number(node.operand.text)
-  }
-  if (ts.isArrayLiteralExpression(node)) {
-    const values: unknown[] = []
-    for (const element of node.elements) {
-      const value = literalValue(element)
-      if (value === undefined) {
-        return undefined
-      }
-      values.push(value)
-    }
-    return values
-  }
-  if (ts.isObjectLiteralExpression(node)) {
-    const value: Record<string, unknown> = {}
-    for (const property of node.properties) {
-      if (!ts.isPropertyAssignment(property)) {
-        return undefined
-      }
-      const key =
-        ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name)
-          ? property.name.text
-          : undefined
-      if (key === undefined) {
-        return undefined
-      }
-      const propertyValue = literalValue(property.initializer)
-      if (propertyValue === undefined) {
-        return undefined
-      }
-      value[key] = propertyValue
-    }
-    return value
-  }
-  return undefined
-}
-
-/**
- * Resolves a scenario reference to the name it is declared under, following an
- * import alias back to the original export so `{ x as y }` records `x`.
- */
-const scenarioName = (
-  node: ts.Expression,
-  checker: ts.TypeChecker
-): string | undefined => {
-  if (!ts.isIdentifier(node)) {
-    return undefined
-  }
-  const symbol = checker.getSymbolAtLocation(node)
-  if (!symbol) {
-    return node.text
-  }
-  const resolved =
-    symbol.flags & ts.SymbolFlags.Alias
-      ? checker.getAliasedSymbol(symbol)
-      : symbol
-  return resolved.getName() || node.text
-}
-
-const getProperty = (
-  config: ts.ObjectLiteralExpression,
-  name: string
-): ts.Expression | undefined => {
-  const property = config.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === name
-  )
-  return property && ts.isPropertyAssignment(property)
-    ? property.initializer
-    : undefined
-}
-
-const hasProperty = (
-  config: ts.ObjectLiteralExpression,
-  name: string
-): boolean =>
-  config.properties.some(
-    (p) =>
-      (ts.isPropertyAssignment(p) ||
-        ts.isMethodDeclaration(p) ||
-        ts.isShorthandPropertyAssignment(p)) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === name
-  )
-
-const stringProperty = (
-  config: ts.ObjectLiteralExpression,
-  name: string
-): string | undefined => {
-  const value = getProperty(config, name)
-  return value && ts.isStringLiteralLike(value) ? value.text : undefined
-}
-
-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
-}
-
-const readEntry = (
-  element: ts.Expression,
-  checker: ts.TypeChecker
-): InspectorFeatureEntry | undefined => {
-  if (ts.isIdentifier(element)) {
-    const scenario = scenarioName(element, checker)
-    return scenario ? { scenario } : undefined
-  }
-
-  if (ts.isObjectLiteralExpression(element)) {
-    const reference = getProperty(element, 'scenario')
-    if (!reference) {
-      return undefined
-    }
-    const scenario = scenarioName(reference, checker)
-    if (!scenario) {
-      return undefined
-    }
-    const dataNode = getProperty(element, 'data')
-    if (!dataNode) {
-      return { scenario }
-    }
-    const data = literalValue(dataNode)
-    return data === undefined ? undefined : { scenario, data }
-  }
-
-  return undefined
-}
-
-/**
- * Inspector for `pikkuFeature()` calls.
- *
- * A feature is the document structure the console renders — its name,
- * description, tags and the order of its scenarios are what a reader sees — so
- * everything the config states literally is extracted here.
- *
- * What cannot be extracted is a scenarios entry that is not literal:
- * `...['stripe', 'google'].map((name) => ({ scenario, data: { name } }))` is
- * ordinary TypeScript, and no AST walk can enumerate it. Those entries are
- * counted in `unresolvedEntries` rather than dropped, and membership for them
- * is resolved at runtime by object identity (`resolveFeatureScenarios`), where
- * the array has actually been evaluated.
- *
- * The export location is recorded either way, which is what the CLI needs to
- * emit its `addFeature(...)` wiring line.
- */
-export const addFeature: AddWiring = (logger, node, checker, state) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const expression = node.expression
-  if (!ts.isIdentifier(expression) || expression.text !== 'pikkuFeature') {
-    return
-  }
-
-  const { exportedName } = extractFunctionName(node, checker, state.rootDir)
-
-  if (!exportedName) {
-    logger.critical(
-      ErrorCode.MISSING_NAME,
-      `A pikkuFeature() must be assigned to an export — the export identifier is the feature's id.`
-    )
-    return
-  }
-
-  const feature: InspectorFeature = {
-    path: node.getSourceFile().fileName,
-    exportedName,
-    entries: [],
-    unresolvedEntries: 0,
-    hasBefore: false,
-    hasAfter: false,
-  }
-
-  const [config] = node.arguments
-  if (config && ts.isObjectLiteralExpression(config)) {
-    const name = stringProperty(config, 'name')
-    const description = stringProperty(config, 'description')
-    const tags = stringArrayProperty(config, 'tags')
-    if (name !== undefined) {
-      feature.name = name
-    }
-    if (description !== undefined) {
-      feature.description = description
-    }
-    if (tags !== undefined) {
-      feature.tags = tags
-    }
-    feature.hasBefore = hasProperty(config, 'before')
-    feature.hasAfter = hasProperty(config, 'after')
-
-    const scenarios = getProperty(config, 'scenarios')
-    if (scenarios && ts.isArrayLiteralExpression(scenarios)) {
-      for (const element of scenarios.elements) {
-        const entry = readEntry(element, checker)
-        if (entry) {
-          feature.entries.push(entry)
-        } else {
-          feature.unresolvedEntries += 1
-        }
-      }
-    }
-  }
-
-  state.workflows.featureFiles.set(exportedName, feature)
-}

package/src/add/add-file-extends-core-type.ts

@@ -1,66 +0,0 @@
-import * as ts from 'typescript'
-import type { PathToNameAndType, InspectorState } from '../types.js'
-
-export const addFileExtendsCoreType = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  methods: PathToNameAndType,
-  expectedTypeName: string,
-  state?: InspectorState
-) => {
-  if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) {
-    const fileName = node.getSourceFile().fileName
-    const typeName = node.name?.getText()
-
-    // Check if the class or interface extends the expected type
-    if (node.heritageClauses) {
-      for (const clause of node.heritageClauses) {
-        if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
-          for (const type of clause.types) {
-            const extendedTypeName = type.expression.getText()
-            let extendedTypeDeclarationPath: string | null = null
-
-            // Check if the extended type matches the expected type name
-            if (extendedTypeName === expectedTypeName) {
-              // Retrieve the symbol of the extended type
-              const typeSymbol = checker.getSymbolAtLocation(type.expression)
-              const declaration =
-                typeSymbol &&
-                typeSymbol.declarations &&
-                typeSymbol.declarations[0]
-              if (declaration) {
-                const sourceFile = declaration.getSourceFile()
-                extendedTypeDeclarationPath = sourceFile.fileName // Get the path of the file where the extended type was declared
-              }
-
-              const variables = methods.get(fileName) || []
-
-              if (!typeName) {
-                throw new Error(
-                  `Found anonymous ${ts.isClassDeclaration(node) ? 'class' : 'interface'} extending ${expectedTypeName} in ${fileName}. ` +
-                    `Classes and interfaces that extend core types must have a name.`
-                )
-              }
-              variables.push({
-                variable: typeName,
-                type: typeName,
-                typePath: extendedTypeDeclarationPath,
-              })
-              methods.set(fileName, variables)
-
-              // Store the type in typesLookup if state is provided
-              if (state && node.name) {
-                const symbol = checker.getSymbolAtLocation(node.name)
-                if (symbol) {
-                  const declaredType = checker.getDeclaredTypeOfSymbol(symbol)
-                  // Use the type name as the key in typesLookup
-                  state.typesLookup.set(typeName, [declaredType])
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

package/src/add/add-file-with-config.ts

@@ -1,45 +0,0 @@
-import * as ts from 'typescript'
-import { doesTypeExtendsCore } from '../utils/does-type-extend-core-type.js'
-import type { PathToNameAndType } from '../types.js'
-
-export const addFileWithConfig = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  configs: PathToNameAndType
-) => {
-  if (ts.isVariableDeclaration(node)) {
-    const fileName = node.getSourceFile().fileName
-    const variableSymbol = checker.getSymbolAtLocation(node.name)
-
-    if (variableSymbol) {
-      const variableType = checker.getTypeOfSymbolAtLocation(
-        variableSymbol,
-        node.name
-      )
-      const variableName = node.name.getText()
-      const variableTypeText = node.type?.getText()
-
-      // Check if the type extends CoreConfig
-      if (doesTypeExtendsCore(variableType, checker, new Set(), 'CoreConfig')) {
-        // Retrieve the symbol of the type (if it has one)
-        const typeSymbol = variableType.symbol
-        let typeDeclarationPath: string | null = null
-        const declaration =
-          typeSymbol && typeSymbol.declarations && typeSymbol.declarations[0]
-
-        if (declaration) {
-          const sourceFile = declaration.getSourceFile()
-          typeDeclarationPath = sourceFile.fileName // Get the path of the file where the type was declared
-        }
-
-        const variables = configs[fileName] || []
-        variables.push({
-          variable: variableName,
-          type: variableTypeText || null,
-          typePath: typeDeclarationPath,
-        })
-        configs[fileName] = variables
-      }
-    }
-  }
-}

package/src/add/add-file-with-factory.test.ts

@@ -1,134 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { ErrorCode } from '../error-codes.js'
-import type { InspectorLogger } from '../types.js'
-import {
-  serializeInspectorState,
-  deserializeInspectorState,
-} from '../utils/serialize-inspector-state.js'
-
-const makeLogger = (criticals: Array<{ code: ErrorCode; message: string }>) =>
-  ({
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: ({ severity, code, message }) => {
-      if (severity !== 'warn') {
-        criticals.push({ code, message })
-      }
-    },
-    critical: (code: ErrorCode, message: string) => {
-      criticals.push({ code, message })
-    },
-    hasCriticalErrors: () => criticals.length > 0,
-  }) satisfies InspectorLogger
-
-const inspectSource = async (prefix: string, source: string) => {
-  const rootDir = await mkdtemp(join(tmpdir(), prefix))
-  const file = join(rootDir, 'services.ts')
-  await writeFile(file, source)
-  const criticals: Array<{ code: ErrorCode; message: string }> = []
-  try {
-    const state = await inspect(makeLogger(criticals), [file], { rootDir })
-    return { state, criticals }
-  } finally {
-    await rm(rootDir, { recursive: true, force: true })
-  }
-}
-
-describe('pikkuAddonServices — what an addon takes from its parent', () => {
-  test('a name destructured in the body, not the parameter list, is still forwarded', async () => {
-    const { state } = await inspectSource(
-      'pikku-addon-body-destructure-',
-      [
-        "import { pikkuAddonServices } from '#pikku/addon/setup'",
-        'export const createSingletonServices = pikkuAddonServices(',
-        '  async (_config, existingServices) => {',
-        '    const { kysely, secrets } = existingServices',
-        '    return { ...existingServices, stripeApi: makeStripe(secrets) }',
-        '  }',
-        ')',
-      ].join('\n')
-    )
-
-    assert.ok(
-      state.addonRequiredParentServices.includes('kysely'),
-      'kysely is read off the parent bag and must be declared as required'
-    )
-    assert.deepEqual(state.addonCreatedServices, ['stripeApi'])
-    assert.equal(state.addonServicesFactorySeen, true)
-  })
-
-  test('an object rest is a binding name, not a service', async () => {
-    const { state } = await inspectSource(
-      'pikku-addon-object-rest-',
-      [
-        "import { pikkuAddonServices } from '#pikku/addon/setup'",
-        'export const createSingletonServices = pikkuAddonServices(',
-        '  async (_config, { kysely, ...parentServices }) => ({',
-        '    ...parentServices,',
-        '    kysely,',
-        '    stripeApi: makeStripe(),',
-        '  })',
-        ')',
-      ].join('\n')
-    )
-
-    assert.deepEqual(state.addonRequiredParentServices, ['kysely'])
-    assert.ok(
-      !state.addonRequiredParentServices.includes('parentServices'),
-      'a rest binding names the leftover bag, not a service the parent provides'
-    )
-  })
-
-  test('a parenthesised return still yields its created services', async () => {
-    const { state } = await inspectSource(
-      'pikku-addon-parenthesised-return-',
-      [
-        "import { pikkuAddonServices } from '#pikku/addon/setup'",
-        'export const createSingletonServices = pikkuAddonServices(',
-        '  async (_config, existingServices) => {',
-        '    return ({ ...existingServices, stripeApi: makeStripe() })',
-        '  }',
-        ')',
-      ].join('\n')
-    )
-
-    assert.deepEqual(state.addonCreatedServices, ['stripeApi'])
-    assert.ok(
-      !state.addonRequiredParentServices.includes('stripeApi'),
-      'a service the factory builds is not one the parent has to supply'
-    )
-  })
-
-  test('the addon contract survives a serialize/deserialize round trip', async () => {
-    const { state } = await inspectSource(
-      'pikku-addon-round-trip-',
-      [
-        "import { pikkuAddonServices } from '#pikku/addon/setup'",
-        'export const createSingletonServices = pikkuAddonServices(',
-        '  async (_config, existingServices) => {',
-        '    const { kysely } = existingServices',
-        '    return { ...existingServices, stripeApi: makeStripe(kysely) }',
-        '  }',
-        ')',
-      ].join('\n')
-    )
-
-    const restored = deserializeInspectorState(
-      JSON.parse(JSON.stringify(serializeInspectorState(state)))
-    )
-
-    assert.deepEqual(
-      restored.addonRequiredParentServices,
-      state.addonRequiredParentServices
-    )
-    assert.deepEqual(restored.addonCreatedServices, ['stripeApi'])
-    assert.equal(restored.addonServicesFactorySeen, true)
-  })
-})