@pikku/inspector 0.11.1 → 0.12.0

package/src/add/add-schedule.ts

@@ -4,7 +4,10 @@ import {
   getCommonWireMetaData,
 } from '../utils/get-property-value.js'
 import { AddWiring } from '../types.js'
-import { extractFunctionName } from '../utils/extract-function-name.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'
@@ -39,12 +42,10 @@ export const addSchedule: AddWiring = (
 
     const nameValue = getPropertyValue(obj, 'name') as string | null
     const scheduleValue = getPropertyValue(obj, 'schedule') as string | null
-    const { tags, summary, description, errors } = getCommonWireMetaData(
-      obj,
-      'Scheduler',
-      nameValue,
-      logger
-    )
+    const { disabled, tags, summary, description, errors } =
+      getCommonWireMetaData(obj, 'Scheduler', nameValue, logger)
+
+    if (disabled) return
 
     const funcInitializer = getPropertyAssignmentInitializer(
       obj,
@@ -60,11 +61,15 @@ export const addSchedule: AddWiring = (
       return
     }
 
-    const pikkuFuncName = extractFunctionName(
+    const extracted = extractFunctionName(
       funcInitializer,
       checker,
       state.rootDir
-    ).pikkuFuncName
+    )
+    let pikkuFuncId = extracted.pikkuFuncId
+    if (pikkuFuncId.startsWith('__temp_') && nameValue) {
+      pikkuFuncId = makeContextBasedId('scheduler', nameValue)
+    }
 
     if (!nameValue || !scheduleValue) {
       return
@@ -74,14 +79,14 @@ export const addSchedule: AddWiring = (
     const middleware = resolveMiddleware(state, obj, tags, checker)
 
     // --- track used functions/middleware for service aggregation ---
-    state.serviceAggregation.usedFunctions.add(pikkuFuncName)
+    state.serviceAggregation.usedFunctions.add(pikkuFuncId)
     extractWireNames(middleware).forEach((name) =>
       state.serviceAggregation.usedMiddleware.add(name)
     )
 
     state.scheduledTasks.files.add(node.getSourceFile().fileName)
     state.scheduledTasks.meta[nameValue] = {
-      pikkuFuncName,
+      pikkuFuncId,
       name: nameValue,
       schedule: scheduleValue,
       summary,

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 { 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 { 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 { resolveExternalPackageName } from '../utils/resolve-external-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 = resolveExternalPackageName(
+      funcInitializer,
+      checker,
+      options.externalPackages
+    )
+    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,
+})