feat(api): Add slack integration

apps/api/package.json

@@ -34,6 +34,7 @@
     "@nestjs/swagger": "^7.3.0",
     "@nestjs/throttler": "^6.2.1",
     "@nestjs/websockets": "^10.3.7",
+    "@slack/bolt": "^3.22.0",
     "@socket.io/redis-adapter": "^8.3.0",
     "@supabase/supabase-js": "^2.39.6",
     "class-transformer": "^0.5.1",

apps/api/src/integration/integration.types.ts

@@ -43,6 +43,12 @@ export interface DiscordIntegrationMetadata extends IntegrationMetadata {
   webhookUrl: string
 }
 
+export interface SlackIntegrationMetadata extends IntegrationMetadata {
+  botToken: string;
+  signingSecret: string;
+  channelId: string;
+}
+
 export interface IntegrationWithWorkspace extends Integration {
   workspace: Workspace
 }

apps/api/src/integration/plugins/factory/integration.factory.ts

@@ -2,7 +2,7 @@ import { IntegrationType } from '@prisma/client'
 import { BaseIntegration } from '../base.integration'
 import { DiscordIntegration } from '../discord/discord.integration'
 import { InternalServerErrorException } from '@nestjs/common'
-
+import { SlackIntegration } from '../slack/slack.integration'
 /**
  * Factory class to create integrations. This class will be called to create an integration,
  * based on the integration type. This has only a single factory method. You will need to
@@ -20,6 +20,8 @@ export default class IntegrationFactory {
     switch (integrationType) {
       case IntegrationType.DISCORD:
         return new DiscordIntegration()
+        case IntegrationType.SLACK:
+          return new SlackIntegration()
       default:
         throw new InternalServerErrorException('Integration type not found')
     }

apps/api/src/integration/plugins/slack/slack.integration.spec.ts

@@ -0,0 +1,30 @@
+import { IntegrationType } from '@prisma/client'
+import { SlackIntegration } from './slack.integration'
+
+describe('Slack Integration Test', () => {  
+  let integration: SlackIntegration
+
+  beforeEach(() => {
+    integration = new SlackIntegration()
+  })
+
+  it('should generate slack integration', () => {
+    expect(integration).toBeDefined()
+    expect(integration.integrationType).toBe(IntegrationType.SLACK)
+  })
+
+  it('should have the correct permitted events', () => {
+    const events = integration.getPermittedEvents()
+    expect(events).toBeDefined()
+    expect(events.size).toBe(26)  
+  })
+
+  it('should have the correct required metadata parameters', () => {
+    const metadata = integration.getRequiredMetadataParameters()
+    expect(metadata).toBeDefined()
+    expect(metadata.size).toBe(3)  
+    expect(metadata.has('botToken')).toBe(true)
+    expect(metadata.has('signingSecret')).toBe(true)  
+    expect(metadata.has('channelId')).toBe(true)
+  })
+})

apps/api/src/integration/plugins/slack/slack.integration.ts

@@ -0,0 +1,122 @@
+import {EventType, IntegrationType} from '@prisma/client'
+import {SlackIntegrationMetadata,IntegrationEventData} from '../../integration.types'
+import {App} from '@slack/bolt'
+import { BaseIntegration } from '../base.integration'
+import { Logger } from '@nestjs/common'
+import { set, string } from 'zod'
+import { MetadataScanner } from '@nestjs/core'
+
+export class SlackIntegration extends BaseIntegration {
+    private readonly logger = new Logger('SlackIntegration')
+    private app : App;
+    constructor() {
+        super(IntegrationType.SLACK);
+    }
+
+
+public getPermittedEvents(): Set<EventType> {
+    return new Set([
+        EventType.INTEGRATION_ADDED,
+        EventType.INTEGRATION_UPDATED,
+        EventType.INTEGRATION_DELETED,
+        EventType.INVITED_TO_WORKSPACE,
+        EventType.REMOVED_FROM_WORKSPACE,
+        EventType.ACCEPTED_INVITATION,
+        EventType.DECLINED_INVITATION,
+        EventType.CANCELLED_INVITATION,
+        EventType.LEFT_WORKSPACE,
+        EventType.WORKSPACE_UPDATED,
+        EventType.WORKSPACE_CREATED,
+        EventType.WORKSPACE_ROLE_CREATED,
+        EventType.WORKSPACE_ROLE_UPDATED,
+        EventType.WORKSPACE_ROLE_DELETED,
+        EventType.PROJECT_CREATED,
+        EventType.PROJECT_UPDATED,
+        EventType.PROJECT_DELETED,
+        EventType.SECRET_UPDATED,
+        EventType.SECRET_DELETED,
+        EventType.SECRET_ADDED,
+        EventType.VARIABLE_UPDATED,
+        EventType.VARIABLE_DELETED,
+        EventType.VARIABLE_ADDED,
+        EventType.ENVIRONMENT_UPDATED,
+        EventType.ENVIRONMENT_DELETED,
+        EventType.ENVIRONMENT_ADDED,
+        EventType.INTEGRATION_ADDED,
+        EventType.INTEGRATION_UPDATED,
+        EventType.INTEGRATION_DELETED
+      ])
+}
+
+public getRequiredMetadataParameters(): Set<string> {
+    return new Set(['botToken','signingSecret','channelId'])
+}
+
+async emitEvent(
+    data: IntegrationEventData,
+    metadata: SlackIntegrationMetadata
+) : Promise<void> {
+    this.logger.log(`Emitting event to Slack: ${data.title}`)
+    try{
+      if(!this.app)
+      {
+        this.app = new App({
+            token: metadata.botToken,
+            signingSecret: metadata.signingSecret
+        })
+      }
+      const block = [
+        {
+            type: 'header',
+            text: {
+              type: 'plain_text',
+              text: 'Update occurred on keyshade',
+              emoji: true
+            }
+          },
+          {
+            type: 'section',
+            text: {
+              type: 'mrkdwn',
+              text: `*${data.title ?? 'No title provided'}*\n${data.description ?? 'No description provided'}`
+            }
+          },
+          {
+            type: 'divider'
+          },
+          {
+            type: 'section',
+            fields: [
+              {
+                type: 'mrkdwn',
+                text: `*Event:*\n${data.title}`
+              },
+              {
+                type: 'mrkdwn',
+                text: `*Source:*\n${data.source}`
+              }
+            ]
+          },
+          {
+            type: 'context',
+            elements: [
+              {
+                type: 'mrkdwn',
+                text: '<https://keyshade.xyz|View in Keyshade>'
+              }
+            ]
+          }
+      ];
+      await this.app.client.chat.postMessage({
+               channel: metadata.channelId,
+               blocks: block,
+               text:data.title
+    });
+}
+    catch(error){
+      this.logger.error(`Failed to emit event to Slack: ${error.message}`);
+      console.error(error);
+      throw error;
+    }
+  } 
+}