Add support for payload generation for other APIs

Author: varadarajan-tw

packages/cli/src/commands/generate-test-payload.ts

@@ -11,18 +11,27 @@ import {
   generateSamplePayloadFromMapping,
   generateDestinationSettings,
   generateAudienceSettings,
-  addAudienceSettingsToPayload
+  addAudienceSettingsToPayload,
+  generateSampleFromSchema
 } from '../lib/payload-generator/payload'
+import {
+  API_ENDPOINTS,
+  ApiEndpoint,
+  getApiEndpointByName,
+  getFormattedPath
+} from '../lib/payload-generator/api-definitions'
 
 export default class GenerateTestPayload extends Command {
   private spinner: ora.Ora = ora()
 
-  static description = `Generates sample test payload curl commands for a cloud mode destination.`
+  static description = `Generates sample test payload curl commands for different APIs in a cloud mode destination.`
 
   static examples = [
     `$ ./bin/run generate-test-payload`,
     `$ ./bin/run generate-test-payload --destination=slack`,
-    `$ ./bin/run generate-test-payload --destination=slack --action=postToChannel`
+    `$ ./bin/run generate-test-payload --destination=slack --action=postToChannel`,
+    `$ ./bin/run generate-test-payload --destination=slack --api="Execute Action"`,
+    `$ ./bin/run generate-test-payload --destination=slack --api="Create Audience"`
   ]
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -36,6 +45,9 @@ export default class GenerateTestPayload extends Command {
       char: 'a',
       description: 'specific action to generate test payload for'
     }),
+    api: flags.boolean({
+      description: 'prompt for API Selection'
+    }),
     directory: flags.string({
       char: 'p',
       description: 'destination actions directory path',
@@ -53,6 +65,29 @@ export default class GenerateTestPayload extends Command {
     const { flags } = this.parse(GenerateTestPayload)
     let destinationName = flags.destination
     const isBrowser = !!flags.browser
+    let selectedApiEndpoint: ApiEndpoint | undefined = getApiEndpointByName('Execute Action')
+
+    // Get the API endpoint based on the flag if provided
+    if (flags.api) {
+      // Prompt for API selection instead of exiting
+      const { selectedApi } = await autoPrompt<{ selectedApi: string }>(flags, {
+        type: 'select',
+        name: 'selectedApi',
+        message: 'Please select a valid API endpoint:',
+        choices: API_ENDPOINTS.map((api) => ({
+          title: api.name === 'Execute Action' ? 'Execute Action (default)' : api.name,
+          value: api.name
+        }))
+      })
+      selectedApiEndpoint = getApiEndpointByName(selectedApi)
+    }
+
+    if (!selectedApiEndpoint) {
+      this.warn('No valid API endpoint selected. Exiting.')
+      this.exit(1)
+    }
+
+    this.spinner.info(`Generating test payload for API: ${selectedApiEndpoint.name}`)
 
     if (!destinationName) {
       const integrationsGlob = `${flags.directory}/*`
@@ -97,49 +132,57 @@ export default class GenerateTestPayload extends Command {
       this.error(`Failed to load destination: ${destinationName}`)
     }
 
-    const actions = Object.entries(destination.actions)
+    this.spinner.succeed(`Successfully loaded destination: ${destinationName}`)
 
-    if (actions.length === 0) {
-      this.warn('No actions found for this destination.')
-      this.exit()
-    }
+    // If Execute Action API is selected, proceed with action selection
+    if (selectedApiEndpoint.name === 'Execute Action') {
+      const actions = Object.entries(destination.actions)
 
-    let actionToGenerate = flags.action
+      if (actions.length === 0) {
+        this.warn('No actions found for this destination.')
+        this.exit()
+      }
 
-    if (!actionToGenerate && actions.length > 1) {
-      const { selectedAction } = await autoPrompt<{ selectedAction: string }>(flags, {
-        type: 'select',
-        name: 'selectedAction',
-        message: 'Which action to generate test payload for?',
-        choices: [
-          { title: 'All actions', value: 'all' },
-          ...actions.map(([slug, action]) => ({
-            title: action.title || slug,
-            value: slug
-          }))
-        ]
-      })
+      let actionToGenerate = flags.action
+
+      if (!actionToGenerate && actions.length > 1) {
+        const { selectedAction } = await autoPrompt<{ selectedAction: string }>(flags, {
+          type: 'select',
+          name: 'selectedAction',
+          message: 'Which action to generate test payload for?',
+          choices: [
+            { title: 'All actions', value: 'all' },
+            ...actions.map(([slug, action]) => ({
+              title: action.title || slug,
+              value: slug
+            }))
+          ]
+        })
 
-      actionToGenerate = selectedAction
-    } else if (!actionToGenerate) {
-      actionToGenerate = 'all'
-    }
+        actionToGenerate = selectedAction
+      } else if (!actionToGenerate) {
+        actionToGenerate = 'all'
+      }
 
-    this.log(chalk.bold('\nTest Payload curl commands:'))
+      this.log(chalk.bold('\nTest Payload curl commands:'))
+
+      if (actionToGenerate === 'all') {
+        for (const [slug, action] of actions) {
+          await this.generatePayloadForAction(destination, slug, action)
+        }
+      } else {
+        const action = actions.find(([slug]) => slug === actionToGenerate)
+        if (!action) {
+          this.warn(`Action "${actionToGenerate}" not found. Exiting.`)
+          this.exit(1)
+          return
+        }
 
-    if (actionToGenerate === 'all') {
-      for (const [slug, action] of actions) {
-        await this.generatePayloadForAction(destination, slug, action)
+        await this.generatePayloadForAction(destination, action[0], action[1])
       }
     } else {
-      const action = actions.find(([slug]) => slug === actionToGenerate)
-      if (!action) {
-        this.warn(`Action "${actionToGenerate}" not found. Exiting.`)
-        this.exit(1)
-        return
-      }
-
-      await this.generatePayloadForAction(destination, action[0], action[1])
+      // Generate payload for selected API endpoint
+      await this.generatePayloadForApi(destination, selectedApiEndpoint)
     }
 
     this.log(chalk.green(`\nDone generating test payloads! 🎉`))
@@ -221,6 +264,77 @@ export default class GenerateTestPayload extends Command {
     }
   }
 
+  /**
+   * Generate payload for a specific API endpoint
+   */
+  async generatePayloadForApi(destination: DestinationDefinition, apiEndpoint: ApiEndpoint) {
+    this.spinner.start(`Generating test payload for API: ${apiEndpoint.name}`)
+
+    try {
+      // Generate destination settings and auth
+      const { settings, auth } = generateDestinationSettings(destination)
+
+      // Get audience settings if needed
+      const audienceSettings = generateAudienceSettings(destination)
+      const audienceSettingsValues =
+        Object.keys(audienceSettings).length > 0 ? generateSampleFromSchema(audienceSettings || {}) : {}
+
+      // Start with the template payload from the API definition
+      const request = { ...apiEndpoint.requestTemplate }
+
+      // Fill in settings and auth if the payload has those fields
+      if ('settings' in request && !Object.keys(request.settings).length) {
+        request.settings = settings
+      }
+
+      if ('auth' in request && !Object.keys(request.auth || {}).length && auth) {
+        request.auth = auth
+      }
+
+      // Fill in audience settings if applicable
+      if ('audienceSettings' in request && !Object.keys(request.audienceSettings || {}).length) {
+        request.audienceSettings = audienceSettingsValues
+      }
+
+      if ('payload' in request) {
+        const baseEvent = generateSamplePayloadFromMapping({}, {})
+        const isDeleteHandler = apiEndpoint.name === 'Invoke Delete Handler'
+        request.payload = {
+          ...baseEvent,
+          type: isDeleteHandler ? 'delete' : 'track',
+          traits: {}
+        }
+      }
+
+      // Handle path parameters if needed
+      const pathParams: Record<string, string> = {}
+      if (apiEndpoint.pathParams) {
+        // For now we'll use placeholders, but in the future we could prompt for these values
+        for (const param of apiEndpoint.pathParams) {
+          pathParams[param.key] = param.placeholder
+        }
+      }
+
+      // Format the path with any parameters
+      const formattedPath = getFormattedPath(apiEndpoint, pathParams)
+
+      this.spinner.succeed(`Generated test payload for API: ${apiEndpoint.name}`)
+
+      // Print the curl command to the terminal
+      this.log(chalk.cyan(`\n# Test payload for ${chalk.bold(destination.name)} - ${chalk.bold(apiEndpoint.name)}`))
+
+      if (apiEndpoint.method === 'GET') {
+        this.log(chalk.yellow(`curl -X GET http://localhost:3000${formattedPath}`))
+      } else {
+        this.log(chalk.yellow(`curl -X ${apiEndpoint.method} http://localhost:3000${formattedPath} \\`))
+        this.log(chalk.yellow(`  -H "Content-Type: application/json" \\`))
+        this.log(chalk.yellow(`  -d '${JSON.stringify(request).replace(/'/g, "\\'")}'`))
+      }
+    } catch (error) {
+      this.spinner.fail(`Failed to generate payload for API ${apiEndpoint.name}: ${(error as Error).message}`)
+    }
+  }
+
   async catch(error: unknown) {
     if (this.spinner?.isSpinning) {
       this.spinner.fail()