Merge pull request #650 from akhilmhdh/feat/integrations-page

Feat/integrations page
2026-10-16 05:13:43 +00:00 · 2023-06-17 10:06:30 +02:00
parent db12dafad2 ff567892f9
commit e9eacc445d
30 changed files with 1031 additions and 639 deletions
@@ -1,29 +1,21 @@
 import { Types } from "mongoose";
-import {
-  Bot,
-  BotKey,
-  Secret,
-  ISecret,
-  IUser
-} from "../models";
+import { Bot, BotKey, Secret, ISecret, IUser } from "../models";
 import {
  generateKeyPair,
  encryptSymmetric128BitHexKeyUTF8,
  decryptSymmetric128BitHexKeyUTF8,
-  decryptAsymmetric
-} from '../utils/crypto';
+  decryptAsymmetric,
+} from "../utils/crypto";
 import {
  SECRET_SHARED,
  ALGORITHM_AES_256_GCM,
  ENCODING_SCHEME_UTF8,
-  ENCODING_SCHEME_BASE64
+  ENCODING_SCHEME_BASE64,
 } from "../variables";
-import { 
-  getEncryptionKey, 
-  getRootEncryptionKey,
-  client
-} from "../config";
+import { getEncryptionKey, getRootEncryptionKey, client } from "../config";
 import { InternalServerError } from "../utils/errors";
+import Folder from "../models/folder";
+import { getFolderByPath } from "../services/FolderService";

 /**
 * Create an inactive bot with name [name] for workspace with id [workspaceId]
@@ -40,15 +32,14 @@ export const createBot = async ({
 }) => {
  const encryptionKey = await getEncryptionKey();
  const rootEncryptionKey = await getRootEncryptionKey();
-  
+
  const { publicKey, privateKey } = generateKeyPair();
-  
+
  if (rootEncryptionKey) {
-    const { 
-      ciphertext, 
-      iv, 
-      tag 
-    } = client.encryptSymmetric(privateKey, rootEncryptionKey);
+    const { ciphertext, iv, tag } = client.encryptSymmetric(
+      privateKey,
+      rootEncryptionKey
+    );

    return await new Bot({
      name,
@@ -59,9 +50,8 @@ export const createBot = async ({
      iv,
      tag,
      algorithm: ALGORITHM_AES_256_GCM,
-      keyEncoding: ENCODING_SCHEME_BASE64
+      keyEncoding: ENCODING_SCHEME_BASE64,
    }).save();
-  
  } else if (encryptionKey) {
    const { ciphertext, iv, tag } = encryptSymmetric128BitHexKeyUTF8({
      plaintext: privateKey,
@@ -77,12 +67,12 @@ export const createBot = async ({
      iv,
      tag,
      algorithm: ALGORITHM_AES_256_GCM,
-      keyEncoding: ENCODING_SCHEME_UTF8
+      keyEncoding: ENCODING_SCHEME_UTF8,
    }).save();
  }

  throw InternalServerError({
-    message: 'Failed to create new bot due to missing encryption key'
+    message: "Failed to create new bot due to missing encryption key",
  });
 };

@@ -92,11 +82,11 @@ export const createBot = async ({
 */
 export const getIsWorkspaceE2EEHelper = async (workspaceId: Types.ObjectId) => {
  const botKey = await BotKey.exists({
-    workspace: workspaceId
-  }); 
-  
+    workspace: workspaceId,
+  });
+
  return botKey ? false : true;
-}
+};

 /**
 * Return decrypted secrets for workspace with id [workspaceId]
@@ -108,16 +98,38 @@ export const getIsWorkspaceE2EEHelper = async (workspaceId: Types.ObjectId) => {
 export const getSecretsBotHelper = async ({
  workspaceId,
  environment,
+  secretPath,
 }: {
  workspaceId: Types.ObjectId;
  environment: string;
+  secretPath: string;
 }) => {
  const content = {} as any;
  const key = await getKey({ workspaceId: workspaceId });
+
+  let folderId = "root";
+  const folders = await Folder.findOne({
+    workspace: workspaceId,
+    environment,
+  });
+
+  if (!folders && secretPath !== "/") {
+    throw InternalServerError({ message: "Folder not found" });
+  }
+
+  if (folders) {
+    const folder = getFolderByPath(folders.nodes, secretPath);
+    if (!folder) {
+      throw InternalServerError({ message: "Folder not found" });
+    }
+    folderId = folder.id;
+  }
+
  const secrets = await Secret.find({
    workspace: workspaceId,
    environment,
    type: SECRET_SHARED,
+    folder: folderId,
  });

  secrets.forEach((secret: ISecret) => {
@@ -148,14 +160,17 @@ export const getSecretsBotHelper = async ({
 * @param {String} obj.workspaceId - id of workspace
 * @returns {String} key - decrypted workspace key
 */
-export const getKey = async ({ workspaceId }: { workspaceId: Types.ObjectId }) => {
+export const getKey = async ({
+  workspaceId,
+}: {
+  workspaceId: Types.ObjectId;
+}) => {
  const encryptionKey = await getEncryptionKey();
  const rootEncryptionKey = await getRootEncryptionKey();

  const botKey = await BotKey.findOne({
    workspace: workspaceId,
-  })
-  .populate<{ sender: IUser }>("sender", "publicKey");
+  }).populate<{ sender: IUser }>("sender", "publicKey");

  if (!botKey) throw new Error("Failed to find bot key");

@@ -168,7 +183,12 @@ export const getKey = async ({ workspaceId }: { workspaceId: Types.ObjectId }) =

  if (rootEncryptionKey && bot.keyEncoding === ENCODING_SCHEME_BASE64) {
    // case: encoding scheme is base64
-    const privateKeyBot = client.decryptSymmetric(bot.encryptedPrivateKey, rootEncryptionKey, bot.iv, bot.tag);
+    const privateKeyBot = client.decryptSymmetric(
+      bot.encryptedPrivateKey,
+      rootEncryptionKey,
+      bot.iv,
+      bot.tag
+    );

    return decryptAsymmetric({
      ciphertext: botKey.encryptedKey,
@@ -177,15 +197,14 @@ export const getKey = async ({ workspaceId }: { workspaceId: Types.ObjectId }) =
      privateKey: privateKeyBot,
    });
  } else if (encryptionKey && bot.keyEncoding === ENCODING_SCHEME_UTF8) {
-    
    // case: encoding scheme is utf8
    const privateKeyBot = decryptSymmetric128BitHexKeyUTF8({
      ciphertext: bot.encryptedPrivateKey,
      iv: bot.iv,
      tag: bot.tag,
-      key: encryptionKey
+      key: encryptionKey,
    });
-    
+
    return decryptAsymmetric({
      ciphertext: botKey.encryptedKey,
      nonce: botKey.nonce,
@@ -195,7 +214,8 @@ export const getKey = async ({ workspaceId }: { workspaceId: Types.ObjectId }) =
  }

  throw InternalServerError({
-    message: "Failed to obtain bot's copy of workspace key needed for bot operations"
+    message:
+      "Failed to obtain bot's copy of workspace key needed for bot operations",
  });
 };

@@ -254,4 +274,4 @@ export const decryptSymmetricHelper = async ({
  });

  return plaintext;
-};
+};
@@ -1,26 +1,20 @@
-import { Types } from 'mongoose';
+import { Types } from "mongoose";
+import { Bot, Integration, IntegrationAuth } from "../models";
+import { exchangeCode, exchangeRefresh, syncSecrets } from "../integrations";
+import { BotService } from "../services";
 import {
-    Bot,
-    Integration,
-    IntegrationAuth
-} from '../models';
-import { exchangeCode, exchangeRefresh, syncSecrets } from '../integrations';
-import { BotService } from '../services';
-import {
-    INTEGRATION_VERCEL,
-    INTEGRATION_NETLIFY,
-    ALGORITHM_AES_256_GCM,
-    ENCODING_SCHEME_UTF8
-} from '../variables';
-import { 
-    UnauthorizedRequestError,
-} from '../utils/errors';
+  INTEGRATION_VERCEL,
+  INTEGRATION_NETLIFY,
+  ALGORITHM_AES_256_GCM,
+  ENCODING_SCHEME_UTF8,
+} from "../variables";
+import { UnauthorizedRequestError } from "../utils/errors";

 interface Update {
-    workspace: string;
-    integration: string;
-    teamId?: string;
-    accountId?: string;
+  workspace: string;
+  integration: string;
+  teamId?: string;
+  accountId?: string;
 }

 /**
@@ -31,78 +25,83 @@ interface Update {
 * - 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.integration - name of integration
 * @param {String} obj.code - code
 * @returns {IntegrationAuth} integrationAuth - integration auth after OAuth2 code-token exchange
-*/
+ */
 export const handleOAuthExchangeHelper = async ({
-    workspaceId,
+  workspaceId,
+  integration,
+  code,
+  environment,
+}: {
+  workspaceId: string;
+  integration: string;
+  code: string;
+  environment: string;
+}) => {
+  const bot = await Bot.findOne({
+    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
+  const res = await exchangeCode({
    integration,
    code,
-    environment
-}: {
-    workspaceId: string;
-    integration: string;
-    code: string;
-    environment: string;
-}) => {
-    const bot = await Bot.findOne({
-        workspace: workspaceId,
-        isActive: true
+  });
+
+  const update: Update = {
+    workspace: workspaceId,
+    integration,
+  };
+
+  switch (integration) {
+    case INTEGRATION_VERCEL:
+      update.teamId = res.teamId;
+      break;
+    case INTEGRATION_NETLIFY:
+      update.accountId = res.accountId;
+      break;
+  }
+
+  const integrationAuth = await IntegrationAuth.findOneAndUpdate(
+    {
+      workspace: workspaceId,
+      integration,
+    },
+    update,
+    {
+      new: true,
+      upsert: true,
+    }
+  );
+
+  if (res.refreshToken) {
+    // case: refresh token returned from exchange
+    // set integration auth refresh token
+    await setIntegrationAuthRefreshHelper({
+      integrationAuthId: integrationAuth._id.toString(),
+      refreshToken: res.refreshToken,
    });
-    
-    if (!bot) throw new Error('Bot must be enabled for OAuth2 code-token exchange');
-    
-    // exchange code for access and refresh tokens
-    const res = await exchangeCode({
-        integration,
-        code
+  }
+
+  if (res.accessToken) {
+    // case: access token returned from exchange
+    // set integration auth access token
+    await setIntegrationAuthAccessHelper({
+      integrationAuthId: integrationAuth._id.toString(),
+      accessId: null,
+      accessToken: res.accessToken,
+      accessExpiresAt: res.accessExpiresAt,
    });
-    
-    const update: Update = {
-        workspace: workspaceId,
-        integration
-    }
-    
-    switch (integration) {
-        case INTEGRATION_VERCEL:
-            update.teamId = res.teamId;
-            break;
-        case INTEGRATION_NETLIFY:
-            update.accountId = res.accountId;
-            break;
-    }
-    
-    const integrationAuth = await IntegrationAuth.findOneAndUpdate({
-        workspace: workspaceId,
-        integration
-    }, update, {
-        new: true,
-        upsert: true
-    });
-    
-    if (res.refreshToken) {
-        // case: refresh token returned from exchange
-        // set integration auth refresh token
-        await setIntegrationAuthRefreshHelper({
-            integrationAuthId: integrationAuth._id.toString(),
-            refreshToken: res.refreshToken
-        });
-    }
-    
-    if (res.accessToken) {
-        // case: access token returned from exchange
-        // set integration auth access token
-        await setIntegrationAuthAccessHelper({
-            integrationAuthId: integrationAuth._id.toString(),
-            accessId: null,
-            accessToken: res.accessToken,
-            accessExpiresAt: res.accessExpiresAt
-        });
-    }
-    
-    return integrationAuth;
-}
+  }
+
+  return integrationAuth;
+};
 /**
 * Sync/push environment variables in workspace with id [workspaceId] to
 * all active integrations for that workspace
@@ -110,48 +109,54 @@ export const handleOAuthExchangeHelper = async ({
 * @param {Object} obj.workspaceId - id of workspace
 */
 export const syncIntegrationsHelper = async ({
-    workspaceId,
-    environment
+  workspaceId,
+  environment,
 }: {
-    workspaceId: Types.ObjectId;
-    environment?: string;
+  workspaceId: Types.ObjectId;
+  environment?: string;
 }) => {
-    const integrations = await Integration.find({
-        workspace: workspaceId,
-        ...(environment ? {
-            environment
-        } : {}),
-        isActive: true,
-        app: { $ne: null }
+  const integrations = await Integration.find({
+    workspace: workspaceId,
+    ...(environment
+      ? {
+          environment,
+        }
+      : {}),
+    isActive: true,
+    app: { $ne: null },
+  });
+
+  // for each workspace integration, sync/push secrets
+  // to that integration
+  for await (const integration of integrations) {
+    // get workspace, environment (shared) secrets
+    const secrets = await BotService.getSecrets({
+      // issue here?
+      workspaceId: integration.workspace,
+      environment: integration.environment,
+      secretPath: integration.secretPath,
    });

-    // for each workspace integration, sync/push secrets
-    // to that integration
-    for await (const integration of integrations) {
-        // get workspace, environment (shared) secrets
-        const secrets = await BotService.getSecrets({ // issue here?
-            workspaceId: integration.workspace,
-            environment: integration.environment
-        });
+    const integrationAuth = await IntegrationAuth.findById(
+      integration.integrationAuth
+    );
+    if (!integrationAuth) throw new Error("Failed to find integration auth");

-        const integrationAuth = await IntegrationAuth.findById(integration.integrationAuth);
-        if (!integrationAuth) throw new Error('Failed to find integration auth');
-        
-        // get integration auth access token
-        const access = await getIntegrationAuthAccessHelper({
-            integrationAuthId: integration.integrationAuth
-        });
+    // get integration auth access token
+    const access = await getIntegrationAuthAccessHelper({
+      integrationAuthId: integration.integrationAuth,
+    });

-        // sync secrets to integration
-        await syncSecrets({
-            integration,
-            integrationAuth,
-            secrets,
-            accessId: access.accessId === undefined ? null : access.accessId,
-            accessToken: access.accessToken
-        });
-    }
-}
+    // sync secrets to integration
+    await syncSecrets({
+      integration,
+      integrationAuth,
+      secrets,
+      accessId: access.accessId === undefined ? null : access.accessId,
+      accessToken: access.accessToken,
+    });
+  }
+};

 /**
 * Return decrypted refresh token using the bot's copy
@@ -161,22 +166,29 @@ export const syncIntegrationsHelper = async ({
 * @param {String} obj.integrationAuthId - id of integration auth
 * @param {String} refreshToken - decrypted refresh token
 */
-export const getIntegrationAuthRefreshHelper = async ({ integrationAuthId }: { integrationAuthId: Types.ObjectId }) => {
-    const integrationAuth = await IntegrationAuth
-        .findById(integrationAuthId)
-        .select('+refreshCiphertext +refreshIV +refreshTag');
+export const getIntegrationAuthRefreshHelper = async ({
+  integrationAuthId,
+}: {
+  integrationAuthId: Types.ObjectId;
+}) => {
+  const integrationAuth = await IntegrationAuth.findById(
+    integrationAuthId
+  ).select("+refreshCiphertext +refreshIV +refreshTag");

-    if (!integrationAuth) throw UnauthorizedRequestError({message: 'Failed to locate Integration Authentication credentials'});
-
-    const refreshToken = await BotService.decryptSymmetric({
-        workspaceId: integrationAuth.workspace,
-        ciphertext: integrationAuth.refreshCiphertext as string,
-        iv: integrationAuth.refreshIV as string,
-        tag: integrationAuth.refreshTag as string
+  if (!integrationAuth)
+    throw UnauthorizedRequestError({
+      message: "Failed to locate Integration Authentication credentials",
    });
-    
-    return refreshToken;
-}
+
+  const refreshToken = await BotService.decryptSymmetric({
+    workspaceId: integrationAuth.workspace,
+    ciphertext: integrationAuth.refreshCiphertext as string,
+    iv: integrationAuth.refreshIV as string,
+    tag: integrationAuth.refreshTag as string,
+  });
+
+  return refreshToken;
+};

 /**
 * Return decrypted access token using the bot's copy
@@ -186,50 +198,65 @@ export const getIntegrationAuthRefreshHelper = async ({ integrationAuthId }: { i
 * @param {String} obj.integrationAuthId - id of integration auth
 * @returns {String} accessToken - decrypted access token
 */
-export const getIntegrationAuthAccessHelper = async ({ integrationAuthId }: { integrationAuthId: Types.ObjectId }) => {
-    let accessId;
-    let accessToken;
-    const integrationAuth = await IntegrationAuth
-        .findById(integrationAuthId)
-        .select('workspace integration +accessCiphertext +accessIV +accessTag +accessExpiresAt + refreshCiphertext +accessIdCiphertext +accessIdIV +accessIdTag');
+export const getIntegrationAuthAccessHelper = async ({
+  integrationAuthId,
+}: {
+  integrationAuthId: Types.ObjectId;
+}) => {
+  let accessId;
+  let accessToken;
+  const integrationAuth = await IntegrationAuth.findById(
+    integrationAuthId
+  ).select(
+    "workspace integration +accessCiphertext +accessIV +accessTag +accessExpiresAt + refreshCiphertext +accessIdCiphertext +accessIdIV +accessIdTag"
+  );

-    if (!integrationAuth) throw UnauthorizedRequestError({message: 'Failed to locate Integration Authentication credentials'});
-
-    accessToken = await BotService.decryptSymmetric({
-        workspaceId: integrationAuth.workspace,
-        ciphertext: integrationAuth.accessCiphertext as string,
-        iv: integrationAuth.accessIV as string,
-        tag: integrationAuth.accessTag as string
+  if (!integrationAuth)
+    throw UnauthorizedRequestError({
+      message: "Failed to locate Integration Authentication credentials",
    });

-    if (integrationAuth?.accessExpiresAt && integrationAuth?.refreshCiphertext) {
-        // there is a access token expiration date
-        // and refresh token to exchange with the OAuth2 server
-        
-        if (integrationAuth.accessExpiresAt < new Date()) {
-            // access token is expired
-            const refreshToken = await getIntegrationAuthRefreshHelper({ integrationAuthId });
-            accessToken = await exchangeRefresh({
-                integrationAuth,
-                refreshToken
-            });
-        }
+  accessToken = await BotService.decryptSymmetric({
+    workspaceId: integrationAuth.workspace,
+    ciphertext: integrationAuth.accessCiphertext as string,
+    iv: integrationAuth.accessIV as string,
+    tag: integrationAuth.accessTag as string,
+  });
+
+  if (integrationAuth?.accessExpiresAt && integrationAuth?.refreshCiphertext) {
+    // there is a access token expiration date
+    // and refresh token to exchange with the OAuth2 server
+
+    if (integrationAuth.accessExpiresAt < new Date()) {
+      // access token is expired
+      const refreshToken = await getIntegrationAuthRefreshHelper({
+        integrationAuthId,
+      });
+      accessToken = await exchangeRefresh({
+        integrationAuth,
+        refreshToken,
+      });
    }
-    
-    if (integrationAuth?.accessIdCiphertext && integrationAuth?.accessIdIV && integrationAuth?.accessIdTag) {
-        accessId = await BotService.decryptSymmetric({
-            workspaceId: integrationAuth.workspace,
-            ciphertext: integrationAuth.accessIdCiphertext as string,
-            iv: integrationAuth.accessIdIV as string,
-            tag: integrationAuth.accessIdTag as string
-        });
-    }
-    
-    return ({
-        accessId,
-        accessToken
+  }
+
+  if (
+    integrationAuth?.accessIdCiphertext &&
+    integrationAuth?.accessIdIV &&
+    integrationAuth?.accessIdTag
+  ) {
+    accessId = await BotService.decryptSymmetric({
+      workspaceId: integrationAuth.workspace,
+      ciphertext: integrationAuth.accessIdCiphertext as string,
+      iv: integrationAuth.accessIdIV as string,
+      tag: integrationAuth.accessIdTag as string,
    });
-}
+  }
+
+  return {
+    accessId,
+    accessToken,
+  };
+};

 /**
 * Encrypt refresh token [refreshToken] using the bot's copy
@@ -240,41 +267,43 @@ export const getIntegrationAuthAccessHelper = async ({ integrationAuthId }: { in
 * @param {String} obj.refreshToken - refresh token
 */
 export const setIntegrationAuthRefreshHelper = async ({
-    integrationAuthId,
-    refreshToken
+  integrationAuthId,
+  refreshToken,
 }: {
-    integrationAuthId: string;
-    refreshToken: string;
+  integrationAuthId: string;
+  refreshToken: string;
 }) => {
-    
-    let integrationAuth = await IntegrationAuth
-        .findById(integrationAuthId);
-    
-    if (!integrationAuth) throw new Error('Failed to find integration auth');
-    
-    const obj = await BotService.encryptSymmetric({
-        workspaceId: integrationAuth.workspace,
-        plaintext: refreshToken
-    });
-    
-    integrationAuth = await IntegrationAuth.findOneAndUpdate({
-        _id: integrationAuthId
-    }, {
-        refreshCiphertext: obj.ciphertext,
-        refreshIV: obj.iv,
-        refreshTag: obj.tag,
-        algorithm: ALGORITHM_AES_256_GCM,
-        keyEncoding: ENCODING_SCHEME_UTF8
-    }, {
-        new: true
-    });
-    
-    return integrationAuth;
-}
+  let integrationAuth = await IntegrationAuth.findById(integrationAuthId);
+
+  if (!integrationAuth) throw new Error("Failed to find integration auth");
+
+  const obj = await BotService.encryptSymmetric({
+    workspaceId: integrationAuth.workspace,
+    plaintext: refreshToken,
+  });
+
+  integrationAuth = await IntegrationAuth.findOneAndUpdate(
+    {
+      _id: integrationAuthId,
+    },
+    {
+      refreshCiphertext: obj.ciphertext,
+      refreshIV: obj.iv,
+      refreshTag: obj.tag,
+      algorithm: ALGORITHM_AES_256_GCM,
+      keyEncoding: ENCODING_SCHEME_UTF8,
+    },
+    {
+      new: true,
+    }
+  );
+
+  return integrationAuth;
+};

 /**
 * Encrypt access token [accessToken] and (optionally) access id [accessId]
- * using the bot's copy of the workspace key for workspace belonging to 
+ * using the bot's copy of the workspace key for workspace belonging to
 * integration auth with id [integrationAuthId] and store it along with [accessExpiresAt]
 * @param {Object} obj
 * @param {String} obj.integrationAuthId - id of integration auth
@@ -282,48 +311,52 @@ export const setIntegrationAuthRefreshHelper = async ({
 * @param {Date} obj.accessExpiresAt - expiration date of access token
 */
 export const setIntegrationAuthAccessHelper = async ({
-    integrationAuthId,
-    accessId,
-    accessToken,
-    accessExpiresAt
+  integrationAuthId,
+  accessId,
+  accessToken,
+  accessExpiresAt,
 }: {
-    integrationAuthId: string;
-    accessId: string | null;
-    accessToken: string;
-    accessExpiresAt: Date | undefined;
+  integrationAuthId: string;
+  accessId: string | null;
+  accessToken: string;
+  accessExpiresAt: Date | undefined;
 }) => {
-    let integrationAuth = await IntegrationAuth.findById(integrationAuthId);
-    
-    if (!integrationAuth) throw new Error('Failed to find integration auth');
-    
-    const encryptedAccessTokenObj = await BotService.encryptSymmetric({
-        workspaceId: integrationAuth.workspace,
-        plaintext: accessToken
+  let integrationAuth = await IntegrationAuth.findById(integrationAuthId);
+
+  if (!integrationAuth) throw new Error("Failed to find integration auth");
+
+  const encryptedAccessTokenObj = await BotService.encryptSymmetric({
+    workspaceId: integrationAuth.workspace,
+    plaintext: accessToken,
+  });
+
+  let encryptedAccessIdObj;
+  if (accessId) {
+    encryptedAccessIdObj = await BotService.encryptSymmetric({
+      workspaceId: integrationAuth.workspace,
+      plaintext: accessId,
    });
-    
-    let encryptedAccessIdObj;
-    if (accessId) {
-        encryptedAccessIdObj = await BotService.encryptSymmetric({
-            workspaceId: integrationAuth.workspace,
-            plaintext: accessId
-        }); 
+  }
+
+  integrationAuth = await IntegrationAuth.findOneAndUpdate(
+    {
+      _id: integrationAuthId,
+    },
+    {
+      accessIdCiphertext: encryptedAccessIdObj?.ciphertext ?? undefined,
+      accessIdIV: encryptedAccessIdObj?.iv ?? undefined,
+      accessIdTag: encryptedAccessIdObj?.tag ?? undefined,
+      accessCiphertext: encryptedAccessTokenObj.ciphertext,
+      accessIV: encryptedAccessTokenObj.iv,
+      accessTag: encryptedAccessTokenObj.tag,
+      accessExpiresAt,
+      algorithm: ALGORITHM_AES_256_GCM,
+      keyEncoding: ENCODING_SCHEME_UTF8,
+    },
+    {
+      new: true,
    }
-    
-    integrationAuth = await IntegrationAuth.findOneAndUpdate({
-        _id: integrationAuthId
-    }, {
-        accessIdCiphertext: encryptedAccessIdObj?.ciphertext ?? undefined,
-        accessIdIV: encryptedAccessIdObj?.iv ?? undefined,
-        accessIdTag: encryptedAccessIdObj?.tag ?? undefined,
-        accessCiphertext: encryptedAccessTokenObj.ciphertext,
-        accessIV: encryptedAccessTokenObj.iv,
-        accessTag: encryptedAccessTokenObj.tag,
-        accessExpiresAt,
-        algorithm: ALGORITHM_AES_256_GCM,
-        keyEncoding: ENCODING_SCHEME_UTF8
-    }, {
-        new: true
-    });
-    
-    return integrationAuth;
-}
+  );
+
+  return integrationAuth;
+};