@pikku/inspector 0.11.2 → 0.12.1

package/src/add/add-secret.ts

@@ -0,0 +1,140 @@
+import * as ts from 'typescript'
+import {
+  getPropertyValue,
+  getArrayPropertyValue,
+} from '../utils/get-property-value.js'
+import type { AddWiring } from '../types.js'
+import { ErrorCode } from '../error-codes.js'
+import { createAddKeyedWiring } from './add-keyed-wiring.js'
+
+export const addSecret = createAddKeyedWiring({
+  functionName: 'wireSecret',
+  idField: 'secretId',
+  label: 'Secret',
+  schemaPrefix: 'SecretSchema',
+  getState: (state) => state.secrets,
+})
+
+export const addOAuth2Credential: 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 !== 'wireOAuth2Credential'
+  ) {
+    return
+  }
+
+  if (!firstArg) {
+    return
+  }
+
+  if (ts.isObjectLiteralExpression(firstArg)) {
+    const obj = firstArg
+
+    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 secretIdValue = getPropertyValue(obj, 'secretId') as string | null
+    const tokenSecretIdValue = getPropertyValue(obj, 'tokenSecretId') as
+      | string
+      | null
+    const authorizationUrlValue = getPropertyValue(obj, 'authorizationUrl') as
+      | string
+      | null
+    const tokenUrlValue = getPropertyValue(obj, 'tokenUrl') as string | null
+    const scopesValue = getArrayPropertyValue(obj, 'scopes')
+    const pkceValue = getPropertyValue(obj, 'pkce') as boolean | null
+
+    if (!nameValue) {
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        "OAuth2 Credential is missing the required 'name' property."
+      )
+      return
+    }
+
+    if (!displayNameValue) {
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        `OAuth2 Credential '${nameValue}' is missing the required 'displayName' property.`
+      )
+      return
+    }
+
+    if (!secretIdValue) {
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        `OAuth2 Credential '${nameValue}' is missing the required 'secretId' property.`
+      )
+      return
+    }
+
+    if (!tokenSecretIdValue) {
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        `OAuth2 Credential '${nameValue}' is missing the required 'tokenSecretId' property.`
+      )
+      return
+    }
+
+    if (!authorizationUrlValue) {
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        `OAuth2 Credential '${nameValue}' is missing the required 'authorizationUrl' property.`
+      )
+      return
+    }
+
+    if (!tokenUrlValue) {
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        `OAuth2 Credential '${nameValue}' is missing the required 'tokenUrl' property.`
+      )
+      return
+    }
+
+    if (!scopesValue || scopesValue.length === 0) {
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        `OAuth2 Credential '${nameValue}' is missing the required 'scopes' property.`
+      )
+      return
+    }
+
+    const sourceFile = node.getSourceFile().fileName
+
+    state.secrets.files.add(sourceFile)
+
+    state.secrets.definitions.push({
+      name: nameValue,
+      displayName: displayNameValue,
+      description: descriptionValue || undefined,
+      secretId: secretIdValue,
+      oauth2: {
+        tokenSecretId: tokenSecretIdValue,
+        authorizationUrl: authorizationUrlValue,
+        tokenUrl: tokenUrlValue,
+        scopes: scopesValue,
+        pkce: pkceValue || undefined,
+      },
+      sourceFile,
+    })
+  }
+}

package/src/add/add-trigger.ts

@@ -0,0 +1,154 @@
+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 { 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)
+
+  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
+  }
+
+  // --- 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

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

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

@@ -0,0 +1,80 @@
+import * as ts from 'typescript'
+import type { InspectorState, InspectorLogger } from '../types.js'
+
+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 secretOverrides: Record<string, string> | undefined
+  let variableOverrides: Record<string, 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 === 'secretOverrides' &&
+      ts.isObjectLiteralExpression(prop.initializer)
+    ) {
+      secretOverrides = parseStringRecord(prop.initializer)
+    } else if (
+      key === 'variableOverrides' &&
+      ts.isObjectLiteralExpression(prop.initializer)
+    ) {
+      variableOverrides = parseStringRecord(prop.initializer)
+    }
+  }
+
+  if (!name || !pkg) return
+
+  logger.debug(`• Found wireAddon: ${name} → ${pkg}`)
+  state.rpc.wireAddonDeclarations.set(name, {
+    package: pkg,
+    rpcEndpoint,
+    secretOverrides,
+    variableOverrides,
+  })
+  state.rpc.usedAddons.add(name)
+  state.rpc.wireAddonFiles.add(node.getSourceFile().fileName)
+}