feat: support command options on discord

marian2js · marian2js · commit b5259f96bb10 · 2023-04-28T14:37:08.000+01:00
diff --git a/libs/definitions/src/definition.ts b/libs/definitions/src/definition.ts
@@ -16,7 +16,7 @@ import { IntegrationTriggerService } from '../../../apps/api/src/integration-tri
 import { Integration } from '../../../apps/api/src/integrations/entities/integration'
 import { WorkflowAction } from '../../../apps/api/src/workflow-actions/entities/workflow-action'
 import { WorkflowTrigger } from '../../../apps/api/src/workflow-triggers/entities/workflow-trigger'
-import { OperationRunnerService, OperationRunOptions } from '../../../apps/runner/src/services/operation-runner.service'
+import { OperationRunOptions, OperationRunnerService } from '../../../apps/runner/src/services/operation-runner.service'
 import { Operation } from './operation'
 import { OperationTrigger } from './operation-trigger'
 import { OperationOffChain } from './opertion-offchain'
diff --git a/libs/definitions/src/integration-definition.factory.ts b/libs/definitions/src/integration-definition.factory.ts
@@ -23,7 +23,7 @@ import { CoinMarketCapDefinition } from './integration-definitions/coinmarketcap
 import { CronoscanDefinition } from './integration-definitions/cronoscan.definition'
 import { DecentralandMarketplaceDefinition } from './integration-definitions/decentraland-marketplace.definition'
 import { DexScreenerDefinition } from './integration-definitions/dexscreener.definition'
-import { DiscordDefinition } from './integration-definitions/discord.definition'
+import { DiscordDefinition } from './integration-definitions/discord/discord.definition'
 import { DiscourseDefinition } from './integration-definitions/discourse.definition'
 import { EmailDefinition } from './integration-definitions/email.definition'
 import { EnsDefinition } from './integration-definitions/ens/ens.definition'
diff --git a/libs/definitions/src/integration-definitions/discord/discord.definition.ts b/libs/definitions/src/integration-definitions/discord/discord.definition.ts
@@ -9,12 +9,13 @@ import { Integration } from 'apps/api/src/integrations/entities/integration'
 import { WorkflowAction } from 'apps/api/src/workflow-actions/entities/workflow-action'
 import { WorkflowTrigger } from 'apps/api/src/workflow-triggers/entities/workflow-trigger'
 import { OperationRunOptions } from 'apps/runner/src/services/operation-runner.service'
-import { StaticRunner } from 'apps/runner/src/services/static-runner.service'
 import { InteractionResponseType, InteractionType, verifyKey } from 'discord-interactions'
 import { Request } from 'express'
 import { OpenAPIObject } from 'openapi3-ts'
 import { OptionsWithUrl } from 'request'
-import { GetAsyncSchemasProps, IntegrationHookInjects, RequestInterceptorOptions, StepInputs } from '../definition'
+import { GetAsyncSchemasProps, IntegrationHookInjects, RequestInterceptorOptions } from '../../definition'
+import { DiscordLib } from './discord.lib'
+import { NewSlashCommandGuild } from './triggers/new-slash-command-guild.trigger'
 
 const CHANNEL_TYPES = {
   GUILD_TEXT: 0,
@@ -43,6 +44,8 @@ export class DiscordDefinition extends SingleIntegrationDefinition {
   integrationVersion = '10'
   schemaUrl = null
 
+  triggers = [new NewSlashCommandGuild()]
+
   // standard oauth2 refresh token won't work for discord ()
   async refreshCredentials(credentials: Record<string, any>): Promise<Record<string, any>> {
     return credentials
@@ -73,36 +76,13 @@ export class DiscordDefinition extends SingleIntegrationDefinition {
     return opts
   }
 
-  // We need to ensure the user has access to the guild id and the channel id belongs to the user
-  // This must be run before create and update triggers and actions
-  private async ensurePermissions(inputs: StepInputs, accountCredential?: AccountCredential | null) {
-    const credentials = accountCredential?.credentials ?? {}
-    inputs.guildId = credentials.guild_id // enforce guild id
-    if (inputs.channelId) {
-      const { outputs: channels } = await StaticRunner.run({
-        definition: this,
-        actionKey: 'getGuildChannels',
-        inputs: {
-          guildId: credentials.guild_id,
-        },
-        accountCredential,
-      })
-      const hasChannel = (channels as unknown as any[]).some(
-        (channel) => channel.id.toString() === inputs.channelId.toString(),
-      )
-      if (!hasChannel) {
-        throw new Error(`Invalid permissions to access channel ${inputs.channelId}`)
-      }
-    }
-  }
-
   async beforeCreateWorkflowAction(
     workflowAction: Partial<WorkflowAction>,
     integrationAction: IntegrationAction,
     accountCredential: AccountCredential | null,
   ): Promise<Partial<WorkflowAction>> {
-    await this.ensurePermissions(workflowAction.inputs ?? {}, accountCredential)
-    return workflowAction
+    await DiscordLib.ensurePermissions(workflowAction.inputs ?? {}, accountCredential!.credentials)
+    return super.beforeCreateWorkflowAction(workflowAction, integrationAction, accountCredential)
   }
 
   async beforeUpdateWorkflowAction(
@@ -111,31 +91,17 @@ export class DiscordDefinition extends SingleIntegrationDefinition {
     integrationAction: IntegrationAction,
     accountCredential: AccountCredential | null,
   ): Promise<Partial<WorkflowAction>> {
-    await this.ensurePermissions(update.inputs ?? {}, accountCredential)
-    return update
+    await DiscordLib.ensurePermissions(update.inputs ?? {}, accountCredential!.credentials)
+    return super.beforeUpdateWorkflowAction(update, prevWorkflowAction, integrationAction, accountCredential)
   }
 
   async beforeCreateWorkflowTrigger(
     workflowTrigger: Partial<WorkflowTrigger>,
     integrationTrigger: IntegrationTrigger,
     accountCredential: AccountCredential | null,
   ): Promise<Partial<WorkflowTrigger>> {
-    await this.ensurePermissions(workflowTrigger.inputs ?? {}, accountCredential)
-    switch (integrationTrigger.key) {
-      case 'newSlashCommandGuild':
-        await StaticRunner.run({
-          definition: this,
-          actionKey: 'createGuildCommand',
-          inputs: {
-            applicationId: process.env.DISCORD_CLIENT_ID,
-            guildId: accountCredential?.credentials.guild_id,
-            name: workflowTrigger.inputs?.name,
-            description: workflowTrigger.inputs?.description,
-          },
-          accountCredential,
-        })
-    }
-    return workflowTrigger
+    await DiscordLib.ensurePermissions(workflowTrigger.inputs ?? {}, accountCredential!.credentials)
+    return super.beforeCreateWorkflowTrigger(workflowTrigger, integrationTrigger, accountCredential)
   }
 
   async beforeUpdateWorkflowTrigger(
@@ -144,20 +110,8 @@ export class DiscordDefinition extends SingleIntegrationDefinition {
     integrationTrigger: IntegrationTrigger,
     accountCredential: AccountCredential | null,
   ): Promise<Partial<WorkflowTrigger>> {
-    await this.ensurePermissions(update.inputs ?? {}, accountCredential)
-    return update
-  }
-
-  async beforeDeleteWorkflowTrigger(
-    workflowTrigger: Partial<WorkflowTrigger>,
-    integrationTrigger: IntegrationTrigger,
-    accountCredential: AccountCredential | null,
-  ): Promise<void> {
-    switch (integrationTrigger.key) {
-      case 'newSlashCommandGuild':
-        // TODO delete command
-        break
-    }
+    await DiscordLib.ensurePermissions(update.inputs ?? {}, accountCredential!.credentials)
+    return super.beforeUpdateWorkflowTrigger(update, prevWorkflowTrigger, integrationTrigger, accountCredential)
   }
 
   async onHookReceived(
@@ -192,6 +146,8 @@ export class DiscordDefinition extends SingleIntegrationDefinition {
     if (type === InteractionType.APPLICATION_COMMAND) {
       const { name, guild_id } = data
 
+      console.log(`Received slash command ${name} in guild ${guild_id}`, data)
+
       const integrationTrigger = await injects.integrationTriggerService.findOne({ key: 'newSlashCommandGuild' }) // TODO check integration = discord
       if (!integrationTrigger) {
         throw new Error(`Integration trigger for discord slash command not configured correctly`)
diff --git a/libs/definitions/src/integration-definitions/discord/discord.lib.ts b/libs/definitions/src/integration-definitions/discord/discord.lib.ts
@@ -0,0 +1,151 @@
+import { Logger, UnauthorizedException } from '@nestjs/common'
+import axios from 'axios'
+
+export const DiscordLib = {
+  logger: new Logger('DiscordLib'),
+
+  async createCommand({
+    guildId,
+    name,
+    description,
+    options = [],
+  }: {
+    guildId: string
+    name: string
+    description: string
+    options: any[]
+  }) {
+    const url = `https://discord.com/api/v9/applications/${process.env.DISCORD_CLIENT_ID}/guilds/${guildId}/commands`
+    const command = {
+      name,
+      description,
+      options,
+    }
+    const response = await axios.post(url, command, {
+      headers: {
+        Authorization: `Bot ${process.env.DISCORD_BOT_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+    })
+    return response.data
+  },
+
+  async updateCommand({
+    guildId,
+    commandId,
+    name,
+    description,
+    options = [],
+  }: {
+    guildId: string
+    commandId: string
+    name: string
+    description: string
+    options: any[]
+  }) {
+    const url = `https://discord.com/api/v9/applications/${process.env.DISCORD_CLIENT_ID}/guilds/${guildId}/commands/${commandId}`
+    const command = {
+      name,
+      description,
+      options,
+    }
+    const response = await axios.patch(url, command, {
+      headers: {
+        Authorization: `Bot ${process.env.DISCORD_BOT_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+    })
+    return response.data
+  },
+
+  async deleteCommand({ guildId, commandId }: { guildId: string; commandId: string }) {
+    const url = `https://discord.com/api/v9/applications/${process.env.DISCORD_CLIENT_ID}/guilds/${guildId}/commands/${commandId}`
+    const response = await axios.delete(url, {
+      headers: {
+        Authorization: `Bot ${process.env.DISCORD_BOT_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+    })
+    return response.status
+  },
+
+  async deleteAllCommands(guildId: string) {
+    const url = `https://discord.com/api/v9/applications/${process.env.DISCORD_CLIENT_ID}/guilds/${guildId}/commands`
+
+    // First, list all the commands
+    const listCommandsResponse = await axios.get(url, {
+      headers: {
+        Authorization: `Bot ${process.env.DISCORD_BOT_TOKEN}`,
+      },
+    })
+
+    // Delete each command in the server
+    for (const command of listCommandsResponse.data) {
+      await axios.delete(`${url}/${command.id}`, {
+        headers: {
+          Authorization: `Bot ${process.env.DISCORD_BOT_TOKEN}`,
+        },
+      })
+    }
+  },
+
+  async getCommandIdByName(guildId: string, commandName: string): Promise<string | null> {
+    const url = `https://discord.com/api/v9/applications/${process.env.DISCORD_CLIENT_ID}/guilds/${guildId}/commands`
+
+    this.logger.log(`Getting command ID for ${commandName}`)
+
+    try {
+      // List all the commands
+      const listCommandsResponse = await axios.get(url, {
+        headers: {
+          Authorization: `Bot ${process.env.DISCORD_BOT_TOKEN}`,
+        },
+      })
+
+      // Find the command with the specified name
+      const command = listCommandsResponse.data.find((cmd: any) => cmd.name === commandName)
+
+      if (!command) {
+        console.log('Command not found')
+        return null
+      }
+
+      // Return the command ID
+      return command.id
+    } catch (error) {
+      this.logger.error('Error retrieving command ID:', error)
+      return null
+    }
+  },
+
+  async getGuildChannels(guildId: string): Promise<any[] | null> {
+    const url = `https://discord.com/api/v9/guilds/${guildId}/channels`
+
+    try {
+      const response = await axios.get(url, {
+        headers: {
+          Authorization: `Bot ${process.env.DISCORD_BOT_TOKEN}`,
+        },
+      })
+      return response.data
+    } catch (error) {
+      this.logger.error('Error retrieving guild channels:', error)
+      return null
+    }
+  },
+
+  // We need to ensure the user has access to the guild id and the channel id belongs to the user
+  // This must be run before create and update triggers and actions
+  async ensurePermissions(inputs: Record<string, any>, credentials: Record<string, any>) {
+    inputs.guildId = credentials.guild_id // enforce guild id
+    if (inputs.channelId) {
+      const { outputs: channels } = this.getGuildChannels(inputs.guildId)
+      const hasChannel = (channels as unknown as any[]).some(
+        (channel) => channel.id.toString() === inputs.channelId.toString(),
+      )
+      if (!hasChannel) {
+        throw new UnauthorizedException(`Invalid permissions to access channel ${inputs.channelId}`)
+      }
+    }
+  },
+}
diff --git a/libs/definitions/src/integration-definitions/discord/triggers/new-slash-command-guild.trigger.ts b/libs/definitions/src/integration-definitions/discord/triggers/new-slash-command-guild.trigger.ts
diff --git a/schemas/openapi3/discord-10.json b/schemas/openapi3/discord-10.json
