@pikku/inspector 0.12.75 → 0.12.82

package/src/add/add-credential.ts

@@ -1,186 +0,0 @@
-import * as ts from 'typescript'
-import {
-  getPropertyValue,
-  getArrayPropertyValue,
-  getRecordPropertyValue,
-  assertStringLiteralProperty,
-} from '../utils/get-property-value.js'
-import type { AddWiring } from '../types.js'
-import { ErrorCode } from '../error-codes.js'
-import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js'
-
-export const addCredential: 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) || expression.text !== 'defineCredential') {
-    return
-  }
-
-  if (!firstArg) {
-    return
-  }
-
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    assertStringLiteralProperty(obj, 'name', 'Credential', logger)
-
-    const nameValue = getPropertyValue(obj, 'name') as string | null
-    const displayNameValue = getPropertyValue(obj, 'displayName') as
-      string | null
-    const descriptionValue = getPropertyValue(obj, 'description') as
-      string | null
-    const typeValue = getPropertyValue(obj, 'type') as string | null
-    const docsUrlValue = getPropertyValue(obj, 'docsUrl') as string | null
-
-    if (!nameValue) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        "Credential is missing the required 'name' property."
-      )
-      return
-    }
-
-    if (!displayNameValue) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        `Credential '${nameValue}' is missing the required 'displayName' property.`
-      )
-      return
-    }
-
-    if (!typeValue || (typeValue !== 'singleton' && typeValue !== 'wire')) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        `Credential '${nameValue}' is missing or has invalid 'type' property. Must be 'singleton' or 'wire'.`
-      )
-      return
-    }
-
-    let schemaVariableName: string | null = null
-    let schemaSourceFile: string | null = null
-    let schemaIdentifier: ts.Identifier | null = null
-    for (const prop of obj.properties) {
-      if (
-        ts.isPropertyAssignment(prop) &&
-        ts.isIdentifier(prop.name) &&
-        prop.name.text === 'schema'
-      ) {
-        if (ts.isIdentifier(prop.initializer)) {
-          schemaVariableName = prop.initializer.text
-          schemaIdentifier = prop.initializer
-
-          const symbol = checker.getSymbolAtLocation(prop.initializer)
-          if (symbol) {
-            const decl = symbol.valueDeclaration || symbol.declarations?.[0]
-            if (decl) {
-              if (ts.isImportSpecifier(decl)) {
-                const aliasedSymbol = checker.getAliasedSymbol(symbol)
-                if (aliasedSymbol) {
-                  const aliasedDecl =
-                    aliasedSymbol.valueDeclaration ||
-                    aliasedSymbol.declarations?.[0]
-                  if (aliasedDecl) {
-                    schemaSourceFile = aliasedDecl.getSourceFile().fileName
-                  }
-                }
-              } else {
-                schemaSourceFile = decl.getSourceFile().fileName
-              }
-            }
-          }
-        }
-        break
-      }
-    }
-
-    let oauth2: any = undefined
-    const oauth2Prop = obj.properties.find(
-      (p) =>
-        ts.isPropertyAssignment(p) &&
-        ts.isIdentifier(p.name) &&
-        p.name.text === 'oauth2'
-    )
-    if (
-      oauth2Prop &&
-      ts.isPropertyAssignment(oauth2Prop) &&
-      ts.isObjectLiteralExpression(oauth2Prop.initializer)
-    ) {
-      const oauth2Obj = oauth2Prop.initializer
-      const appCredentialSecretId = getPropertyValue(
-        oauth2Obj,
-        'appCredentialSecretId'
-      ) as string | null
-      const tokenSecretId = getPropertyValue(oauth2Obj, 'tokenSecretId') as
-        string | null
-      const authorizationUrl = getPropertyValue(
-        oauth2Obj,
-        'authorizationUrl'
-      ) as string | null
-      const tokenUrl = getPropertyValue(oauth2Obj, 'tokenUrl') as string | null
-      const scopes = getArrayPropertyValue(oauth2Obj, 'scopes')
-      const pkce = getPropertyValue(oauth2Obj, 'pkce') as boolean | null
-      const additionalParams = getRecordPropertyValue(
-        oauth2Obj,
-        'additionalParams'
-      )
-
-      if (appCredentialSecretId && authorizationUrl && tokenUrl && scopes) {
-        oauth2 = {
-          appCredentialSecretId,
-          tokenSecretId: tokenSecretId || undefined,
-          authorizationUrl,
-          tokenUrl,
-          scopes,
-          pkce: pkce || undefined,
-          additionalParams: additionalParams || undefined,
-        }
-      }
-    }
-
-    const sourceFile = node.getSourceFile().fileName
-    state.credentials.files.add(sourceFile)
-
-    let schemaLookupName: string | undefined
-    if (schemaVariableName && schemaSourceFile && schemaIdentifier) {
-      const vendor = detectSchemaVendorOrError(
-        schemaIdentifier,
-        checker,
-        logger,
-        `Credential '${nameValue}'`,
-        schemaSourceFile
-      )
-      if (vendor) {
-        schemaLookupName = `CredentialSchema_${nameValue}`
-        state.schemaLookup.set(schemaLookupName, {
-          variableName: schemaVariableName,
-          sourceFile: schemaSourceFile,
-          vendor,
-        })
-      }
-    }
-
-    state.credentials.definitions.push({
-      name: nameValue,
-      displayName: displayNameValue,
-      description: descriptionValue || undefined,
-      type: typeValue as 'singleton' | 'wire',
-      docsUrl: docsUrlValue || undefined,
-      schema: schemaLookupName,
-      oauth2,
-      sourceFile,
-    })
-  }
-}

package/src/add/add-feature.test.ts

@@ -1,306 +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 { InspectorLogger } from '../types.js'
-
-function makeLogger(
-  criticals: Array<{ code: string; message: string }>
-): InspectorLogger {
-  return {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: ({ code, message }: any) => {
-      criticals.push({ code, message })
-    },
-    critical: (code: any, message: string) => {
-      criticals.push({ code, message })
-    },
-    hasCriticalErrors: () => criticals.length > 0,
-  } as InspectorLogger
-}
-
-const SCENARIOS = [
-  "import { pikkuScenario } from '@pikku/core/workflow'",
-  'export const lazyLoadScenario = pikkuScenario({',
-  "  title: 'A credential is loaded on first use',",
-  "  tags: ['credential'],",
-  '  func: async () => ({ ok: true }),',
-  '})',
-  'export const roundTripScenario = pikkuScenario({',
-  "  title: 'A credential round-trips',",
-  '  func: async (_services, _data: { name: string }) => ({ ok: true }),',
-  '})',
-].join('\n')
-
-async function run(featureSource: string) {
-  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-feature-'))
-  const scenarioFile = join(rootDir, 'credential.scenario.ts')
-  const featureFile = join(rootDir, 'credential.feature.ts')
-  await writeFile(scenarioFile, SCENARIOS)
-  await writeFile(featureFile, featureSource)
-  const criticals: Array<{ code: string; message: string }> = []
-  const state = await inspect(
-    makeLogger(criticals),
-    [scenarioFile, featureFile],
-    { rootDir }
-  )
-  return {
-    state,
-    criticals,
-    featureFile,
-    cleanup: () => rm(rootDir, { recursive: true, force: true }),
-  }
-}
-
-describe('addFeature', () => {
-  test('records where a feature is exported from', async () => {
-    const { state, criticals, featureFile, cleanup } = await run(
-      [
-        "import { pikkuFeature } from '@pikku/core/workflow'",
-        "import { lazyLoadScenario } from './credential.scenario.js'",
-        'export const credentialFeature = pikkuFeature({',
-        "  name: 'Credential API',",
-        "  tags: ['credential'],",
-        '  scenarios: [lazyLoadScenario],',
-        '})',
-      ].join('\n')
-    )
-    try {
-      assert.deepEqual(criticals, [])
-      assert.deepEqual(
-        [...state.workflows.featureFiles.entries()],
-        [
-          [
-            'credentialFeature',
-            {
-              path: featureFile,
-              exportedName: 'credentialFeature',
-              name: 'Credential API',
-              tags: ['credential'],
-              entries: [{ scenario: 'lazyLoadScenario' }],
-              unresolvedEntries: 0,
-              hasBefore: false,
-              hasAfter: false,
-            },
-          ],
-        ]
-      )
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('extracts the feature name, description and tags', async () => {
-    const { state, criticals, cleanup } = await run(
-      [
-        "import { pikkuFeature } from '@pikku/core/workflow'",
-        "import { lazyLoadScenario } from './credential.scenario.js'",
-        'export const credentialFeature = pikkuFeature({',
-        "  name: 'Credential API',",
-        "  description: 'How credentials are loaded and rotated',",
-        "  tags: ['credential', 'console'],",
-        '  scenarios: [lazyLoadScenario],',
-        '})',
-      ].join('\n')
-    )
-    try {
-      assert.deepEqual(criticals, [])
-      const feature = state.workflows.featureFiles.get('credentialFeature')!
-      assert.equal(feature.name, 'Credential API')
-      assert.equal(
-        feature.description,
-        'How credentials are loaded and rotated'
-      )
-      assert.deepEqual(feature.tags, ['credential', 'console'])
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('resolves a literal scenarios array to scenario names, in order', async () => {
-    const { state, criticals, cleanup } = await run(
-      [
-        "import { pikkuFeature } from '@pikku/core/workflow'",
-        "import { lazyLoadScenario, roundTripScenario } from './credential.scenario.js'",
-        'export const credentialFeature = pikkuFeature({',
-        "  name: 'Credential API',",
-        '  scenarios: [roundTripScenario, lazyLoadScenario],',
-        '})',
-      ].join('\n')
-    )
-    try {
-      assert.deepEqual(criticals, [])
-      const feature = state.workflows.featureFiles.get('credentialFeature')!
-      assert.deepEqual(feature.entries, [
-        { scenario: 'roundTripScenario' },
-        { scenario: 'lazyLoadScenario' },
-      ])
-      assert.equal(feature.unresolvedEntries, 0)
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('resolves an aliased import back to the declared scenario name', async () => {
-    const { state, criticals, cleanup } = await run(
-      [
-        "import { pikkuFeature } from '@pikku/core/workflow'",
-        "import { lazyLoadScenario as lazy } from './credential.scenario.js'",
-        'export const credentialFeature = pikkuFeature({',
-        "  name: 'Credential API',",
-        '  scenarios: [lazy],',
-        '})',
-      ].join('\n')
-    )
-    try {
-      assert.deepEqual(criticals, [])
-      assert.deepEqual(
-        state.workflows.featureFiles.get('credentialFeature')!.entries,
-        [{ scenario: 'lazyLoadScenario' }]
-      )
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('resolves a { scenario, data } entry with its literal data', async () => {
-    const { state, criticals, cleanup } = await run(
-      [
-        "import { pikkuFeature } from '@pikku/core/workflow'",
-        "import { roundTripScenario } from './credential.scenario.js'",
-        'export const credentialFeature = pikkuFeature({',
-        "  name: 'Credential API',",
-        '  scenarios: [',
-        "    { scenario: roundTripScenario, data: { name: 'stripe', retries: 2 } },",
-        "    { scenario: roundTripScenario, data: { name: 'google', retries: 0 } },",
-        '  ],',
-        '})',
-      ].join('\n')
-    )
-    try {
-      assert.deepEqual(criticals, [])
-      assert.deepEqual(
-        state.workflows.featureFiles.get('credentialFeature')!.entries,
-        [
-          {
-            scenario: 'roundTripScenario',
-            data: { name: 'stripe', retries: 2 },
-          },
-          {
-            scenario: 'roundTripScenario',
-            data: { name: 'google', retries: 0 },
-          },
-        ]
-      )
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('records whether the feature has before/after hooks', async () => {
-    const { state, criticals, cleanup } = await run(
-      [
-        "import { pikkuFeature } from '@pikku/core/workflow'",
-        "import { lazyLoadScenario } from './credential.scenario.js'",
-        'export const credentialFeature = pikkuFeature({',
-        "  name: 'Credential API',",
-        '  before: async () => {},',
-        '  scenarios: [lazyLoadScenario],',
-        '})',
-      ].join('\n')
-    )
-    try {
-      assert.deepEqual(criticals, [])
-      const feature = state.workflows.featureFiles.get('credentialFeature')!
-      assert.equal(feature.hasBefore, true)
-      assert.equal(feature.hasAfter, false)
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('a feature built by a loop keeps its literal entries and counts the rest', async () => {
-    // A spread of `.map()` cannot be enumerated statically — membership for it
-    // is resolved at runtime by object identity. Everything literal alongside it
-    // is still extracted, and the dynamic portion is counted rather than lost.
-    const { state, criticals, cleanup } = await run(
-      [
-        "import { pikkuFeature } from '@pikku/core/workflow'",
-        "import { lazyLoadScenario, roundTripScenario } from './credential.scenario.js'",
-        'export const credentialFeature = pikkuFeature({',
-        "  name: 'Credential API',",
-        '  scenarios: [',
-        '    lazyLoadScenario,',
-        "    ...['stripe', 'google'].map((name) => ({",
-        '      scenario: roundTripScenario,',
-        '      data: { name },',
-        '    })),',
-        '  ],',
-        '})',
-      ].join('\n')
-    )
-    try {
-      assert.deepEqual(criticals, [])
-      const feature = state.workflows.featureFiles.get('credentialFeature')!
-      assert.deepEqual(feature.entries, [{ scenario: 'lazyLoadScenario' }])
-      assert.equal(feature.unresolvedEntries, 1)
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('several features in one file are all recorded', async () => {
-    const { state, criticals, cleanup } = await run(
-      [
-        "import { pikkuFeature } from '@pikku/core/workflow'",
-        "import { lazyLoadScenario, roundTripScenario } from './credential.scenario.js'",
-        "export const readFeature = pikkuFeature({ name: 'Read', scenarios: [lazyLoadScenario] })",
-        "export const writeFeature = pikkuFeature({ name: 'Write', scenarios: [roundTripScenario] })",
-      ].join('\n')
-    )
-    try {
-      assert.deepEqual(criticals, [])
-      assert.deepEqual(
-        [...state.workflows.featureFiles.keys()],
-        ['readFeature', 'writeFeature']
-      )
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('a feature that is not exported is a critical error', async () => {
-    const { state, criticals, cleanup } = await run(
-      [
-        "import { pikkuFeature } from '@pikku/core/workflow'",
-        "import { lazyLoadScenario } from './credential.scenario.js'",
-        "const credentialFeature = pikkuFeature({ name: 'Credential API', scenarios: [lazyLoadScenario] })",
-        'void credentialFeature',
-      ].join('\n')
-    )
-    try {
-      assert.equal(state.workflows.featureFiles.size, 0)
-      assert.equal(criticals.length, 1)
-      assert.match(criticals[0]!.message, /must be assigned to an export/)
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('a project with no features records none', async () => {
-    const { state, criticals, cleanup } = await run(
-      "export const nothing = 'here'\n"
-    )
-    try {
-      assert.deepEqual(criticals, [])
-      assert.equal(state.workflows.featureFiles.size, 0)
-    } finally {
-      await cleanup()
-    }
-  })
-})