Begin developing bot, event, and integration pipeline

backend/src/services/ActionService.ts

@@ -0,0 +1,54 @@
+import * as Sentry from '@sentry/node';
+import { IBot } from '../models';
+import { ACTION_PUSH_TO_HEROKU } from '../variables';
+import { actionPushToHeroku } from '../actions';
+
+interface Event {
+    name: string;
+    workspaceId: string;
+    payload: any;
+}
+
+/**
+ * Class to handle actions
+ */
+class ActionService {
+    /**
+     * @param {Object} obj
+     * @param {String} action - name of action to trigger
+     * @param {Event} event 
+     * @param {String} obj.event.name - name of event
+     * @param {String} obj.event.workspaceId - id of workspace that event is part of
+     * @param {Object} obj.event.payload - payload of event (depends on event)
+     * @param bot
+     * @returns 
+     */
+    static async handleAction({
+        action,
+        event,
+        bot
+    }: {
+        action: string;
+        event: Event;
+        bot: IBot;
+    }) {
+        try {
+            switch (action) {
+                case ACTION_PUSH_TO_HEROKU:
+                    actionPushToHeroku({
+                        event,
+                        bot
+                    });
+                    return;
+                default:
+                    return;
+            }
+        } catch (err) {
+            console.error('EventService err', err);
+            Sentry.setUser(null);
+            Sentry.captureException(err);
+        }
+    }
+}
+
+export default ActionService;

backend/src/services/BotService.ts

@@ -0,0 +1,108 @@
+import { 
+    Bot,
+    IBot,
+    BotKey,
+    IBotKey,
+    IUser,
+    Secret
+} from '../models';
+import * as Sentry from '@sentry/node';
+import {
+    decryptAsymmetric,
+    decryptSymmetric
+} from '../utils/crypto';
+import {
+    ENCRYPTION_KEY
+} from '../config';
+
+/**
+ * Class to handle bot actions
+ */
+class BotService {
+    
+    /**
+     * Return decrypted secrets using bot
+     * @param {Object} obj
+     * @param {String} obj.workspaceId - id of workspace of secrets
+     * @param {String} obj.environment - environment for secrets
+     */
+    static async decryptSecrets({
+        workspaceId,
+        environment
+    }: {
+        workspaceId: string;
+        environment: string;
+    }) {
+
+        let content: any = {};
+        let bot;
+        let botKey;
+        try {
+            
+            // find bot
+            bot = await Bot.findOne({
+                workspace: workspaceId,
+                isActive: true
+            });
+            
+            if (!bot) throw new Error('Failed to find bot');
+            
+            // find bot key
+            botKey = await BotKey.findOne({
+                workspace: workspaceId
+            }).populate<{ sender: IUser }>('sender');
+            
+            if (!botKey) throw new Error('Failed to find bot key');
+            
+            // decrypt bot private key
+            const privateKey = decryptSymmetric({
+                ciphertext: bot.encryptedPrivateKey,
+                iv: bot.iv,
+                tag: bot.tag,
+                key: ENCRYPTION_KEY
+            });
+            
+            // decrypt workspace key
+            const key = decryptAsymmetric({
+                ciphertext: botKey.encryptedKey,
+                nonce: botKey.nonce,
+                publicKey: botKey.sender.publicKey as string,
+                privateKey
+            });
+            
+            // decrypt secrets
+            const secrets = await Secret.find({
+                workspace: workspaceId,
+                environment
+            });
+
+            secrets.forEach(secret => {
+                // KEY, VALUE
+                const secretKey = decryptSymmetric({
+                    ciphertext: secret.secretKeyCiphertext,
+                    iv: secret.secretKeyIV,
+                    tag: secret.secretKeyTag,
+                    key
+                });
+                
+                const secretValue = decryptSymmetric({
+                    ciphertext: secret.secretValueCiphertext,
+                    iv: secret.secretValueIV,
+                    tag: secret.secretValueTag,
+                    key
+                });
+                
+                content[secretKey] = secretValue;
+            });
+            
+        } catch (err) {
+            console.error('BotService');
+            Sentry.setUser(null);
+            Sentry.captureException(err);
+        }
+        
+        return content;
+    }
+}
+
+export default BotService;

backend/src/services/EventService.ts

@@ -0,0 +1,75 @@
+import { Bot, IBot, BotSequence } from '../models';
+import * as Sentry from '@sentry/node';
+import ActionService from './ActionService';
+
+interface Event {
+    name: string;
+    workspaceId: string;
+    payload: any;
+}
+
+/**
+ * Class to handle events. TODO: elaborate DOCSTRING.
+ */
+class EventService {
+    /**
+     * Check if any bot sequences exist for event and forward
+     * bot sequence details to ActionService for execution
+     * @param {Object} obj
+     * @param {Event} obj.event - an event
+     * @param {String} obj.event.name - name of event
+     * @param {String} obj.event.workspaceId - id of workspace that event is part of
+     * @param {Object} obj.event.payload - payload of event (depends on event)
+     */
+    static async handleEvent({ event }: { event: Event }): Promise<void> {
+        let botSequences;
+        let bot: IBot | null;
+        try {
+            
+            console.log('EventService');
+            const { workspaceId } = event;
+
+            bot = await Bot.findOne({
+                workspace: workspaceId,
+                isActive: true
+            });
+            
+            console.log('A', bot);
+            // case: bot doesn't exist
+            if (!bot) {
+                return;
+            }
+            
+            botSequences = await BotSequence.find({
+                bot: bot._id,
+                event: event.name
+            });
+
+            console.log('B', botSequences);
+            
+            // case: bot sequences don't exist
+            if (botSequences.length === 0) return;
+
+            console.log('C');
+            
+            return;
+
+            // // execute event sequences
+            // botSequences.forEach(botSequence => {
+            //     // sequence.actions
+            //     ActionService.handleAction({
+            //         action: botSequence.action,
+            //         event,
+            //         bot: bot as IBot
+            //     });
+            // });
+            
+        } catch (err) {
+            console.error('EventService err', err);
+            Sentry.setUser(null);
+            Sentry.captureException(err);
+        }
+    }
+}
+
+export default EventService;

backend/src/services/IntegrationService.ts

@@ -0,0 +1,93 @@
+import * as Sentry from '@sentry/node';
+import {
+    Integration,
+    Bot,
+    BotSequence
+} from '../models';
+import { exchangeCode } from '../integrations';
+import { processOAuthTokenRes2 } from '../helpers/integrationAuth';
+import { 
+    ENV_DEV, 
+    EVENT_PUSH_SECRETS
+} from '../variables';
+
+/**
+ * Class to handle integrations
+ */
+class IntegrationService {
+    
+    /**
+     * Perform OAuth2 code-token exchange for workspace with id [workspaceId] and integration
+     * named [integration]
+     * - Store integration access and refresh tokens returned from the OAuth2 code-token exchange
+     * - Add placeholder inactive integration
+     * - Create bot sequence for integration
+     * @param {Object} obj
+     * @param {String} obj.workspaceId - id of workspace
+     * @param {String} obj.integration - name of integration 
+     * @param {String} obj.code - code
+     */
+    static async handleOAuthExchange({ 
+        workspaceId,
+        integration,
+        code
+    }: { 
+        workspaceId: string;
+        integration: string;
+        code: string;
+    }) {
+        console.log('IntegrationService > handleO')
+        let action;
+        try {
+            
+            const bot = await Bot.find({
+                workspace: workspaceId,
+                isActive: true
+            });
+            
+            if (!bot) throw new Error('Bot must be enabled for OAuth2 code-token exchange');
+            
+            // exchange code for access and refresh tokens
+            let res = await exchangeCode({
+                integration,
+                code
+            });
+            
+            const integrationAuth = await processOAuthTokenRes2({
+                workspaceId,
+                integration,
+                accessToken: res.accessToken,
+                accessExpiresAt: res.accessExpiresAt,
+                refreshToken: res.refreshToken
+            });
+
+            await Integration.findOneAndUpdate(
+                { workspace: workspaceId, integration },
+                {
+                    workspace: workspaceId,
+                    environment: ENV_DEV,
+                    isActive: false,
+                    app: null,
+                    integration,
+                    integrationAuth: integrationAuth._id
+                },
+                { upsert: true, new: true }
+		    );
+            
+            // add bot sequence
+            await BotSequence.findOneAndUpdate({
+                bot: bot._id,
+                name: integration + 'sequence',
+                event: EVENT_PUSH_SECRETS,
+                action
+            });
+        } catch (err) {
+            console.error('IntegrationService error', err);
+            Sentry.setUser(null);
+            Sentry.captureException(err);
+            throw new Error('Failed to handle OAuth2 code-token exchange')
+        }
+    }
+}
+
+export default IntegrationService;

backend/src/services/index.ts

@@ -1,5 +1,13 @@
 import postHogClient from './PostHogClient';
+import BotService from './BotService';
+import EventService from './EventService';
+import ActionService from './ActionService';
+import IntegrationService from './IntegrationService';
 
 export {
-    postHogClient
+    postHogClient,
+    BotService,
+    EventService,
+    ActionService,
+    IntegrationService
 }