Add eslint rule and fix as many issues as possible

backend/src/controllers/v1/authController.ts

@@ -1,36 +1,36 @@
-import { Request, Response } from 'express';
-import fs from 'fs';
-import path from 'path';
-import jwt from 'jsonwebtoken';
-import * as bigintConversion from 'bigint-conversion';
+import { Request, Response } from "express";
+import fs from "fs";
+import path from "path";
+import jwt from "jsonwebtoken";
+import * as bigintConversion from "bigint-conversion";
 // eslint-disable-next-line @typescript-eslint/no-var-requires
-const jsrp = require('jsrp');
+const jsrp = require("jsrp");
 import { 
-  User, 
-  LoginSRPDetail,
-  TokenVersion
-} from '../../models';
-import { createToken, issueAuthTokens, clearTokens } from '../../helpers/auth';
-import { checkUserDevice } from '../../helpers/user';
+  LoginSRPDetail, 
+  TokenVersion,
+  User,
+} from "../../models";
+import { clearTokens, createToken, issueAuthTokens } from "../../helpers/auth";
+import { checkUserDevice } from "../../helpers/user";
 import {
   ACTION_LOGIN,
   ACTION_LOGOUT,
-  AUTH_MODE_JWT
-} from '../../variables';
+  AUTH_MODE_JWT,
+} from "../../variables";
 import { 
   BadRequestError,
-  UnauthorizedRequestError
-} from '../../utils/errors';
-import { EELogService } from '../../ee/services';
-import { getChannelFromUserAgent } from '../../utils/posthog';
+  UnauthorizedRequestError,
+} from "../../utils/errors";
+import { EELogService } from "../../ee/services";
+import { getChannelFromUserAgent } from "../../utils/posthog";
 import {
-  getJwtRefreshSecret,
+  getHttpsEnabled,
   getJwtAuthLifetime,
   getJwtAuthSecret,
-  getHttpsEnabled
-} from '../../config';
+  getJwtRefreshSecret,
+} from "../../config";
 
-declare module 'jsonwebtoken' {
+declare module "jsonwebtoken" {
   export interface UserIDJwtPayload extends jwt.JwtPayload {
     userId: string;
     refreshVersion?: number;
@@ -46,20 +46,20 @@ declare module 'jsonwebtoken' {
 export const login1 = async (req: Request, res: Response) => {
   const {
     email,
-    clientPublicKey
+    clientPublicKey,
   }: { email: string; clientPublicKey: string } = req.body;
 
   const user = await User.findOne({
-    email
-  }).select('+salt +verifier');
+    email,
+  }).select("+salt +verifier");
 
-  if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
   const server = new jsrp.server();
   server.init(
     {
       salt: user.salt,
-      verifier: user.verifier
+      verifier: user.verifier,
     },
     async () => {
       // generate server-side public key
@@ -73,7 +73,7 @@ export const login1 = async (req: Request, res: Response) => {
 
       return res.status(200).send({
         serverPublicKey,
-        salt: user.salt
+        salt: user.salt,
       });
     }
   );
@@ -89,10 +89,10 @@ export const login1 = async (req: Request, res: Response) => {
 export const login2 = async (req: Request, res: Response) => {
   const { email, clientProof } = req.body;
   const user = await User.findOne({
-    email
-  }).select('+salt +verifier +publicKey +encryptedPrivateKey +iv +tag');
+    email,
+  }).select("+salt +verifier +publicKey +encryptedPrivateKey +iv +tag");
 
-  if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
   const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: email })
 
@@ -105,7 +105,7 @@ export const login2 = async (req: Request, res: Response) => {
     {
       salt: user.salt,
       verifier: user.verifier,
-      b: loginSRPDetailFromDB.serverBInt
+      b: loginSRPDetailFromDB.serverBInt,
     },
     async () => {
       server.setClientPublicKey(loginSRPDetailFromDB.clientPublicKey);
@@ -117,33 +117,33 @@ export const login2 = async (req: Request, res: Response) => {
         await checkUserDevice({
           user,
           ip: req.realIP,
-          userAgent: req.headers['user-agent'] ?? ''
+          userAgent: req.headers["user-agent"] ?? "",
         });
 
         const tokens = await issueAuthTokens({ 
           userId: user._id,
           ip: req.realIP,
-          userAgent: req.headers['user-agent'] ?? ''
+          userAgent: req.headers["user-agent"] ?? "",
         });
 
         // store (refresh) token in httpOnly cookie
-        res.cookie('jid', tokens.refreshToken, {
+        res.cookie("jid", tokens.refreshToken, {
           httpOnly: true,
-          path: '/',
-          sameSite: 'strict',
-          secure: await getHttpsEnabled()
+          path: "/",
+          sameSite: "strict",
+          secure: await getHttpsEnabled(),
         });
 
         const loginAction = await EELogService.createAction({
           name: ACTION_LOGIN,
-          userId: user._id
+          userId: user._id,
         });
 
         loginAction && await EELogService.createLog({
           userId: user._id,
           actions: [loginAction],
-          channel: getChannelFromUserAgent(req.headers['user-agent']),
-          ipAddress: req.realIP
+          channel: getChannelFromUserAgent(req.headers["user-agent"]),
+          ipAddress: req.realIP,
         });
 
         // return (access) token in response
@@ -152,12 +152,12 @@ export const login2 = async (req: Request, res: Response) => {
           publicKey: user.publicKey,
           encryptedPrivateKey: user.encryptedPrivateKey,
           iv: user.iv,
-          tag: user.tag
+          tag: user.tag,
         });
       }
 
       return res.status(400).send({
-        message: 'Failed to authenticate. Try again?'
+        message: "Failed to authenticate. Try again?",
       });
     }
   );
@@ -175,51 +175,51 @@ export const logout = async (req: Request, res: Response) => {
   }
 
   // clear httpOnly cookie
-  res.cookie('jid', '', {
+  res.cookie("jid", "", {
     httpOnly: true,
-    path: '/',
-    sameSite: 'strict',
-    secure: (await getHttpsEnabled()) as boolean
+    path: "/",
+    sameSite: "strict",
+    secure: (await getHttpsEnabled()) as boolean,
   });
 
   const logoutAction = await EELogService.createAction({
     name: ACTION_LOGOUT,
-    userId: req.user._id
+    userId: req.user._id,
   });
 
   logoutAction && await EELogService.createLog({
     userId: req.user._id,
     actions: [logoutAction],
-    channel: getChannelFromUserAgent(req.headers['user-agent']),
-    ipAddress: req.realIP
+    channel: getChannelFromUserAgent(req.headers["user-agent"]),
+    ipAddress: req.realIP,
   });
 
   return res.status(200).send({
-    message: 'Successfully logged out.'
+    message: "Successfully logged out.",
   });
 };
 
 export const getCommonPasswords = async (req: Request, res: Response) => {
   const commonPasswords = fs.readFileSync(
-		path.resolve(__dirname, '../../data/' + 'common_passwords.txt'),
-		'utf8'
-	).split('\n');	
+		path.resolve(__dirname, "../../data/" + "common_passwords.txt"),
+		"utf8"
+	).split("\n");	
 
   return res.status(200).send(commonPasswords);
 }
 
 export const revokeAllSessions = async (req: Request, res: Response) => {
   await TokenVersion.updateMany({
-    user: req.user._id
+    user: req.user._id,
   }, {
     $inc: {
       refreshVersion: 1,
-      accessVersion: 1
-    }
+      accessVersion: 1,
+    },
   });
 
   return res.status(200).send({
-    message: 'Successfully revoked all sessions.'
+    message: "Successfully revoked all sessions.",
   }); 
 }
 
@@ -231,7 +231,7 @@ export const revokeAllSessions = async (req: Request, res: Response) => {
  */
 export const checkAuth = async (req: Request, res: Response) => {
   return res.status(200).send({
-    message: 'Authenticated'
+    message: "Authenticated",
   });
 }
 
@@ -245,7 +245,7 @@ export const getNewToken = async (req: Request, res: Response) => {
   const refreshToken = req.cookies.jid;
 
   if (!refreshToken) {
-    throw new Error('Failed to find refresh token in request cookies');
+    throw new Error("Failed to find refresh token in request cookies");
   }
 
   const decodedToken = <jwt.UserIDJwtPayload>(
@@ -253,35 +253,35 @@ export const getNewToken = async (req: Request, res: Response) => {
   );
 
   const user = await User.findOne({
-    _id: decodedToken.userId
-  }).select('+publicKey +refreshVersion +accessVersion');
+    _id: decodedToken.userId,
+  }).select("+publicKey +refreshVersion +accessVersion");
 
-  if (!user) throw new Error('Failed to authenticate unfound user');
+  if (!user) throw new Error("Failed to authenticate unfound user");
   if (!user?.publicKey)
-    throw new Error('Failed to authenticate not fully set up account');
+    throw new Error("Failed to authenticate not fully set up account");
   
   const tokenVersion = await TokenVersion.findById(decodedToken.tokenVersionId);
 
   if (!tokenVersion) throw UnauthorizedRequestError({
-    message: 'Failed to validate refresh token'
+    message: "Failed to validate refresh token",
   });
 
   if (decodedToken.refreshVersion !== tokenVersion.refreshVersion) throw BadRequestError({
-    message: 'Failed to validate refresh token'
+    message: "Failed to validate refresh token",
   });
 
   const token = createToken({
     payload: {
       userId: decodedToken.userId,
       tokenVersionId: tokenVersion._id.toString(),
-      accessVersion: tokenVersion.refreshVersion
+      accessVersion: tokenVersion.refreshVersion,
     },
     expiresIn: await getJwtAuthLifetime(),
-    secret: await getJwtAuthSecret()
+    secret: await getJwtAuthSecret(),
   });
 
   return res.status(200).send({
-    token
+    token,
   });
 };
 

backend/src/controllers/v1/botController.ts

@@ -1,7 +1,7 @@
-import { Request, Response } from 'express';
-import { Types } from 'mongoose';
-import { Bot, BotKey } from '../../models';
-import { createBot } from '../../helpers/bot';
+import { Request, Response } from "express";
+import { Types } from "mongoose";
+import { Bot, BotKey } from "../../models";
+import { createBot } from "../../helpers/bot";
 
 interface BotKey {
     encryptedKey: string;
@@ -19,20 +19,20 @@ export const getBotByWorkspaceId = async (req: Request, res: Response) => {
   const { workspaceId } = req.params;
 
   let bot = await Bot.findOne({
-      workspace: workspaceId
+      workspace: workspaceId,
   });
   
   if (!bot) {
       // case: bot doesn't exist for workspace with id [workspaceId]
       // -> create a new bot and return it
       bot = await createBot({
-          name: 'Infisical Bot',
-          workspaceId: new Types.ObjectId(workspaceId)
+          name: "Infisical Bot",
+          workspaceId: new Types.ObjectId(workspaceId),
       });
   }
     
   return res.status(200).send({
-      bot
+      bot,
   });
 };
 
@@ -49,40 +49,40 @@ export const setBotActiveState = async (req: Request, res: Response) => {
         // bot state set to active -> share workspace key with bot
         if (!botKey?.encryptedKey || !botKey?.nonce) {
             return res.status(400).send({
-                message: 'Failed to set bot state to active - missing bot key'
+                message: "Failed to set bot state to active - missing bot key",
             });
         }
         
         await BotKey.findOneAndUpdate({
-            workspace: req.bot.workspace
+            workspace: req.bot.workspace,
         }, {
             encryptedKey: botKey.encryptedKey,
             nonce: botKey.nonce,
             sender: req.user._id,
             bot: req.bot._id,
-            workspace: req.bot.workspace
+            workspace: req.bot.workspace,
         }, {
             upsert: true,
-            new: true
+            new: true,
         });
     } else {
         // case: bot state set to inactive -> delete bot's workspace key
         await BotKey.deleteOne({
-            bot: req.bot._id
+            bot: req.bot._id,
         });
     }
 
-    let bot = await Bot.findOneAndUpdate({
-        _id: req.bot._id
+    const bot = await Bot.findOneAndUpdate({
+        _id: req.bot._id,
     }, {
-        isActive
+        isActive,
     }, {
-        new: true
+        new: true,
     });
     
-    if (!bot) throw new Error('Failed to update bot active state');
+    if (!bot) throw new Error("Failed to update bot active state");
     
     return res.status(200).send({
-        bot
+        bot,
     });
 };

backend/src/controllers/v1/index.ts

@@ -1,19 +1,19 @@
-import * as authController from './authController';
-import * as botController from './botController';
-import * as integrationAuthController from './integrationAuthController';
-import * as integrationController from './integrationController';
-import * as keyController from './keyController';
-import * as membershipController from './membershipController';
-import * as membershipOrgController from './membershipOrgController';
-import * as organizationController from './organizationController';
-import * as passwordController from './passwordController';
-import * as secretController from './secretController';
-import * as serviceTokenController from './serviceTokenController';
-import * as signupController from './signupController';
-import * as stripeController from './stripeController';
-import * as userActionController from './userActionController';
-import * as userController from './userController';
-import * as workspaceController from './workspaceController';
+import * as authController from "./authController";
+import * as botController from "./botController";
+import * as integrationAuthController from "./integrationAuthController";
+import * as integrationController from "./integrationController";
+import * as keyController from "./keyController";
+import * as membershipController from "./membershipController";
+import * as membershipOrgController from "./membershipOrgController";
+import * as organizationController from "./organizationController";
+import * as passwordController from "./passwordController";
+import * as secretController from "./secretController";
+import * as serviceTokenController from "./serviceTokenController";
+import * as signupController from "./signupController";
+import * as stripeController from "./stripeController";
+import * as userActionController from "./userActionController";
+import * as userController from "./userController";
+import * as workspaceController from "./workspaceController";
 
 export {
 	authController,
@@ -31,5 +31,5 @@ export {
 	stripeController,
 	userActionController,
 	userController,
-	workspaceController
+	workspaceController,
 };

backend/src/controllers/v1/integrationAuthController.ts

@@ -1,21 +1,17 @@
-import { Request, Response } from 'express';
-import { Types } from 'mongoose';
+import { Request, Response } from "express";
+import { Types } from "mongoose";
+import { standardRequest } from "../../config/request";
+import { getApps, getTeams, revokeAccess } from "../../integrations";
+import { Bot, IntegrationAuth } from "../../models";
+import { IntegrationService } from "../../services";
 import {
-	IntegrationAuth,
-	Bot 
-} from '../../models';
-import { ALGORITHM_AES_256_GCM, ENCODING_SCHEME_UTF8, INTEGRATION_SET, getIntegrationOptions as getIntegrationOptionsFunc } from '../../variables';
-import { IntegrationService } from '../../services';
-import {
-	getApps, 
-	getTeams,
-	revokeAccess 
-} from '../../integrations';
-import {
-	INTEGRATION_VERCEL_API_URL,
-	INTEGRATION_RAILWAY_API_URL
-} from '../../variables';
-import { standardRequest } from '../../config/request';
+  ALGORITHM_AES_256_GCM,
+  ENCODING_SCHEME_UTF8,
+  INTEGRATION_RAILWAY_API_URL,
+  INTEGRATION_SET,
+  INTEGRATION_VERCEL_API_URL,
+  getIntegrationOptions as getIntegrationOptionsFunc
+} from "../../variables";
 
 /***
  * Return integration authorization with id [integrationAuthId]
@@ -23,22 +19,23 @@ import { standardRequest } from '../../config/request';
 export const getIntegrationAuth = async (req: Request, res: Response) => {
   const { integrationAuthId } = req.params;
   const integrationAuth = await IntegrationAuth.findById(integrationAuthId);
-  
-  if (!integrationAuth) return res.status(400).send({
-    message: 'Failed to find integration authorization'
-  });
 
-	return res.status(200).send({
-		integrationAuth
-	});
-}
+  if (!integrationAuth)
+    return res.status(400).send({
+      message: "Failed to find integration authorization"
+    });
+
+  return res.status(200).send({
+    integrationAuth
+  });
+};
 
 export const getIntegrationOptions = async (req: Request, res: Response) => {
-	const INTEGRATION_OPTIONS = await getIntegrationOptionsFunc();
+  const INTEGRATION_OPTIONS = await getIntegrationOptionsFunc();
 
-	return res.status(200).send({
-		integrationOptions: INTEGRATION_OPTIONS,
-	});
+  return res.status(200).send({
+    integrationOptions: INTEGRATION_OPTIONS
+  });
 };
 
 /**
@@ -47,26 +44,22 @@ export const getIntegrationOptions = async (req: Request, res: Response) => {
  * @param res
  * @returns
  */
-export const oAuthExchange = async (
-	req: Request,
-	res: Response
-) => {
+export const oAuthExchange = async (req: Request, res: Response) => {
   const { workspaceId, code, integration } = req.body;
-  if (!INTEGRATION_SET.has(integration))
-    throw new Error('Failed to validate integration');
-  
+  if (!INTEGRATION_SET.has(integration)) throw new Error("Failed to validate integration");
+
   const environments = req.membership.workspace?.environments || [];
-  if(environments.length === 0){
-    throw new Error("Failed to get environments")
+  if (environments.length === 0) {
+    throw new Error("Failed to get environments");
   }
 
   const integrationAuth = await IntegrationService.handleOAuthExchange({
     workspaceId,
     integration,
     code,
-    environment: environments[0].slug,
+    environment: environments[0].slug
   });
-  
+
   return res.status(200).send({
     integrationAuth
   });
@@ -75,69 +68,70 @@ export const oAuthExchange = async (
 /**
  * Save integration access token and (optionally) access id as part of integration
  * [integration] for workspace with id [workspaceId]
- * @param req 
- * @param res 
+ * @param req
+ * @param res
  */
-export const saveIntegrationAccessToken = async (
-  req: Request,
-  res: Response
-) => {
-	// TODO: refactor
-	// TODO: check if access token is valid for each integration
+export const saveIntegrationAccessToken = async (req: Request, res: Response) => {
+  // TODO: refactor
+  // TODO: check if access token is valid for each integration
 
-	let integrationAuth;
-	const {
-		workspaceId,
-		accessId,
-		accessToken,
-		url,
-		namespace,
-		integration
-	}: {
-		workspaceId: string;
-		accessId: string | null;
-		accessToken: string;
-		url: string;
-		namespace: string;
-		integration: string;
-	} = req.body;
+  let integrationAuth;
+  const {
+    workspaceId,
+    accessId,
+    accessToken,
+    url,
+    namespace,
+    integration
+  }: {
+    workspaceId: string;
+    accessId: string | null;
+    accessToken: string;
+    url: string;
+    namespace: string;
+    integration: string;
+  } = req.body;
 
-	const bot = await Bot.findOne({
-		workspace: new Types.ObjectId(workspaceId),
-		isActive: true
-	});
-      
-    if (!bot) throw new Error('Bot must be enabled to save integration access token');
+  const bot = await Bot.findOne({
+    workspace: new Types.ObjectId(workspaceId),
+    isActive: true
+  });
 
-  	integrationAuth = await IntegrationAuth.findOneAndUpdate({
-		workspace: new Types.ObjectId(workspaceId),
-		integration
-    }, {
-		workspace: new Types.ObjectId(workspaceId),
-		integration,
-		url,
-		namespace,
-		algorithm: ALGORITHM_AES_256_GCM,
-		keyEncoding: ENCODING_SCHEME_UTF8
-  	}, {
-		new: true,
-		upsert: true
-    });
-  
-	// encrypt and save integration access details
-	integrationAuth = await IntegrationService.setIntegrationAuthAccess({
-		integrationAuthId: integrationAuth._id.toString(),
-		accessId,
-		accessToken,
-		accessExpiresAt: undefined
-	});
-  
-  	if (!integrationAuth) throw new Error('Failed to save integration access token');
-	
-	return res.status(200).send({
-		integrationAuth
-	});
-}
+  if (!bot) throw new Error("Bot must be enabled to save integration access token");
+
+  integrationAuth = await IntegrationAuth.findOneAndUpdate(
+    {
+      workspace: new Types.ObjectId(workspaceId),
+      integration
+    },
+    {
+      workspace: new Types.ObjectId(workspaceId),
+      integration,
+      url,
+      namespace,
+      algorithm: ALGORITHM_AES_256_GCM,
+      keyEncoding: ENCODING_SCHEME_UTF8
+    },
+    {
+      new: true,
+      upsert: true
+    }
+  );
+
+  // encrypt and save integration access details
+  integrationAuth = await IntegrationService.setIntegrationAuthAccess({
+    integrationAuthId: integrationAuth._id.toString(),
+    accessId,
+    accessToken,
+    accessExpiresAt: undefined
+  });
+
+  if (!integrationAuth) throw new Error("Failed to save integration access token");
+
+  return res.status(200).send({
+    integrationAuth
+  });
+};
 
 /**
  * Return list of applications allowed for integration with integration authorization id [integrationAuthId]
@@ -147,108 +141,108 @@ export const saveIntegrationAccessToken = async (
  */
 export const getIntegrationAuthApps = async (req: Request, res: Response) => {
   const teamId = req.query.teamId as string;
-  
+
   const apps = await getApps({
     integrationAuth: req.integrationAuth,
     accessToken: req.accessToken,
-	accessId: req.accessId,
-    ...teamId && { teamId }
+    accessId: req.accessId,
+    ...(teamId && { teamId })
   });
 
-	return res.status(200).send({
-		apps
-	});
+  return res.status(200).send({
+    apps
+  });
 };
 
 /**
  * Return list of teams allowed for integration with integration authorization id [integrationAuthId]
- * @param req 
- * @param res 
- * @returns 
+ * @param req
+ * @param res
+ * @returns
  */
 export const getIntegrationAuthTeams = async (req: Request, res: Response) => {
-	const teams = await getTeams({
-		integrationAuth: req.integrationAuth,
-		accessToken: req.accessToken
-	});
-	
-	return res.status(200).send({
-		teams
-	});
-}
+  const teams = await getTeams({
+    integrationAuth: req.integrationAuth,
+    accessToken: req.accessToken
+  });
+
+  return res.status(200).send({
+    teams
+  });
+};
 
 /**
  * Return list of available Vercel (preview) branches for Vercel project with
  * id [appId]
- * @param req 
- * @param res 
+ * @param req
+ * @param res
  */
 export const getIntegrationAuthVercelBranches = async (req: Request, res: Response) => {
-	const { integrationAuthId } = req.params;
-	const appId = req.query.appId as string;
-	
-	interface VercelBranch {
-		ref: string;
-		lastCommit: string;
-		isProtected: boolean;
-	}
+  const appId = req.query.appId as string;
 
-	const params = new URLSearchParams({
-		projectId: appId,
-		...(req.integrationAuth.teamId ? {
-			teamId: req.integrationAuth.teamId
-		} : {})
-	});
+  interface VercelBranch {
+    ref: string;
+    lastCommit: string;
+    isProtected: boolean;
+  }
 
-	let branches: string[] = [];
-	
-	if (appId && appId !== '') {
-		const { data }: { data: VercelBranch[] } = await standardRequest.get(
-			`${INTEGRATION_VERCEL_API_URL}/v1/integrations/git-branches`,
-			{
-				params,
-				headers: {
-					Authorization: `Bearer ${req.accessToken}`,
-					'Accept-Encoding': 'application/json'
-				}
-			}
-		);
-		
-		branches = data.map((b) => b.ref);
-	}
+  const params = new URLSearchParams({
+    projectId: appId,
+    ...(req.integrationAuth.teamId
+      ? {
+          teamId: req.integrationAuth.teamId
+        }
+      : {})
+  });
 
-	return res.status(200).send({
-		branches
-	});
-}
+  let branches: string[] = [];
+
+  if (appId && appId !== "") {
+    const { data }: { data: VercelBranch[] } = await standardRequest.get(
+      `${INTEGRATION_VERCEL_API_URL}/v1/integrations/git-branches`,
+      {
+        params,
+        headers: {
+          Authorization: `Bearer ${req.accessToken}`,
+          "Accept-Encoding": "application/json"
+        }
+      }
+    );
+
+    branches = data.map((b) => b.ref);
+  }
+
+  return res.status(200).send({
+    branches
+  });
+};
 
 /**
  * Return list of Railway environments for Railway project with
  * id [appId]
- * @param req 
- * @param res 
+ * @param req
+ * @param res
  */
 export const getIntegrationAuthRailwayEnvironments = async (req: Request, res: Response) => {
-	const { integrationAuthId } = req.params;
-	const appId = req.query.appId as string;
-	
-	interface RailwayEnvironment {
-		node: {
-			id: string;
-			name: string;
-			isEphemeral: boolean;
-		}
-	}
-	
-	interface Environment {
-		environmentId: string;
-		name: string;
-	}
-	
-	let environments: Environment[] = [];
+  const appId = req.query.appId as string;
 
-	if (appId && appId !== '') {
-		const query = `
+  interface RailwayEnvironment {
+    node: {
+      id: string;
+      name: string;
+      isEphemeral: boolean;
+    };
+  }
+
+  interface Environment {
+    environmentId: string;
+    name: string;
+  }
+
+  let environments: Environment[] = [];
+
+  if (appId && appId !== "") {
+    const query = `
 			query GetEnvironments($projectId: String!, $after: String, $before: String, $first: Int, $isEphemeral: Boolean, $last: Int) {
 				environments(projectId: $projectId, after: $after, before: $before, first: $first, isEphemeral: $isEphemeral, last: $last) {
 				edges {
@@ -261,59 +255,68 @@ export const getIntegrationAuthRailwayEnvironments = async (req: Request, res: R
 				}
 			}
 			`;
-		
-		const variables = {
-			projectId: appId
-		}
-		
-		const { data: { data: { environments: { edges } } } } = await standardRequest.post(INTEGRATION_RAILWAY_API_URL, {
-			query,
-			variables,
-		}, {
-			headers: {
-				'Authorization': `Bearer ${req.accessToken}`,
-				'Content-Type': 'application/json',
-			},
-		});
-		
-		environments = edges.map((e: RailwayEnvironment) => {
-			return ({
-				name: e.node.name,
-				environmentId: e.node.id
-			});
-		});
-	}
-	
-	return res.status(200).send({
-		environments
-	});
-}
+
+    const variables = {
+      projectId: appId
+    };
+
+    const {
+      data: {
+        data: {
+          environments: { edges }
+        }
+      }
+    } = await standardRequest.post(
+      INTEGRATION_RAILWAY_API_URL,
+      {
+        query,
+        variables
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${req.accessToken}`,
+          "Content-Type": "application/json"
+        }
+      }
+    );
+
+    environments = edges.map((e: RailwayEnvironment) => {
+      return {
+        name: e.node.name,
+        environmentId: e.node.id
+      };
+    });
+  }
+
+  return res.status(200).send({
+    environments
+  });
+};
 
 /**
  * Return list of Railway services for Railway project with id
  * [appId]
- * @param req 
- * @param res 
+ * @param req
+ * @param res
  */
 export const getIntegrationAuthRailwayServices = async (req: Request, res: Response) => {
-	const { integrationAuthId } = req.params;
-	const appId = req.query.appId as string;
-	
-	interface RailwayService {
-		node: {
-			id: string;
-			name: string;
-		}
-	}
-	
-	interface Service {
-		name: string;
-		serviceId: string;
-	}
-	
-	let services: Service[] = [];
-	
-	const query = `
+  const appId = req.query.appId as string;
+
+  interface RailwayService {
+    node: {
+      id: string;
+      name: string;
+    };
+  }
+
+  interface Service {
+    name: string;
+    serviceId: string;
+  }
+
+  let services: Service[] = [];
+
+  const query = `
       query project($id: String!) {
         project(id: $id) {
           createdAt
@@ -341,31 +344,43 @@ export const getIntegrationAuthRailwayServices = async (req: Request, res: Respo
       }
     `;
 
-	if (appId && appId !== '') {
-		const variables = {
-			id: appId
-		}
-		
-		const { data: { data: { project: { services: { edges } } } } } = await standardRequest.post(INTEGRATION_RAILWAY_API_URL, {
-			query,
-			variables
-		}, {
-			headers: {
-				'Authorization': `Bearer ${req.accessToken}`,
-				'Content-Type': 'application/json',
-			},
-		});
-		
-		services = edges.map((e: RailwayService) => ({
-			name: e.node.name,
-			serviceId: e.node.id
-		}));
-	}
-	
-	return res.status(200).send({
-		services
-	});
-}
+  if (appId && appId !== "") {
+    const variables = {
+      id: appId
+    };
+
+    const {
+      data: {
+        data: {
+          project: {
+            services: { edges }
+          }
+        }
+      }
+    } = await standardRequest.post(
+      INTEGRATION_RAILWAY_API_URL,
+      {
+        query,
+        variables
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${req.accessToken}`,
+          "Content-Type": "application/json"
+        }
+      }
+    );
+
+    services = edges.map((e: RailwayService) => ({
+      name: e.node.name,
+      serviceId: e.node.id
+    }));
+  }
+
+  return res.status(200).send({
+    services
+  });
+};
 
 /**
  * Delete integration authorization with id [integrationAuthId]
@@ -376,10 +391,10 @@ export const getIntegrationAuthRailwayServices = async (req: Request, res: Respo
 export const deleteIntegrationAuth = async (req: Request, res: Response) => {
   const integrationAuth = await revokeAccess({
     integrationAuth: req.integrationAuth,
-    accessToken: req.accessToken,
+    accessToken: req.accessToken
   });
 
   return res.status(200).send({
-    integrationAuth,
+    integrationAuth
   });
 };

backend/src/controllers/v1/keyController.ts

@@ -1,6 +1,6 @@
-import { Request, Response } from 'express';
-import { Key } from '../../models';
-import { findMembership } from '../../helpers/membership';
+import { Request, Response } from "express";
+import { Key } from "../../models";
+import { findMembership } from "../../helpers/membership";
 
 /**
  * Add (encrypted) copy of workspace key for workspace with id [workspaceId] for user with
@@ -16,11 +16,11 @@ export const uploadKey = async (req: Request, res: Response) => {
   // validate membership of receiver
   const receiverMembership = await findMembership({
     user: key.userId,
-    workspace: workspaceId
+    workspace: workspaceId,
   });
 
   if (!receiverMembership) {
-    throw new Error('Failed receiver membership validation for workspace');
+    throw new Error("Failed receiver membership validation for workspace");
   }
 
   await new Key({
@@ -28,11 +28,11 @@ export const uploadKey = async (req: Request, res: Response) => {
     nonce: key.nonce,
     sender: req.user._id,
     receiver: key.userId,
-    workspace: workspaceId
+    workspace: workspaceId,
   }).save();
 
 	return res.status(200).send({
-		message: 'Successfully uploaded key to workspace'
+		message: "Successfully uploaded key to workspace",
 	});
 };
 
@@ -48,16 +48,16 @@ export const getLatestKey = async (req: Request, res: Response) => {
   // get latest key
   const latestKey = await Key.find({
     workspace: workspaceId,
-    receiver: req.user._id
+    receiver: req.user._id,
   })
     .sort({ createdAt: -1 })
     .limit(1)
-    .populate('sender', '+publicKey');
+    .populate("sender", "+publicKey");
 
 	const resObj: any = {};
 
 	if (latestKey.length > 0) {
-		resObj['latestKey'] = latestKey[0];
+		resObj["latestKey"] = latestKey[0];
 	}
 
 	return res.status(200).send(resObj);

backend/src/controllers/v1/membershipController.ts

@@ -1,12 +1,9 @@
-import { Request, Response } from 'express';
-import { Membership, MembershipOrg, User, Key } from '../../models';
-import {
-	findMembership,
-	deleteMembership as deleteMember
-} from '../../helpers/membership';
-import { sendMail } from '../../helpers/nodemailer';
-import { ADMIN, MEMBER, ACCEPTED } from '../../variables';
-import { getSiteURL } from '../../config';
+import { Request, Response } from "express";
+import { Key, Membership, MembershipOrg, User } from "../../models";
+import { deleteMembership as deleteMember, findMembership } from "../../helpers/membership";
+import { sendMail } from "../../helpers/nodemailer";
+import { ACCEPTED, ADMIN, MEMBER } from "../../variables";
+import { getSiteURL } from "../../config";
 
 /**
  * Check that user is a member of workspace with id [workspaceId]
@@ -23,12 +20,12 @@ export const validateMembership = async (req: Request, res: Response) => {
   });
 
   if (!membership) {
-    throw new Error('Failed to validate membership');
+    throw new Error("Failed to validate membership");
   }
 
-	return res.status(200).send({
-		message: 'Workspace membership confirmed'
-	});
+  return res.status(200).send({
+    message: "Workspace membership confirmed"
+  });
 };
 
 /**
@@ -43,12 +40,10 @@ export const deleteMembership = async (req: Request, res: Response) => {
   // check if membership to delete exists
   const membershipToDelete = await Membership.findOne({
     _id: membershipId
-  }).populate('user');
+  }).populate("user");
 
   if (!membershipToDelete) {
-    throw new Error(
-      "Failed to delete workspace membership that doesn't exist"
-    );
+    throw new Error("Failed to delete workspace membership that doesn't exist");
   }
 
   // check if user is a member and admin of the workspace
@@ -59,12 +54,12 @@ export const deleteMembership = async (req: Request, res: Response) => {
   });
 
   if (!membership) {
-    throw new Error('Failed to validate workspace membership');
+    throw new Error("Failed to validate workspace membership");
   }
 
   if (membership.role !== ADMIN) {
     // user is not an admin member of the workspace
-    throw new Error('Insufficient role for deleting workspace membership');
+    throw new Error("Insufficient role for deleting workspace membership");
   }
 
   // delete workspace membership
@@ -72,9 +67,9 @@ export const deleteMembership = async (req: Request, res: Response) => {
     membershipId: membershipToDelete._id.toString()
   });
 
-	return res.status(200).send({
-		deletedMembership
-	});
+  return res.status(200).send({
+    deletedMembership
+  });
 };
 
 /**
@@ -88,7 +83,7 @@ export const changeMembershipRole = async (req: Request, res: Response) => {
   const { role } = req.body;
 
   if (![ADMIN, MEMBER].includes(role)) {
-    throw new Error('Failed to validate role');
+    throw new Error("Failed to validate role");
   }
 
   // validate target membership
@@ -97,7 +92,7 @@ export const changeMembershipRole = async (req: Request, res: Response) => {
   });
 
   if (!membershipToChangeRole) {
-    throw new Error('Failed to find membership to change role');
+    throw new Error("Failed to find membership to change role");
   }
 
   // check if user is a member and admin of target membership's
@@ -108,20 +103,20 @@ export const changeMembershipRole = async (req: Request, res: Response) => {
   });
 
   if (!membership) {
-    throw new Error('Failed to validate membership');
+    throw new Error("Failed to validate membership");
   }
 
   if (membership.role !== ADMIN) {
     // user is not an admin member of the workspace
-    throw new Error('Insufficient role for changing member roles');
+    throw new Error("Insufficient role for changing member roles");
   }
 
   membershipToChangeRole.role = role;
   await membershipToChangeRole.save();
 
-	return res.status(200).send({
-		membership: membershipToChangeRole
-	});
+  return res.status(200).send({
+    membership: membershipToChangeRole
+  });
 };
 
 /**
@@ -136,10 +131,9 @@ export const inviteUserToWorkspace = async (req: Request, res: Response) => {
 
   const invitee = await User.findOne({
     email
-  }).select('+publicKey');
+  }).select("+publicKey");
 
-  if (!invitee || !invitee?.publicKey)
-    throw new Error('Failed to validate invitee');
+  if (!invitee || !invitee?.publicKey) throw new Error("Failed to validate invitee");
 
   // validate invitee's workspace membership - ensure member isn't
   // already a member of the workspace
@@ -148,8 +142,7 @@ export const inviteUserToWorkspace = async (req: Request, res: Response) => {
     workspace: workspaceId
   });
 
-  if (inviteeMembership)
-    throw new Error('Failed to add existing member of workspace');
+  if (inviteeMembership) throw new Error("Failed to add existing member of workspace");
 
   // validate invitee's organization membership - ensure that only
   // (accepted) organization members can be added to the workspace
@@ -159,8 +152,7 @@ export const inviteUserToWorkspace = async (req: Request, res: Response) => {
     status: ACCEPTED
   });
 
-  if (!membershipOrg)
-    throw new Error("Failed to validate invitee's organization membership");
+  if (!membershipOrg) throw new Error("Failed to validate invitee's organization membership");
 
   // get latest key
   const latestKey = await Key.findOne({
@@ -168,29 +160,29 @@ export const inviteUserToWorkspace = async (req: Request, res: Response) => {
     receiver: req.user._id
   })
     .sort({ createdAt: -1 })
-    .populate('sender', '+publicKey');
+    .populate("sender", "+publicKey");
 
   // create new workspace membership
-  const m = await new Membership({
+  await new Membership({
     user: invitee._id,
     workspace: workspaceId,
     role: MEMBER
   }).save();
 
   await sendMail({
-    template: 'workspaceInvitation.handlebars',
-    subjectLine: 'Infisical workspace invitation',
+    template: "workspaceInvitation.handlebars",
+    subjectLine: "Infisical workspace invitation",
     recipients: [invitee.email],
     substitutions: {
       inviterFirstName: req.user.firstName,
       inviterEmail: req.user.email,
       workspaceName: req.membership.workspace.name,
-      callback_url: (await getSiteURL()) + '/login'
+      callback_url: (await getSiteURL()) + "/login"
     }
   });
 
-	return res.status(200).send({
-		invitee,
-		latestKey
-	});
+  return res.status(200).send({
+    invitee,
+    latestKey
+  });
 };

backend/src/controllers/v1/membershipOrgController.ts

@@ -1,15 +1,27 @@
-import { Types } from 'mongoose';
-import { Request, Response } from 'express';
-import { MembershipOrg, Organization, User } from '../../models';
-import { deleteMembershipOrg as deleteMemberFromOrg } from '../../helpers/membershipOrg';
-import { createToken } from '../../helpers/auth';
-import { updateSubscriptionOrgQuantity } from '../../helpers/organization';
-import { sendMail } from '../../helpers/nodemailer';
-import { TokenService } from '../../services';
-import { EELicenseService } from '../../ee/services';
-import { OWNER, ADMIN, MEMBER, ACCEPTED, INVITED, TOKEN_EMAIL_ORG_INVITATION } from '../../variables';
-import { getSiteURL, getJwtSignupLifetime, getJwtSignupSecret, getSmtpConfigured } from '../../config';
-import { validateUserEmail } from '../../validation';
+import { Types } from "mongoose";
+import { Request, Response } from "express";
+import { MembershipOrg, Organization, User } from "../../models";
+import { deleteMembershipOrg as deleteMemberFromOrg } from "../../helpers/membershipOrg";
+import { createToken } from "../../helpers/auth";
+import { updateSubscriptionOrgQuantity } from "../../helpers/organization";
+import { sendMail } from "../../helpers/nodemailer";
+import { TokenService } from "../../services";
+import { EELicenseService } from "../../ee/services";
+import {
+  ACCEPTED,
+  ADMIN,
+  INVITED,
+  MEMBER,
+  OWNER,
+  TOKEN_EMAIL_ORG_INVITATION
+} from "../../variables";
+import {
+  getJwtSignupLifetime,
+  getJwtSignupSecret,
+  getSiteURL,
+  getSmtpConfigured
+} from "../../config";
+import { validateUserEmail } from "../../validation";
 
 /**
  * Delete organization membership with id [membershipOrgId] from organization
@@ -17,18 +29,16 @@ import { validateUserEmail } from '../../validation';
  * @param res
  * @returns
  */
-export const deleteMembershipOrg = async (req: Request, res: Response) => {
+export const deleteMembershipOrg = async (req: Request, _res: Response) => {
   const { membershipOrgId } = req.params;
 
   // check if organization membership to delete exists
   const membershipOrgToDelete = await MembershipOrg.findOne({
     _id: membershipOrgId
-  }).populate('user');
+  }).populate("user");
 
   if (!membershipOrgToDelete) {
-    throw new Error(
-      "Failed to delete organization membership that doesn't exist"
-    );
+    throw new Error("Failed to delete organization membership that doesn't exist");
   }
 
   // check if user is a member and admin of the organization
@@ -39,16 +49,16 @@ export const deleteMembershipOrg = async (req: Request, res: Response) => {
   });
 
   if (!membershipOrg) {
-    throw new Error('Failed to validate organization membership');
+    throw new Error("Failed to validate organization membership");
   }
 
   if (membershipOrg.role !== OWNER && membershipOrg.role !== ADMIN) {
     // user is not an admin member of the organization
-    throw new Error('Insufficient role for deleting organization membership');
+    throw new Error("Insufficient role for deleting organization membership");
   }
 
   // delete organization membership
-  const deletedMembershipOrg = await deleteMemberFromOrg({
+  await deleteMemberFromOrg({
     membershipOrgId: membershipOrgToDelete._id.toString()
   });
 
@@ -56,7 +66,7 @@ export const deleteMembershipOrg = async (req: Request, res: Response) => {
     organizationId: membershipOrg.organization.toString()
   });
 
-	return membershipOrgToDelete;
+  return membershipOrgToDelete;
 };
 
 /**
@@ -66,14 +76,14 @@ export const deleteMembershipOrg = async (req: Request, res: Response) => {
  * @returns
  */
 export const changeMembershipOrgRole = async (req: Request, res: Response) => {
-	// change role for (target) organization membership with id
-	// [membershipOrgId]
+  // change role for (target) organization membership with id
+  // [membershipOrgId]
 
-	let membershipToChangeRole;
+  let membershipToChangeRole;
 
-	return res.status(200).send({
-		membershipOrg: membershipToChangeRole
-	});
+  return res.status(200).send({
+    membershipOrg: membershipToChangeRole
+  });
 };
 
 /**
@@ -84,7 +94,7 @@ export const changeMembershipOrgRole = async (req: Request, res: Response) => {
  * @returns
  */
 export const inviteUserToOrganization = async (req: Request, res: Response) => {
-	let invitee, inviteeMembershipOrg, completeInviteLink;
+  let inviteeMembershipOrg, completeInviteLink;
   const { organizationId, inviteeEmail } = req.body;
   const host = req.headers.host;
   const siteUrl = `${req.protocol}://${host}`;
@@ -96,25 +106,26 @@ export const inviteUserToOrganization = async (req: Request, res: Response) => {
   });
 
   if (!membershipOrg) {
-    throw new Error('Failed to validate organization membership');
+    throw new Error("Failed to validate organization membership");
   }
-  
+
   const plan = await EELicenseService.getPlan(organizationId);
-  
+
   if (plan.memberLimit !== null) {
     // case: limit imposed on number of members allowed
-    
+
     if (plan.membersUsed >= plan.memberLimit) {
       // case: number of members used exceeds the number of members allowed
       return res.status(400).send({
-        message: 'Failed to invite member due to member limit reached. Upgrade plan to invite more members.'
+        message:
+          "Failed to invite member due to member limit reached. Upgrade plan to invite more members."
       });
     }
   }
 
-  invitee = await User.findOne({
+  const invitee = await User.findOne({
     email: inviteeEmail
-  }).select('+publicKey');
+  }).select("+publicKey");
 
   if (invitee) {
     // case: invitee is an existing user
@@ -125,13 +136,10 @@ export const inviteUserToOrganization = async (req: Request, res: Response) => {
     });
 
     if (inviteeMembershipOrg && inviteeMembershipOrg.status === ACCEPTED) {
-      throw new Error(
-        'Failed to invite an existing member of the organization'
-      );
+      throw new Error("Failed to invite an existing member of the organization");
     }
 
     if (!inviteeMembershipOrg) {
-      
       await new MembershipOrg({
         user: invitee,
         inviteEmail: inviteeEmail,
@@ -149,7 +157,7 @@ export const inviteUserToOrganization = async (req: Request, res: Response) => {
 
     if (!inviteeMembershipOrg) {
       // case: invitee has never been invited before
-      
+
       // validate that email is not disposable
       validateUserEmail(inviteeEmail);
 
@@ -165,7 +173,6 @@ export const inviteUserToOrganization = async (req: Request, res: Response) => {
   const organization = await Organization.findOne({ _id: organizationId });
 
   if (organization) {
-
     const token = await TokenService.createToken({
       type: TOKEN_EMAIL_ORG_INVITATION,
       email: inviteeEmail,
@@ -173,8 +180,8 @@ export const inviteUserToOrganization = async (req: Request, res: Response) => {
     });
 
     await sendMail({
-      template: 'organizationInvitation.handlebars',
-      subjectLine: 'Infisical organization invitation',
+      template: "organizationInvitation.handlebars",
+      subjectLine: "Infisical organization invitation",
       recipients: [inviteeEmail],
       substitutions: {
         inviterFirstName: req.user.firstName,
@@ -183,21 +190,23 @@ export const inviteUserToOrganization = async (req: Request, res: Response) => {
         email: inviteeEmail,
         organizationId: organization._id.toString(),
         token,
-        callback_url: (await getSiteURL()) + '/signupinvite'
+        callback_url: (await getSiteURL()) + "/signupinvite"
       }
     });
 
     if (!(await getSmtpConfigured())) {
-      completeInviteLink = `${siteUrl + '/signupinvite'}?token=${token}&to=${inviteeEmail}&organization_id=${organization._id}`
+      completeInviteLink = `${
+        siteUrl + "/signupinvite"
+      }?token=${token}&to=${inviteeEmail}&organization_id=${organization._id}`;
     }
   }
 
   await updateSubscriptionOrgQuantity({ organizationId });
 
-	return res.status(200).send({
-		message: `Sent an invite link to ${req.body.inviteeEmail}`,
-		completeInviteLink
-	});
+  return res.status(200).send({
+    message: `Sent an invite link to ${req.body.inviteeEmail}`,
+    completeInviteLink
+  });
 };
 
 /**
@@ -208,14 +217,10 @@ export const inviteUserToOrganization = async (req: Request, res: Response) => {
  * @returns
  */
 export const verifyUserToOrganization = async (req: Request, res: Response) => {
-	let user;
-  const {
-    email,
-    organizationId,
-    code
-  } = req.body;
+  let user;
+  const { email, organizationId, code } = req.body;
 
-  user = await User.findOne({ email }).select('+publicKey');
+  user = await User.findOne({ email }).select("+publicKey");
 
   const membershipOrg = await MembershipOrg.findOne({
     inviteEmail: email,
@@ -223,8 +228,7 @@ export const verifyUserToOrganization = async (req: Request, res: Response) => {
     organization: new Types.ObjectId(organizationId)
   });
 
-  if (!membershipOrg)
-    throw new Error('Failed to find any invitations for email');
+  if (!membershipOrg) throw new Error("Failed to find any invitations for email");
 
   await TokenService.validateToken({
     type: TOKEN_EMAIL_ORG_INVITATION,
@@ -238,14 +242,14 @@ export const verifyUserToOrganization = async (req: Request, res: Response) => {
     // membership can be approved and redirected to login/dashboard
     membershipOrg.status = ACCEPTED;
     await membershipOrg.save();
-    
+
     await updateSubscriptionOrgQuantity({
       organizationId
     });
 
     return res.status(200).send({
-      message: 'Successfully verified email',
-      user,
+      message: "Successfully verified email",
+      user
     });
   }
 
@@ -265,9 +269,9 @@ export const verifyUserToOrganization = async (req: Request, res: Response) => {
     secret: await getJwtSignupSecret()
   });
 
-	return res.status(200).send({
-		message: 'Successfully verified email',
-		user,
-		token
-	});
+  return res.status(200).send({
+    message: "Successfully verified email",
+    user,
+    token
+  });
 };

backend/src/controllers/v1/organizationController.ts

@@ -1,28 +1,27 @@
-import { Request, Response } from 'express';
-import Stripe from 'stripe';
+import { Request, Response } from "express";
+import Stripe from "stripe";
 import {
+	IncidentContactOrg,
 	Membership,
 	MembershipOrg,
 	Organization,
 	Workspace,
-	IncidentContactOrg
-} from '../../models';
-import { createOrganization as create } from '../../helpers/organization';
-import { addMembershipsOrg } from '../../helpers/membershipOrg';
-import { OWNER, ACCEPTED } from '../../variables';
-import _ from 'lodash';
-import { getStripeSecretKey, getSiteURL } from '../../config';
+} from "../../models";
+import { createOrganization as create } from "../../helpers/organization";
+import { addMembershipsOrg } from "../../helpers/membershipOrg";
+import { ACCEPTED, OWNER } from "../../variables";
+import { getSiteURL, getStripeSecretKey } from "../../config";
 
 export const getOrganizations = async (req: Request, res: Response) => {
   const organizations = (
     await MembershipOrg.find({
       user: req.user._id,
-      status: ACCEPTED
-    }).populate('organization')
+      status: ACCEPTED,
+    }).populate("organization")
   ).map((m) => m.organization);
 
 	return res.status(200).send({
-		organizations
+		organizations,
 	});
 };
 
@@ -37,24 +36,24 @@ export const createOrganization = async (req: Request, res: Response) => {
   const { organizationName } = req.body;
 
   if (organizationName.length < 1) {
-    throw new Error('Organization names must be at least 1-character long');
+    throw new Error("Organization names must be at least 1-character long");
   }
 
   // create organization and add user as member
   const organization = await create({
     email: req.user.email,
-    name: organizationName
+    name: organizationName,
   });
 
   await addMembershipsOrg({
     userIds: [req.user._id.toString()],
     organizationId: organization._id.toString(),
     roles: [OWNER],
-    statuses: [ACCEPTED]
+    statuses: [ACCEPTED],
   });
 
 	return res.status(200).send({
-		organization
+		organization,
 	});
 };
 
@@ -67,7 +66,7 @@ export const createOrganization = async (req: Request, res: Response) => {
 export const getOrganization = async (req: Request, res: Response) => {
 	const organization = req.organization
 	return res.status(200).send({
-		organization
+		organization,
 	});
 };
 
@@ -81,11 +80,11 @@ export const getOrganizationMembers = async (req: Request, res: Response) => {
   const { organizationId } = req.params;
 
   const users = await MembershipOrg.find({
-    organization: organizationId
-  }).populate('user', '+publicKey');
+    organization: organizationId,
+  }).populate("user", "+publicKey");
 
 	return res.status(200).send({
-		users
+		users,
 	});
 };
 
@@ -105,23 +104,23 @@ export const getOrganizationWorkspaces = async (
     (
       await Workspace.find(
         {
-          organization: organizationId
+          organization: organizationId,
         },
-        '_id'
+        "_id"
       )
     ).map((w) => w._id.toString())
   );
 
   const workspaces = (
     await Membership.find({
-      user: req.user._id
-    }).populate('workspace')
+      user: req.user._id,
+    }).populate("workspace")
   )
     .filter((m) => workspacesSet.has(m.workspace._id.toString()))
     .map((m) => m.workspace);
 
 	return res.status(200).send({
-		workspaces
+		workspaces,
 	});
 };
 
@@ -137,19 +136,19 @@ export const changeOrganizationName = async (req: Request, res: Response) => {
 
   const organization = await Organization.findOneAndUpdate(
     {
-      _id: organizationId
+      _id: organizationId,
     },
     {
-      name
+      name,
     },
     {
-      new: true
+      new: true,
     }
   );
 
 	return res.status(200).send({
-		message: 'Successfully changed organization name',
-		organization
+		message: "Successfully changed organization name",
+		organization,
 	});
 };
 
@@ -166,11 +165,11 @@ export const getOrganizationIncidentContacts = async (
   const { organizationId } = req.params;
 
   const incidentContactsOrg = await IncidentContactOrg.find({
-    organization: organizationId
+    organization: organizationId,
   });
 
 	return res.status(200).send({
-		incidentContactsOrg
+		incidentContactsOrg,
 	});
 };
 
@@ -194,7 +193,7 @@ export const addOrganizationIncidentContact = async (
   );
 
 	return res.status(200).send({
-		incidentContactOrg
+		incidentContactOrg,
 	});
 };
 
@@ -213,12 +212,12 @@ export const deleteOrganizationIncidentContact = async (
 
   const incidentContactOrg = await IncidentContactOrg.findOneAndDelete({
     email,
-    organization: organizationId
+    organization: organizationId,
   });
 
 	return res.status(200).send({
-		message: 'Successfully deleted organization incident contact',
-		incidentContactOrg
+		message: "Successfully deleted organization incident contact",
+		incidentContactOrg,
 	});
 };
 
@@ -235,28 +234,28 @@ export const createOrganizationPortalSession = async (
 ) => {
 	let session;
   const stripe = new Stripe(await getStripeSecretKey(), {
-    apiVersion: '2022-08-01'
+    apiVersion: "2022-08-01",
   });
 
   // check if there is a payment method on file
   const paymentMethods = await stripe.paymentMethods.list({
     customer: req.organization.customerId,
-    type: 'card'
+    type: "card",
   });
   
   if (paymentMethods.data.length < 1) {
     // case: no payment method on file
     session = await stripe.checkout.sessions.create({
       customer: req.organization.customerId,
-      mode: 'setup',
-      payment_method_types: ['card'],
-      success_url: (await getSiteURL()) + '/dashboard',
-      cancel_url: (await getSiteURL()) + '/dashboard'
+      mode: "setup",
+      payment_method_types: ["card"],
+      success_url: (await getSiteURL()) + "/dashboard",
+      cancel_url: (await getSiteURL()) + "/dashboard",
     });
   } else {
     session = await stripe.billingPortal.sessions.create({
       customer: req.organization.customerId,
-      return_url: (await getSiteURL()) + '/dashboard'
+      return_url: (await getSiteURL()) + "/dashboard",
     });
   }
 
@@ -274,15 +273,15 @@ export const getOrganizationSubscriptions = async (
 	res: Response
 ) => {
   const stripe = new Stripe(await getStripeSecretKey(), {
-    apiVersion: '2022-08-01'
+    apiVersion: "2022-08-01",
   });
   
   const subscriptions = await stripe.subscriptions.list({
-    customer: req.organization.customerId
+    customer: req.organization.customerId,
   });
 
 	return res.status(200).send({
-		subscriptions
+		subscriptions,
 	});
 };
 
@@ -302,16 +301,16 @@ export const getOrganizationMembersAndTheirWorkspaces = async (
 	const workspacesSet = (
 			await Workspace.find(
 				{
-					organization: organizationId
+					organization: organizationId,
 				},
-				'_id'
+				"_id"
 			)
 		).map((w) => w._id.toString());
 
 	const memberships = (
 		await Membership.find({
-			workspace: { $in: workspacesSet }
-		}).populate('workspace')
+			workspace: { $in: workspacesSet },
+		}).populate("workspace")
 	);
 	const userToWorkspaceIds: any = {};
 

backend/src/controllers/v1/passwordController.ts

@@ -1,85 +1,77 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
 // eslint-disable-next-line @typescript-eslint/no-var-requires
-const jsrp = require('jsrp');
-import * as bigintConversion from 'bigint-conversion';
-import { User, BackupPrivateKey, LoginSRPDetail } from '../../models';
+const jsrp = require("jsrp");
+import * as bigintConversion from "bigint-conversion";
+import { BackupPrivateKey, LoginSRPDetail, User } from "../../models";
+import { clearTokens, createToken, sendMail } from "../../helpers";
+import { TokenService } from "../../services";
+import { AUTH_MODE_JWT, TOKEN_EMAIL_PASSWORD_RESET } from "../../variables";
+import { BadRequestError } from "../../utils/errors";
 import {
-	createToken,
-	sendMail,
-	clearTokens
-} from '../../helpers';
-import { TokenService } from '../../services';
-import { 
-	TOKEN_EMAIL_PASSWORD_RESET,
-	AUTH_MODE_JWT
-} from '../../variables';
-import { BadRequestError } from '../../utils/errors';
-import { 
-	getSiteURL, 
-	getJwtSignupLifetime, 
-	getJwtSignupSecret,
-	getHttpsEnabled
-} from '../../config';
+  getHttpsEnabled,
+  getJwtSignupLifetime,
+  getJwtSignupSecret,
+  getSiteURL
+} from "../../config";
 
 /**
- * Password reset step 1: Send email verification link to email [email] 
+ * Password reset step 1: Send email verification link to email [email]
  * for account recovery.
  * @param req
  * @param res
  * @returns
  */
 export const emailPasswordReset = async (req: Request, res: Response) => {
-	let email: string;
-  email = req.body.email;
+  const email: string = req.body.email;
 
-  const user = await User.findOne({ email }).select('+publicKey');
+  const user = await User.findOne({ email }).select("+publicKey");
   if (!user || !user?.publicKey) {
     // case: user has already completed account
 
     return res.status(200).send({
-      message:"If an account exists with this email, a password reset link has been sent" 
+      message: "If an account exists with this email, a password reset link has been sent"
     });
   }
-  
+
   const token = await TokenService.createToken({
     type: TOKEN_EMAIL_PASSWORD_RESET,
     email
   });
-  
+
   await sendMail({
-    template: 'passwordReset.handlebars',
-    subjectLine: 'Infisical password reset',
+    template: "passwordReset.handlebars",
+    subjectLine: "Infisical password reset",
     recipients: [email],
     substitutions: {
       email,
       token,
-      callback_url: (await getSiteURL()) + '/password-reset'
+      callback_url: (await getSiteURL()) + "/password-reset"
     }
   });
 
-	return res.status(200).send({
-		message:"If an account exists with this email, a password reset link has been sent" 
-	});
-}
+  return res.status(200).send({
+    message: "If an account exists with this email, a password reset link has been sent"
+  });
+};
 
 /**
  * Password reset step 2: Verify email verification link sent to email [email]
- * @param req 
- * @param res 
- * @returns 
+ * @param req
+ * @param res
+ * @returns
  */
 export const emailPasswordResetVerify = async (req: Request, res: Response) => {
   const { email, code } = req.body;
 
-  const user = await User.findOne({ email }).select('+publicKey');
+  const user = await User.findOne({ email }).select("+publicKey");
   if (!user || !user?.publicKey) {
-    // case: user doesn't exist with email [email] or 
+    // case: user doesn't exist with email [email] or
     // hasn't even completed their account
     return res.status(403).send({
-      error: 'Failed email verification for password reset'
+      error: "Failed email verification for password reset"
     });
   }
-  
+
   await TokenService.validateToken({
     type: TOKEN_EMAIL_PASSWORD_RESET,
     email,
@@ -95,12 +87,12 @@ export const emailPasswordResetVerify = async (req: Request, res: Response) => {
     secret: await getJwtSignupSecret()
   });
 
-	return res.status(200).send({
-		message: 'Successfully verified email',
-		user,
-		token
-	});
-}
+  return res.status(200).send({
+    message: "Successfully verified email",
+    user,
+    token
+  });
+};
 
 /**
  * Return [salt] and [serverPublicKey] as part of step 1 of SRP protocol
@@ -109,14 +101,14 @@ export const emailPasswordResetVerify = async (req: Request, res: Response) => {
  * @returns
  */
 export const srp1 = async (req: Request, res: Response) => {
-	// return salt, serverPublicKey as part of first step of SRP protocol
-	
+  // return salt, serverPublicKey as part of first step of SRP protocol
+
   const { clientPublicKey } = req.body;
   const user = await User.findOne({
     email: req.user.email
-  }).select('+salt +verifier');
+  }).select("+salt +verifier");
 
-  if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
   const server = new jsrp.server();
   server.init(
@@ -128,11 +120,15 @@ export const srp1 = async (req: Request, res: Response) => {
       // generate server-side public key
       const serverPublicKey = server.getPublicKey();
 
-      await LoginSRPDetail.findOneAndReplace({ email: req.user.email }, {
-        email: req.user.email,
-        clientPublicKey: clientPublicKey,
-        serverBInt: bigintConversion.bigintToBuf(server.bInt),
-      }, { upsert: true, returnNewDocument: false })
+      await LoginSRPDetail.findOneAndReplace(
+        { email: req.user.email },
+        {
+          email: req.user.email,
+          clientPublicKey: clientPublicKey,
+          serverBInt: bigintConversion.bigintToBuf(server.bInt)
+        },
+        { upsert: true, returnNewDocument: false }
+      );
 
       return res.status(200).send({
         serverPublicKey,
@@ -140,8 +136,7 @@ export const srp1 = async (req: Request, res: Response) => {
       });
     }
   );
-}
-
+};
 
 /**
  * Change account SRP authentication information for user
@@ -152,8 +147,8 @@ export const srp1 = async (req: Request, res: Response) => {
  * @returns
  */
 export const changePassword = async (req: Request, res: Response) => {
-  const { 
-    clientProof, 
+  const {
+    clientProof,
     protectedKey,
     protectedKeyIV,
     protectedKeyTag,
@@ -166,14 +161,18 @@ export const changePassword = async (req: Request, res: Response) => {
 
   const user = await User.findOne({
     email: req.user.email
-  }).select('+salt +verifier');
+  }).select("+salt +verifier");
 
-  if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
-  const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: req.user.email })
+  const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: req.user.email });
 
   if (!loginSRPDetailFromDB) {
-    return BadRequestError(Error("It looks like some details from the first login are not found. Please try login one again"))
+    return BadRequestError(
+      Error(
+        "It looks like some details from the first login are not found. Please try login one again"
+      )
+    );
   }
 
   const server = new jsrp.server();
@@ -207,27 +206,31 @@ export const changePassword = async (req: Request, res: Response) => {
             new: true
           }
         );
-      
-        if (req.authData.authMode === AUTH_MODE_JWT && req.authData.authPayload instanceof User && req.authData.tokenVersionId) {
-          await clearTokens(req.authData.tokenVersionId)
+
+        if (
+          req.authData.authMode === AUTH_MODE_JWT &&
+          req.authData.authPayload instanceof User &&
+          req.authData.tokenVersionId
+        ) {
+          await clearTokens(req.authData.tokenVersionId);
         }
 
         // clear httpOnly cookie
-        
-        res.cookie('jid', '', {
+
+        res.cookie("jid", "", {
           httpOnly: true,
-          path: '/',
-          sameSite: 'strict',
+          path: "/",
+          sameSite: "strict",
           secure: (await getHttpsEnabled()) as boolean
         });
 
         return res.status(200).send({
-          message: 'Successfully changed password'
+          message: "Successfully changed password"
         });
       }
 
       return res.status(400).send({
-        error: 'Failed to change password. Try again?'
+        error: "Failed to change password. Try again?"
       });
     }
   );
@@ -240,22 +243,25 @@ export const changePassword = async (req: Request, res: Response) => {
  * @returns
  */
 export const createBackupPrivateKey = async (req: Request, res: Response) => {
-	// create/change backup private key
-	// requires verifying [clientProof] as part of second step of SRP protocol
-	// as initiated in /srp1
+  // create/change backup private key
+  // requires verifying [clientProof] as part of second step of SRP protocol
+  // as initiated in /srp1
 
-  const { clientProof, encryptedPrivateKey, iv, tag, salt, verifier } =
-    req.body;
+  const { clientProof, encryptedPrivateKey, iv, tag, salt, verifier } = req.body;
   const user = await User.findOne({
     email: req.user.email
-  }).select('+salt +verifier');
+  }).select("+salt +verifier");
 
-  if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
-  const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: req.user.email })
+  const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: req.user.email });
 
   if (!loginSRPDetailFromDB) {
-    return BadRequestError(Error("It looks like some details from the first login are not found. Please try login one again"))
+    return BadRequestError(
+      Error(
+        "It looks like some details from the first login are not found. Please try login one again"
+      )
+    );
   }
 
   const server = new jsrp.server();
@@ -266,9 +272,7 @@ export const createBackupPrivateKey = async (req: Request, res: Response) => {
       b: loginSRPDetailFromDB.serverBInt
     },
     async () => {
-      server.setClientPublicKey(
-        loginSRPDetailFromDB.clientPublicKey
-      );
+      server.setClientPublicKey(loginSRPDetailFromDB.clientPublicKey);
 
       // compare server and client shared keys
       if (server.checkClientProof(clientProof)) {
@@ -285,17 +289,17 @@ export const createBackupPrivateKey = async (req: Request, res: Response) => {
             verifier
           },
           { upsert: true, new: true }
-        ).select('+user, encryptedPrivateKey');
+        ).select("+user, encryptedPrivateKey");
 
         // issue tokens
         return res.status(200).send({
-          message: 'Successfully updated backup private key',
+          message: "Successfully updated backup private key",
           backupPrivateKey
         });
       }
 
       return res.status(400).send({
-        message: 'Failed to update backup private key'
+        message: "Failed to update backup private key"
       });
     }
   );
@@ -303,21 +307,21 @@ export const createBackupPrivateKey = async (req: Request, res: Response) => {
 
 /**
  * Return backup private key for user
- * @param req 
- * @param res 
- * @returns 
+ * @param req
+ * @param res
+ * @returns
  */
 export const getBackupPrivateKey = async (req: Request, res: Response) => {
   const backupPrivateKey = await BackupPrivateKey.findOne({
     user: req.user._id
-  }).select('+encryptedPrivateKey +iv +tag');
+  }).select("+encryptedPrivateKey +iv +tag");
 
-  if (!backupPrivateKey) throw new Error('Failed to find backup private key');
+  if (!backupPrivateKey) throw new Error("Failed to find backup private key");
 
-	return res.status(200).send({
-		backupPrivateKey
-	});
-}
+  return res.status(200).send({
+    backupPrivateKey
+  });
+};
 
 export const resetPassword = async (req: Request, res: Response) => {
   const {
@@ -328,7 +332,7 @@ export const resetPassword = async (req: Request, res: Response) => {
     encryptedPrivateKeyIV,
     encryptedPrivateKeyTag,
     salt,
-    verifier,
+    verifier
   } = req.body;
 
   await User.findByIdAndUpdate(
@@ -337,7 +341,7 @@ export const resetPassword = async (req: Request, res: Response) => {
       encryptionVersion: 2,
       protectedKey,
       protectedKeyIV,
-      protectedKeyTag,	
+      protectedKeyTag,
       encryptedPrivateKey,
       iv: encryptedPrivateKeyIV,
       tag: encryptedPrivateKeyTag,
@@ -349,7 +353,7 @@ export const resetPassword = async (req: Request, res: Response) => {
     }
   );
 
-	return res.status(200).send({
-		message: 'Successfully reset password'
-	});
-}
+  return res.status(200).send({
+    message: "Successfully reset password"
+  });
+};

backend/src/controllers/v1/secretController.ts

@@ -1,30 +1,30 @@
-import { Request, Response } from 'express';
-import { Types } from 'mongoose';
-import { Key, Secret } from '../../models';
+import { Request, Response } from "express";
+import { Types } from "mongoose";
+import { Key } from "../../models";
 import {
-	v1PushSecrets as push,
-	pullSecrets as pull,
-	reformatPullSecrets
-} from '../../helpers/secret';
-import { pushKeys } from '../../helpers/key';
-import { eventPushSecrets } from '../../events';
-import { EventService } from '../../services';
-import { TelemetryService } from '../../services';
+  pullSecrets as pull,
+  v1PushSecrets as push,
+  reformatPullSecrets
+} from "../../helpers/secret";
+import { pushKeys } from "../../helpers/key";
+import { eventPushSecrets } from "../../events";
+import { EventService } from "../../services";
+import { TelemetryService } from "../../services";
 
 interface PushSecret {
-	ciphertextKey: string;
-	ivKey: string;
-	tagKey: string;
-	hashKey: string;
-	ciphertextValue: string;
-	ivValue: string;
-	tagValue: string;
-	hashValue: string;
-	ciphertextComment: string;
-	ivComment: string;
-	tagComment: string;
-	hashComment: string;
-	type: 'shared' | 'personal';
+  ciphertextKey: string;
+  ivKey: string;
+  tagKey: string;
+  hashKey: string;
+  ciphertextValue: string;
+  ivValue: string;
+  tagValue: string;
+  hashValue: string;
+  ciphertextComment: string;
+  ivComment: string;
+  tagComment: string;
+  hashComment: string;
+  type: "shared" | "personal";
 }
 
 /**
@@ -35,7 +35,7 @@ interface PushSecret {
  * @returns
  */
 export const pushSecrets = async (req: Request, res: Response) => {
-	// upload (encrypted) secrets to workspace with id [workspaceId]
+  // upload (encrypted) secrets to workspace with id [workspaceId]
   const postHogClient = await TelemetryService.getPostHogClient();
   let { secrets }: { secrets: PushSecret[] } = req.body;
   const { keys, environment, channel } = req.body;
@@ -44,13 +44,11 @@ export const pushSecrets = async (req: Request, res: Response) => {
   // validate environment
   const workspaceEnvs = req.membership.workspace.environments;
   if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-    throw new Error('Failed to validate environment');
+    throw new Error("Failed to validate environment");
   }
 
   // sanitize secrets
-  secrets = secrets.filter(
-    (s: PushSecret) => s.ciphertextKey !== '' && s.ciphertextValue !== ''
-  );
+  secrets = secrets.filter((s: PushSecret) => s.ciphertextKey !== "" && s.ciphertextValue !== "");
 
   await push({
     userId: req.user._id,
@@ -64,17 +62,16 @@ export const pushSecrets = async (req: Request, res: Response) => {
     workspaceId,
     keys
   });
-  
-  
+
   if (postHogClient) {
     postHogClient.capture({
-      event: 'secrets pushed',
+      event: "secrets pushed",
       distinctId: req.user.email,
       properties: {
         numberOfSecrets: secrets.length,
         environment,
         workspaceId,
-        channel: channel ? channel : 'cli'
+        channel: channel ? channel : "cli"
       }
     });
   }
@@ -87,9 +84,9 @@ export const pushSecrets = async (req: Request, res: Response) => {
     })
   });
 
-	return res.status(200).send({
-		message: 'Successfully uploaded workspace secrets'
-	});
+  return res.status(200).send({
+    message: "Successfully uploaded workspace secrets"
+  });
 };
 
 /**
@@ -100,57 +97,56 @@ export const pushSecrets = async (req: Request, res: Response) => {
  * @returns
  */
 export const pullSecrets = async (req: Request, res: Response) => {
-	let secrets;
-	let key;
+  let secrets;
 
-	const postHogClient = await TelemetryService.getPostHogClient();
-	const environment: string = req.query.environment as string;
-	const channel: string = req.query.channel as string;
-	const { workspaceId } = req.params;
+  const postHogClient = await TelemetryService.getPostHogClient();
+  const environment: string = req.query.environment as string;
+  const channel: string = req.query.channel as string;
+  const { workspaceId } = req.params;
 
-	// validate environment
-	const workspaceEnvs = req.membership.workspace.environments;
-	if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-		throw new Error('Failed to validate environment');
-	}
+  // validate environment
+  const workspaceEnvs = req.membership.workspace.environments;
+  if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
+    throw new Error("Failed to validate environment");
+  }
 
-	secrets = await pull({
-		userId: req.user._id.toString(),
-		workspaceId,
-		environment,
-		channel: channel ? channel : 'cli',
-		ipAddress: req.realIP
-	});
+  secrets = await pull({
+    userId: req.user._id.toString(),
+    workspaceId,
+    environment,
+    channel: channel ? channel : "cli",
+    ipAddress: req.realIP
+  });
 
-	key = await Key.findOne({
-		workspace: workspaceId,
-		receiver: req.user._id
-	})
-		.sort({ createdAt: -1 })
-		.populate('sender', '+publicKey');
-	
-	if (channel !== 'cli') {
-		secrets = reformatPullSecrets({ secrets });
-	}
+  const key = await Key.findOne({
+    workspace: workspaceId,
+    receiver: req.user._id
+  })
+    .sort({ createdAt: -1 })
+    .populate("sender", "+publicKey");
 
-	if (postHogClient) {
-		// capture secrets pushed event in production
-		postHogClient.capture({
-			distinctId: req.user.email,
-			event: 'secrets pulled',
-			properties: {
-				numberOfSecrets: secrets.length,
-				environment,
-				workspaceId,
-				channel: channel ? channel : 'cli'
-			}
-		});
-	}
+  if (channel !== "cli") {
+    secrets = reformatPullSecrets({ secrets });
+  }
 
-	return res.status(200).send({
-		secrets,
-		key
-	});
+  if (postHogClient) {
+    // capture secrets pushed event in production
+    postHogClient.capture({
+      distinctId: req.user.email,
+      event: "secrets pulled",
+      properties: {
+        numberOfSecrets: secrets.length,
+        environment,
+        workspaceId,
+        channel: channel ? channel : "cli"
+      }
+    });
+  }
+
+  return res.status(200).send({
+    secrets,
+    key
+  });
 };
 
 /**
@@ -162,54 +158,51 @@ export const pullSecrets = async (req: Request, res: Response) => {
  * @returns
  */
 export const pullSecretsServiceToken = async (req: Request, res: Response) => {
-	let secrets;
-	let key;
+  const postHogClient = await TelemetryService.getPostHogClient();
+  const environment: string = req.query.environment as string;
+  const channel: string = req.query.channel as string;
+  const { workspaceId } = req.params;
 
-	const postHogClient = await TelemetryService.getPostHogClient();
-	const environment: string = req.query.environment as string;
-	const channel: string = req.query.channel as string;
-	const { workspaceId } = req.params;
+  // validate environment
+  const workspaceEnvs = req.membership.workspace.environments;
+  if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
+    throw new Error("Failed to validate environment");
+  }
 
-	// validate environment
-	const workspaceEnvs = req.membership.workspace.environments;
-	if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-		throw new Error('Failed to validate environment');
-	}
+  const secrets = await pull({
+    userId: req.serviceToken.user._id.toString(),
+    workspaceId,
+    environment,
+    channel: "cli",
+    ipAddress: req.realIP
+  });
 
-	secrets = await pull({
-		userId: req.serviceToken.user._id.toString(),
-		workspaceId,
-		environment,
-		channel: 'cli',
-		ipAddress: req.realIP
-	});
+  const key = {
+    encryptedKey: req.serviceToken.encryptedKey,
+    nonce: req.serviceToken.nonce,
+    sender: {
+      publicKey: req.serviceToken.publicKey
+    },
+    receiver: req.serviceToken.user,
+    workspace: req.serviceToken.workspace
+  };
 
-	key = {
-		encryptedKey: req.serviceToken.encryptedKey,
-		nonce: req.serviceToken.nonce,
-		sender: {
-			publicKey: req.serviceToken.publicKey
-		},
-		receiver: req.serviceToken.user,
-		workspace: req.serviceToken.workspace
-	};
+  if (postHogClient) {
+    // capture secrets pulled event in production
+    postHogClient.capture({
+      distinctId: req.serviceToken.user.email,
+      event: "secrets pulled",
+      properties: {
+        numberOfSecrets: secrets.length,
+        environment,
+        workspaceId,
+        channel: channel ? channel : "cli"
+      }
+    });
+  }
 
-	if (postHogClient) {
-		// capture secrets pulled event in production
-		postHogClient.capture({
-			distinctId: req.serviceToken.user.email,
-			event: 'secrets pulled',
-			properties: {
-				numberOfSecrets: secrets.length,
-				environment,
-				workspaceId,
-				channel: channel ? channel : 'cli'
-			}
-		});
-	}
-
-	return res.status(200).send({
-		secrets: reformatPullSecrets({ secrets }),
-		key
-	});
+  return res.status(200).send({
+    secrets: reformatPullSecrets({ secrets }),
+    key
+  });
 };

backend/src/controllers/v1/secretsFolderController.ts

@@ -5,13 +5,13 @@ import { BadRequestError } from "../../utils/errors";
 import {
   appendFolder,
   deleteFolderById,
-  getAllFolderIds,
-  searchByFolderIdWithDir,
-  searchByFolderId,
-  validateFolderName,
   generateFolderId,
-  getParentFromFolderId,
+  getAllFolderIds,
   getFolderByPath,
+  getParentFromFolderId,
+  searchByFolderId,
+  searchByFolderIdWithDir,
+  validateFolderName,
 } from "../../services/FolderService";
 import { ADMIN, MEMBER } from "../../variables";
 import { validateMembership } from "../../helpers/membership";

backend/src/controllers/v1/serviceTokenController.ts

@@ -1,7 +1,7 @@
-import { Request, Response } from 'express';
-import { ServiceToken } from '../../models';
-import { createToken } from '../../helpers/auth';
-import { getJwtServiceSecret } from '../../config';
+import { Request, Response } from "express";
+import { ServiceToken } from "../../models";
+import { createToken } from "../../helpers/auth";
+import { getJwtServiceSecret } from "../../config";
 
 /**
  * Return service token on request
@@ -11,7 +11,7 @@ import { getJwtServiceSecret } from '../../config';
  */
 export const getServiceToken = async (req: Request, res: Response) => {
 	return res.status(200).send({
-		serviceToken: req.serviceToken
+		serviceToken: req.serviceToken,
 	});
 };
 
@@ -31,13 +31,13 @@ export const createServiceToken = async (req: Request, res: Response) => {
 			expiresIn,
 			publicKey,
 			encryptedKey,
-			nonce
+			nonce,
 		} = req.body;
 
 		// validate environment
 		const workspaceEnvs = req.membership.workspace.environments;
 		if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-			throw new Error('Failed to validate environment');
+			throw new Error("Failed to validate environment");
 		}
 
 		// compute access token expiration date
@@ -52,24 +52,24 @@ export const createServiceToken = async (req: Request, res: Response) => {
 			expiresAt,
 			publicKey,
 			encryptedKey,
-			nonce
+			nonce,
 		}).save();
 
 		token = createToken({
 			payload: {
 				serviceTokenId: serviceToken._id.toString(),
-				workspaceId
+				workspaceId,
 			},
 			expiresIn: expiresIn,
-			secret: await getJwtServiceSecret()
+			secret: await getJwtServiceSecret(),
 		});
 	} catch (err) {
 		return res.status(400).send({
-			message: 'Failed to create service token'
+			message: "Failed to create service token",
 		});
 	}
 
 	return res.status(200).send({
-		token
+		token,
 	});
 };

backend/src/controllers/v1/signupController.ts

@@ -1,13 +1,15 @@
-import { Request, Response } from 'express';
-import { User } from '../../models';
+import { Request, Response } from "express";
+import { User } from "../../models";
+import { checkEmailVerification, sendEmailVerification } from "../../helpers/signup";
+import { createToken } from "../../helpers/auth";
+import { BadRequestError } from "../../utils/errors";
 import {
-	sendEmailVerification,
-	checkEmailVerification,
-} from '../../helpers/signup';
-import { createToken } from '../../helpers/auth';
-import { BadRequestError } from '../../utils/errors';
-import { getInviteOnlySignup, getJwtSignupLifetime, getJwtSignupSecret, getSmtpConfigured } from '../../config';
-import { validateUserEmail } from '../../validation';
+  getInviteOnlySignup,
+  getJwtSignupLifetime,
+  getJwtSignupSecret,
+  getSmtpConfigured
+} from "../../config";
+import { validateUserEmail } from "../../validation";
 
 /**
  * Signup step 1: Initialize account for user under email [email] and send a verification code
@@ -17,27 +19,26 @@ import { validateUserEmail } from '../../validation';
  * @returns
  */
 export const beginEmailSignup = async (req: Request, res: Response) => {
-	let email: string;
-  email = req.body.email;
-  
+  const email: string = req.body.email;
+
   // validate that email is not disposable
   validateUserEmail(email);
 
-  const user = await User.findOne({ email }).select('+publicKey');
+  const user = await User.findOne({ email }).select("+publicKey");
   if (user && user?.publicKey) {
     // case: user has already completed account
 
     return res.status(403).send({
-      error: 'Failed to send email verification code for complete account'
+      error: "Failed to send email verification code for complete account"
     });
   }
 
   // send send verification email
   await sendEmailVerification({ email });
 
-	return res.status(200).send({
-		message: `Sent an email verification code to ${email}`
-	});
+  return res.status(200).send({
+    message: `Sent an email verification code to ${email}`
+  });
 };
 
 /**
@@ -48,23 +49,25 @@ export const beginEmailSignup = async (req: Request, res: Response) => {
  * @returns
  */
 export const verifyEmailSignup = async (req: Request, res: Response) => {
-	let user, token;
+  let user;
   const { email, code } = req.body;
 
   // initialize user account
-  user = await User.findOne({ email }).select('+publicKey');
+  user = await User.findOne({ email }).select("+publicKey");
   if (user && user?.publicKey) {
     // case: user has already completed account
     return res.status(403).send({
-      error: 'Failed email verification for complete user'
+      error: "Failed email verification for complete user"
     });
   }
 
   if (await getInviteOnlySignup()) {
     // Only one user can create an account without being invited. The rest need to be invited in order to make an account
-    const userCount = await User.countDocuments({})
+    const userCount = await User.countDocuments({});
     if (userCount != 0) {
-      throw BadRequestError({ message: "New user sign ups are not allowed at this time. You must be invited to sign up." })
+      throw BadRequestError({
+        message: "New user sign ups are not allowed at this time. You must be invited to sign up."
+      });
     }
   }
 
@@ -83,7 +86,7 @@ export const verifyEmailSignup = async (req: Request, res: Response) => {
   }
 
   // generate temporary signup token
-  token = createToken({
+  const token = createToken({
     payload: {
       userId: user._id.toString()
     },
@@ -91,9 +94,9 @@ export const verifyEmailSignup = async (req: Request, res: Response) => {
     secret: await getJwtSignupSecret()
   });
 
-	return res.status(200).send({
-		message: 'Successfuly verified email',
-		user,
-		token
-	});
+  return res.status(200).send({
+    message: "Successfuly verified email",
+    user,
+    token
+  });
 };

backend/src/controllers/v1/stripeController.ts

@@ -1,6 +1,6 @@
-import { Request, Response } from 'express';
-import Stripe from 'stripe';
-import { getStripeSecretKey, getStripeWebhookSecret } from '../../config';
+import { Request, Response } from "express";
+import Stripe from "stripe";
+import { getStripeSecretKey, getStripeWebhookSecret } from "../../config";
 
 /**
  * Handle service provisioning/un-provisioning via Stripe
@@ -11,10 +11,10 @@ import { getStripeSecretKey, getStripeWebhookSecret } from '../../config';
 export const handleWebhook = async (req: Request, res: Response) => {
   // check request for valid stripe signature
   const stripe = new Stripe(await getStripeSecretKey(), {
-    apiVersion: '2022-08-01'
+    apiVersion: "2022-08-01",
   });
 
-  const sig = req.headers['stripe-signature'] as string;
+  const sig = req.headers["stripe-signature"] as string;
   const event = stripe.webhooks.constructEvent(
     req.body,
     sig,
@@ -22,7 +22,7 @@ export const handleWebhook = async (req: Request, res: Response) => {
   );
 
 	switch (event.type) {
-		case '':
+		case "":
 			break;
 		default:
 	}

backend/src/controllers/v1/userActionController.ts

@@ -1,5 +1,5 @@
-import { Request, Response } from 'express';
-import { UserAction } from '../../models';
+import { Request, Response } from "express";
+import { UserAction } from "../../models";
 
 /**
  * Add user action [action]
@@ -15,18 +15,18 @@ export const addUserAction = async (req: Request, res: Response) => {
   const userAction = await UserAction.findOneAndUpdate(
     {
       user: req.user._id,
-      action
+      action,
     },
     { user: req.user._id, action },
     {
       new: true,
-      upsert: true
+      upsert: true,
     }
   );
 
 	return res.status(200).send({
-		message: 'Successfully recorded user action',
-		userAction
+		message: "Successfully recorded user action",
+		userAction,
 	});
 };
 
@@ -42,10 +42,10 @@ export const getUserAction = async (req: Request, res: Response) => {
 
   const userAction = await UserAction.findOne({
     user: req.user._id,
-    action
+    action,
   });
 
 	return res.status(200).send({
-		userAction
+		userAction,
 	});
 };

backend/src/controllers/v1/userController.ts

@@ -1,4 +1,4 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
 
 /**
  * Return user on request
@@ -8,6 +8,6 @@ import { Request, Response } from 'express';
  */
 export const getUser = async (req: Request, res: Response) => {
 	return res.status(200).send({
-		user: req.user
+		user: req.user,
 	});
 };

backend/src/controllers/v1/workspaceController.ts

@@ -1,19 +1,18 @@
 import { Request, Response } from "express";
 import {
-  Workspace,
-  Membership,
-  MembershipOrg,
+  IUser,
   Integration,
   IntegrationAuth,
-  IUser,
+  Membership,
+  MembershipOrg,
   ServiceToken,
-  ServiceTokenData,
+  Workspace,
 } from "../../models";
 import {
   createWorkspace as create,
   deleteWorkspace as deleteWork,
 } from "../../helpers/workspace";
-import { EELicenseService } from '../../ee/services';
+import { EELicenseService } from "../../ee/services";
 import { addMemberships } from "../../helpers/membership";
 import { ADMIN } from "../../variables";
 
@@ -123,7 +122,7 @@ export const createWorkspace = async (req: Request, res: Response) => {
     if (plan.workspacesUsed >= plan.workspaceLimit) {
       // case: number of workspaces used exceeds the number of workspaces allowed
       return res.status(400).send({
-        message: 'Failed to create workspace due to plan limit reached. Upgrade plan to add more workspaces.'
+        message: "Failed to create workspace due to plan limit reached. Upgrade plan to add more workspaces.",
       });
     }
   }

backend/src/controllers/v2/apiKeyDataController.ts

@@ -1,74 +1,72 @@
-import { Request, Response } from 'express';
-import crypto from 'crypto';
-import bcrypt from 'bcrypt';
-import {
-    APIKeyData
-} from '../../models';
-import { getSaltRounds } from '../../config';
+import { Request, Response } from "express";
+import crypto from "crypto";
+import bcrypt from "bcrypt";
+import { APIKeyData } from "../../models";
+import { getSaltRounds } from "../../config";
 
 /**
  * Return API key data for user with id [req.user_id]
  * @param req
- * @param res 
- * @returns 
+ * @param res
+ * @returns
  */
 export const getAPIKeyData = async (req: Request, res: Response) => {
-    const apiKeyData = await APIKeyData.find({
-        user: req.user._id
-    });
-    
-    return res.status(200).send({
-        apiKeyData
-    });
-}
+	const apiKeyData = await APIKeyData.find({
+		user: req.user._id,
+	});
+
+	return res.status(200).send({
+		apiKeyData,
+	});
+};
 
 /**
  * Create new API key data for user with id [req.user._id]
- * @param req 
- * @param res 
+ * @param req
+ * @param res
  */
 export const createAPIKeyData = async (req: Request, res: Response) => {
-    const { name, expiresIn } = req.body;
-    
-    const secret = crypto.randomBytes(16).toString('hex');
-    const secretHash = await bcrypt.hash(secret, await getSaltRounds());
-    
-    const expiresAt = new Date();
-    expiresAt.setSeconds(expiresAt.getSeconds() + expiresIn);
-    
-    let apiKeyData = await new APIKeyData({
-        name,
-        lastUsed: new Date(),
-        expiresAt,
-        user: req.user._id,
-        secretHash
-    }).save();
-    
-    // return api key data without sensitive data
-    // FIX: fix this any
-    apiKeyData = await APIKeyData.findById(apiKeyData._id) as any
-    
-    if (!apiKeyData) throw new Error('Failed to find API key data');
-    
-    const apiKey = `ak.${apiKeyData._id.toString()}.${secret}`;
-            
-    return res.status(200).send({
-        apiKey,
-        apiKeyData
-    });
-}
+	const { name, expiresIn } = req.body;
+
+	const secret = crypto.randomBytes(16).toString("hex");
+	const secretHash = await bcrypt.hash(secret, await getSaltRounds());
+
+	const expiresAt = new Date();
+	expiresAt.setSeconds(expiresAt.getSeconds() + expiresIn);
+
+	let apiKeyData = await new APIKeyData({
+		name,
+		lastUsed: new Date(),
+		expiresAt,
+		user: req.user._id,
+		secretHash,
+	}).save();
+
+	// return api key data without sensitive data
+	// FIX: fix this any
+	apiKeyData = (await APIKeyData.findById(apiKeyData._id)) as any;
+
+	if (!apiKeyData) throw new Error("Failed to find API key data");
+
+	const apiKey = `ak.${apiKeyData._id.toString()}.${secret}`;
+
+	return res.status(200).send({
+		apiKey,
+		apiKeyData,
+	});
+};
 
 /**
  * Delete API key data with id [apiKeyDataId].
- * @param req 
- * @param res 
- * @returns 
+ * @param req
+ * @param res
+ * @returns
  */
 export const deleteAPIKeyData = async (req: Request, res: Response) => {
-    const { apiKeyDataId } = req.params;
-    const apiKeyData = await APIKeyData.findByIdAndDelete(apiKeyDataId);
-    
-    return res.status(200).send({
-        apiKeyData
-    });
-}
+	const { apiKeyDataId } = req.params;
+	const apiKeyData = await APIKeyData.findByIdAndDelete(apiKeyDataId);
+
+	return res.status(200).send({
+		apiKeyData,
+	});
+};

backend/src/controllers/v2/authController.ts

@@ -1,27 +1,27 @@
 /* eslint-disable @typescript-eslint/no-var-requires */
-import { Request, Response } from 'express';
-import jwt from 'jsonwebtoken';
-import * as bigintConversion from 'bigint-conversion';
-const jsrp = require('jsrp');
-import { User, LoginSRPDetail } from '../../models';
-import { issueAuthTokens, createToken } from '../../helpers/auth';
-import { checkUserDevice } from '../../helpers/user';
-import { sendMail } from '../../helpers/nodemailer';
-import { TokenService } from '../../services';
-import { EELogService } from '../../ee/services';
-import { BadRequestError, InternalServerError } from '../../utils/errors';
+import { Request, Response } from "express";
+import jwt from "jsonwebtoken";
+import * as bigintConversion from "bigint-conversion";
+const jsrp = require("jsrp");
+import { LoginSRPDetail, User } from "../../models";
+import { createToken, issueAuthTokens } from "../../helpers/auth";
+import { checkUserDevice } from "../../helpers/user";
+import { sendMail } from "../../helpers/nodemailer";
+import { TokenService } from "../../services";
+import { EELogService } from "../../ee/services";
+import { BadRequestError, InternalServerError } from "../../utils/errors";
 import {
+  ACTION_LOGIN,
   TOKEN_EMAIL_MFA,
-  ACTION_LOGIN
-} from '../../variables';
-import { getChannelFromUserAgent } from '../../utils/posthog'; // TODO: move this
+} from "../../variables";
+import { getChannelFromUserAgent } from "../../utils/posthog"; // TODO: move this
 import {
+  getHttpsEnabled,
   getJwtMfaLifetime,
   getJwtMfaSecret,
-  getHttpsEnabled
-} from '../../config';
+} from "../../config";
 
-declare module 'jsonwebtoken' {
+declare module "jsonwebtoken" {
   export interface UserIDJwtPayload extends jwt.JwtPayload {
     userId: string;
   }
@@ -36,20 +36,20 @@ declare module 'jsonwebtoken' {
 export const login1 = async (req: Request, res: Response) => {
   const {
     email,
-    clientPublicKey
+    clientPublicKey,
   }: { email: string; clientPublicKey: string } = req.body;
 
   const user = await User.findOne({
-    email
-  }).select('+salt +verifier');
+    email,
+  }).select("+salt +verifier");
 
-  if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
   const server = new jsrp.server();
   server.init(
     {
       salt: user.salt,
-      verifier: user.verifier
+      verifier: user.verifier,
     },
     async () => {
       // generate server-side public key
@@ -63,7 +63,7 @@ export const login1 = async (req: Request, res: Response) => {
 
       return res.status(200).send({
         serverPublicKey,
-        salt: user.salt
+        salt: user.salt,
       });
     }
   );
@@ -78,14 +78,14 @@ export const login1 = async (req: Request, res: Response) => {
  * @returns
  */
 export const login2 = async (req: Request, res: Response) => {
-  if (!req.headers['user-agent']) throw InternalServerError({ message: 'User-Agent header is required' });
+  if (!req.headers["user-agent"]) throw InternalServerError({ message: "User-Agent header is required" });
 
   const { email, clientProof } = req.body;
   const user = await User.findOne({
-    email
-  }).select('+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag +devices');
+    email,
+  }).select("+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag +devices");
 
-  if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
   const loginSRPDetail = await LoginSRPDetail.findOneAndDelete({ email: email })
 
@@ -98,7 +98,7 @@ export const login2 = async (req: Request, res: Response) => {
     {
       salt: user.salt,
       verifier: user.verifier,
-      b: loginSRPDetail.serverBInt
+      b: loginSRPDetail.serverBInt,
     },
     async () => {
       server.setClientPublicKey(loginSRPDetail.clientPublicKey);
@@ -111,52 +111,52 @@ export const login2 = async (req: Request, res: Response) => {
           // generate temporary MFA token
           const token = createToken({
             payload: {
-              userId: user._id.toString()
+              userId: user._id.toString(),
             },
             expiresIn: await getJwtMfaLifetime(),
-            secret: await getJwtMfaSecret()
+            secret: await getJwtMfaSecret(),
           });
 
           const code = await TokenService.createToken({
             type: TOKEN_EMAIL_MFA,
-            email
+            email,
           });
 
           // send MFA code [code] to [email]
           await sendMail({
-            template: 'emailMfa.handlebars',
-            subjectLine: 'Infisical MFA code',
+            template: "emailMfa.handlebars",
+            subjectLine: "Infisical MFA code",
             recipients: [email],
             substitutions: {
-              code
-            }
+              code,
+            },
           });
 
           return res.status(200).send({
             mfaEnabled: true,
-            token
+            token,
           });
         }
 
         await checkUserDevice({
           user,
           ip: req.realIP,
-          userAgent: req.headers['user-agent'] ?? ''
+          userAgent: req.headers["user-agent"] ?? "",
         });
 
         // issue tokens
         const tokens = await issueAuthTokens({ 
           userId: user._id,
           ip: req.realIP,
-          userAgent: req.headers['user-agent'] ?? ''
+          userAgent: req.headers["user-agent"] ?? "",
         });
 
         // store (refresh) token in httpOnly cookie
-        res.cookie('jid', tokens.refreshToken, {
+        res.cookie("jid", tokens.refreshToken, {
           httpOnly: true,
-          path: '/',
-          sameSite: 'strict',
-          secure: await getHttpsEnabled()
+          path: "/",
+          sameSite: "strict",
+          secure: await getHttpsEnabled(),
         });
 
         // case: user does not have MFA enabled
@@ -182,7 +182,7 @@ export const login2 = async (req: Request, res: Response) => {
           publicKey: user.publicKey,
           encryptedPrivateKey: user.encryptedPrivateKey,
           iv: user.iv,
-          tag: user.tag
+          tag: user.tag,
         }
 
         if (
@@ -197,21 +197,21 @@ export const login2 = async (req: Request, res: Response) => {
 
         const loginAction = await EELogService.createAction({
           name: ACTION_LOGIN,
-          userId: user._id
+          userId: user._id,
         });
 
         loginAction && await EELogService.createLog({
           userId: user._id,
           actions: [loginAction],
-          channel: getChannelFromUserAgent(req.headers['user-agent']),
-          ipAddress: req.ip
+          channel: getChannelFromUserAgent(req.headers["user-agent"]),
+          ipAddress: req.ip,
         });
 
         return res.status(200).send(response);
       }
 
       return res.status(400).send({
-        message: 'Failed to authenticate. Try again?'
+        message: "Failed to authenticate. Try again?",
       });
     }
   );
@@ -227,21 +227,21 @@ export const sendMfaToken = async (req: Request, res: Response) => {
 
   const code = await TokenService.createToken({
     type: TOKEN_EMAIL_MFA,
-    email
+    email,
   });
 
   // send MFA code [code] to [email]
   await sendMail({
-    template: 'emailMfa.handlebars',
-    subjectLine: 'Infisical MFA code',
+    template: "emailMfa.handlebars",
+    subjectLine: "Infisical MFA code",
     recipients: [email],
     substitutions: {
-      code
-    }
+      code,
+    },
   });
 
   return res.status(200).send({
-    message: 'Successfully sent new MFA code'
+    message: "Successfully sent new MFA code",
   });
 }
 
@@ -257,36 +257,36 @@ export const verifyMfaToken = async (req: Request, res: Response) => {
   await TokenService.validateToken({
     type: TOKEN_EMAIL_MFA,
     email,
-    token: mfaToken
+    token: mfaToken,
   });
 
   const user = await User.findOne({
-    email
-  }).select('+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag +devices');
+    email,
+  }).select("+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag +devices");
 
-  if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
   await LoginSRPDetail.deleteOne({ userId: user.id })
 
   await checkUserDevice({
     user,
     ip: req.realIP,
-    userAgent: req.headers['user-agent'] ?? ''
+    userAgent: req.headers["user-agent"] ?? "",
   });
 
   // issue tokens
   const tokens = await issueAuthTokens({ 
     userId: user._id,
     ip: req.realIP,
-    userAgent: req.headers['user-agent'] ?? ''
+    userAgent: req.headers["user-agent"] ?? "",
   });
 
   // store (refresh) token in httpOnly cookie
-  res.cookie('jid', tokens.refreshToken, {
+  res.cookie("jid", tokens.refreshToken, {
     httpOnly: true,
-    path: '/',
-    sameSite: 'strict',
-    secure: await getHttpsEnabled()
+    path: "/",
+    sameSite: "strict",
+    secure: await getHttpsEnabled(),
   });
 
   interface VerifyMfaTokenRes {
@@ -319,7 +319,7 @@ export const verifyMfaToken = async (req: Request, res: Response) => {
     publicKey: user.publicKey as string,
     encryptedPrivateKey: user.encryptedPrivateKey as string,
     iv: user.iv as string,
-    tag: user.tag as string
+    tag: user.tag as string,
   }
 
   if (user?.protectedKey && user?.protectedKeyIV && user?.protectedKeyTag) {
@@ -330,14 +330,14 @@ export const verifyMfaToken = async (req: Request, res: Response) => {
 
   const loginAction = await EELogService.createAction({
     name: ACTION_LOGIN,
-    userId: user._id
+    userId: user._id,
   });
 
   loginAction && await EELogService.createLog({
     userId: user._id,
     actions: [loginAction],
-    channel: getChannelFromUserAgent(req.headers['user-agent']),
-    ipAddress: req.realIP
+    channel: getChannelFromUserAgent(req.headers["user-agent"]),
+    ipAddress: req.realIP,
   });
 
   return res.status(200).send(resObj);

backend/src/controllers/v2/environmentController.ts

@@ -1,17 +1,17 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
 import {
+  Integration,
+  Membership,
   Secret,
   ServiceToken,
-  Workspace,
-  Integration,
   ServiceTokenData,
-  Membership,
-} from '../../models';
-import { SecretVersion } from '../../ee/models';
-import { EELicenseService } from '../../ee/services';
-import { BadRequestError, WorkspaceNotFoundError } from '../../utils/errors';
-import _ from 'lodash';
-import { PERMISSION_READ_SECRETS, PERMISSION_WRITE_SECRETS } from '../../variables';
+  Workspace,
+} from "../../models";
+import { SecretVersion } from "../../ee/models";
+import { EELicenseService } from "../../ee/services";
+import { BadRequestError, WorkspaceNotFoundError } from "../../utils/errors";
+import _ from "lodash";
+import { PERMISSION_READ_SECRETS, PERMISSION_WRITE_SECRETS } from "../../variables";
 
 /**
  * Create new workspace environment named [environmentName] under workspace with id
@@ -38,7 +38,7 @@ export const createWorkspaceEnvironment = async (
       // case: number of environments used exceeds the number of environments allowed
       
       return res.status(400).send({
-        message: 'Failed to create environment due to environment limit reached. Upgrade plan to create more environments.'
+        message: "Failed to create environment due to environment limit reached. Upgrade plan to create more environments.",
       });
     }
   }
@@ -49,7 +49,7 @@ export const createWorkspaceEnvironment = async (
       ({ name, slug }) => slug === environmentSlug || environmentName === name
     )
   ) {
-    throw new Error('Failed to create workspace environment');
+    throw new Error("Failed to create workspace environment");
   }
 
   workspace?.environments.push({
@@ -61,7 +61,7 @@ export const createWorkspaceEnvironment = async (
   await EELicenseService.refreshPlan(workspace.organization.toString(), workspaceId);
 
   return res.status(200).send({
-    message: 'Successfully created new environment',
+    message: "Successfully created new environment",
     workspace: workspaceId,
     environment: {
       name: environmentName,
@@ -85,13 +85,13 @@ export const renameWorkspaceEnvironment = async (
   const { environmentName, environmentSlug, oldEnvironmentSlug } = req.body;
   // user should pass both new slug and env name
   if (!environmentSlug || !environmentName) {
-    throw new Error('Invalid environment given.');
+    throw new Error("Invalid environment given.");
   }
 
   // atomic update the env to avoid conflict
   const workspace = await Workspace.findById(workspaceId).exec();
   if (!workspace) {
-    throw new Error('Failed to create workspace environment');
+    throw new Error("Failed to create workspace environment");
   }
 
   const isEnvExist = workspace.environments.some(
@@ -100,14 +100,14 @@ export const renameWorkspaceEnvironment = async (
       (name === environmentName || slug === environmentSlug)
   );
   if (isEnvExist) {
-    throw new Error('Invalid environment given');
+    throw new Error("Invalid environment given");
   }
 
   const envIndex = workspace?.environments.findIndex(
     ({ slug }) => slug === oldEnvironmentSlug
   );
   if (envIndex === -1) {
-    throw new Error('Invalid environment given');
+    throw new Error("Invalid environment given");
   }
 
   workspace.environments[envIndex].name = environmentName;
@@ -137,7 +137,7 @@ export const renameWorkspaceEnvironment = async (
   await Membership.updateMany(
     {
       workspace: workspaceId,
-      "deniedPermissions.environmentSlug": oldEnvironmentSlug
+      "deniedPermissions.environmentSlug": oldEnvironmentSlug,
     },
     { $set: { "deniedPermissions.$[element].environmentSlug": environmentSlug } },
     { arrayFilters: [{ "element.environmentSlug": oldEnvironmentSlug }] }
@@ -145,7 +145,7 @@ export const renameWorkspaceEnvironment = async (
 
 
   return res.status(200).send({
-    message: 'Successfully update environment',
+    message: "Successfully update environment",
     workspace: workspaceId,
     environment: {
       name: environmentName,
@@ -169,14 +169,14 @@ export const deleteWorkspaceEnvironment = async (
   // atomic update the env to avoid conflict
   const workspace = await Workspace.findById(workspaceId).exec();
   if (!workspace) {
-    throw new Error('Failed to create workspace environment');
+    throw new Error("Failed to create workspace environment");
   }
 
   const envIndex = workspace?.environments.findIndex(
     ({ slug }) => slug === environmentSlug
   );
   if (envIndex === -1) {
-    throw new Error('Invalid environment given');
+    throw new Error("Invalid environment given");
   }
 
   workspace.environments.splice(envIndex, 1);
@@ -211,7 +211,7 @@ export const deleteWorkspaceEnvironment = async (
   await EELicenseService.refreshPlan(workspace.organization.toString(), workspaceId);
 
   return res.status(200).send({
-    message: 'Successfully deleted environment',
+    message: "Successfully deleted environment",
     workspace: workspaceId,
     environment: environmentSlug,
   });
@@ -225,7 +225,7 @@ export const getAllAccessibleEnvironmentsOfWorkspace = async (
   const { workspaceId } = req.params;
   const workspacesUserIsMemberOf = await Membership.findOne({
     workspace: workspaceId,
-    user: req.user
+    user: req.user,
   })
 
   if (!workspacesUserIsMemberOf) {
@@ -249,7 +249,7 @@ export const getAllAccessibleEnvironmentsOfWorkspace = async (
         name: environment.name,
         slug: environment.slug,
         isWriteDenied: isWriteBlocked,
-        isReadDenied: isReadBlocked
+        isReadDenied: isReadBlocked,
       })
     }
   })

backend/src/controllers/v2/index.ts

@@ -1,15 +1,15 @@
-import * as authController from './authController';
-import * as signupController from './signupController';
-import * as usersController from './usersController';
-import * as organizationsController from './organizationsController';
-import * as workspaceController from './workspaceController';
-import * as serviceTokenDataController from './serviceTokenDataController';
-import * as apiKeyDataController from './apiKeyDataController';
-import * as secretController from './secretController';
-import * as secretsController from './secretsController';
-import * as serviceAccountsController from './serviceAccountsController';
-import * as environmentController from './environmentController';
-import * as tagController from './tagController';
+import * as authController from "./authController";
+import * as signupController from "./signupController";
+import * as usersController from "./usersController";
+import * as organizationsController from "./organizationsController";
+import * as workspaceController from "./workspaceController";
+import * as serviceTokenDataController from "./serviceTokenDataController";
+import * as apiKeyDataController from "./apiKeyDataController";
+import * as secretController from "./secretController";
+import * as secretsController from "./secretsController";
+import * as serviceAccountsController from "./serviceAccountsController";
+import * as environmentController from "./environmentController";
+import * as tagController from "./tagController";
 
 export {
     authController,
@@ -23,5 +23,5 @@ export {
     secretsController,
     serviceAccountsController,
     environmentController,
-    tagController
+    tagController,
 }

backend/src/controllers/v2/organizationsController.ts

@@ -1,13 +1,13 @@
-import { Request, Response } from 'express';
-import { Types } from 'mongoose';
+import { Request, Response } from "express";
+import { Types } from "mongoose";
 import { 
-    MembershipOrg,
     Membership,
+    MembershipOrg,
+    ServiceAccount,
     Workspace,
-    ServiceAccount
-} from '../../models';
-import { deleteMembershipOrg } from '../../helpers/membershipOrg';
-import { updateSubscriptionOrgQuantity } from '../../helpers/organization';
+} from "../../models";
+import { deleteMembershipOrg } from "../../helpers/membershipOrg";
+import { updateSubscriptionOrgQuantity } from "../../helpers/organization";
 
 /**
  * Return memberships for organization with id [organizationId]
@@ -51,11 +51,11 @@ export const getOrganizationMemberships = async (req: Request, res: Response) =>
     const { organizationId } = req.params;
 
 		const memberships = await MembershipOrg.find({
-			organization: organizationId
-		}).populate('user', '+publicKey');
+			organization: organizationId,
+		}).populate("user", "+publicKey");
     
     return res.status(200).send({
-        memberships
+        memberships,
     });
 }
 
@@ -124,14 +124,14 @@ export const updateOrganizationMembership = async (req: Request, res: Response)
     const membership = await MembershipOrg.findByIdAndUpdate(
         membershipId,
         {
-            role
+            role,
         }, {
-            new: true
+            new: true,
         }
     );
     
     return res.status(200).send({
-        membership
+        membership,
     });
 }
 
@@ -182,15 +182,15 @@ export const deleteOrganizationMembership = async (req: Request, res: Response)
     
     // delete organization membership
     const membership = await deleteMembershipOrg({
-        membershipOrgId: membershipId
+        membershipOrgId: membershipId,
     });
 
     await updateSubscriptionOrgQuantity({
-			organizationId: membership.organization.toString()
+			organizationId: membership.organization.toString(),
 		});
 
     return res.status(200).send({
-        membership
+        membership,
     });
 }
 
@@ -240,23 +240,23 @@ export const getOrganizationWorkspaces = async (req: Request, res: Response) =>
         (
             await Workspace.find(
                 {
-                    organization: organizationId
+                    organization: organizationId,
                 },
-                '_id'
+                "_id"
             )
         ).map((w) => w._id.toString())
     );
 
     const workspaces = (
         await Membership.find({
-            user: req.user._id
-        }).populate('workspace')
+            user: req.user._id,
+        }).populate("workspace")
     )
     .filter((m) => workspacesSet.has(m.workspace._id.toString()))
     .map((m) => m.workspace);
 
 return res.status(200).send({
-        workspaces
+        workspaces,
     });
 }
 
@@ -269,10 +269,10 @@ export const getOrganizationServiceAccounts = async (req: Request, res: Response
     const { organizationId } = req.params;
     
     const serviceAccounts = await ServiceAccount.find({
-        organization: new Types.ObjectId(organizationId)
+        organization: new Types.ObjectId(organizationId),
     });
     
     return res.status(200).send({
-        serviceAccounts
+        serviceAccounts,
     });
 }

backend/src/controllers/v2/secretController.ts

@@ -2,24 +2,39 @@ import to from "await-to-js";
 import { Request, Response } from "express";
 import mongoose, { Types } from "mongoose";
 import Secret, { ISecret } from "../../models/secret";
-import { CreateSecretRequestBody, ModifySecretRequestBody, SanitizedSecretForCreate, SanitizedSecretModify } from "../../types/secret";
+import {
+  CreateSecretRequestBody,
+  ModifySecretRequestBody,
+  SanitizedSecretForCreate,
+  SanitizedSecretModify
+} from "../../types/secret";
 const { ValidationError } = mongoose.Error;
-import { BadRequestError, InternalServerError, UnauthorizedRequestError, ValidationError as RouteValidationError } from '../../utils/errors';
-import { AnyBulkWriteOperation } from 'mongodb';
-import { ALGORITHM_AES_256_GCM, ENCODING_SCHEME_UTF8, SECRET_PERSONAL, SECRET_SHARED } from "../../variables";
-import { TelemetryService } from '../../services';
+import {
+  BadRequestError,
+  InternalServerError,
+  ValidationError as RouteValidationError,
+  UnauthorizedRequestError
+} from "../../utils/errors";
+import { AnyBulkWriteOperation } from "mongodb";
+import {
+  ALGORITHM_AES_256_GCM,
+  ENCODING_SCHEME_UTF8,
+  SECRET_PERSONAL,
+  SECRET_SHARED
+} from "../../variables";
+import { TelemetryService } from "../../services";
 import { User } from "../../models";
-import { AccountNotFoundError } from '../../utils/errors';
+import { AccountNotFoundError } from "../../utils/errors";
 
 /**
  * Create secret for workspace with id [workspaceId] and environment [environment]
- * @param req 
- * @param res 
+ * @param req
+ * @param res
  */
 export const createSecret = async (req: Request, res: Response) => {
   const postHogClient = await TelemetryService.getPostHogClient();
   const secretToCreate: CreateSecretRequestBody = req.body.secret;
-  const { workspaceId, environment } = req.params
+  const { workspaceId, environment } = req.params;
   const sanitizedSecret: SanitizedSecretForCreate = {
     secretKeyCiphertext: secretToCreate.secretKeyCiphertext,
     secretKeyIV: secretToCreate.secretKeyIV,
@@ -39,45 +54,44 @@ export const createSecret = async (req: Request, res: Response) => {
     user: new Types.ObjectId(req.user._id),
     algorithm: ALGORITHM_AES_256_GCM,
     keyEncoding: ENCODING_SCHEME_UTF8
-  }
+  };
 
-
-  const [error, secret] = await to(Secret.create(sanitizedSecret).then())
+  const [error, secret] = await to(Secret.create(sanitizedSecret).then());
   if (error instanceof ValidationError) {
-    throw RouteValidationError({ message: error.message, stack: error.stack })
+    throw RouteValidationError({ message: error.message, stack: error.stack });
   }
 
   if (postHogClient) {
     postHogClient.capture({
-      event: 'secrets added',
+      event: "secrets added",
       distinctId: req.user.email,
       properties: {
         numberOfSecrets: 1,
         workspaceId,
         environment,
-        channel: req.headers?.['user-agent']?.toLowerCase().includes('mozilla') ? 'web' : 'cli',
-        userAgent: req.headers?.['user-agent']
+        channel: req.headers?.["user-agent"]?.toLowerCase().includes("mozilla") ? "web" : "cli",
+        userAgent: req.headers?.["user-agent"]
       }
     });
   }
 
   res.status(200).send({
     secret
-  })
-}
+  });
+};
 
 /**
  * Create many secrets for workspace wiht id [workspaceId] and environment [environment]
- * @param req 
- * @param res 
+ * @param req
+ * @param res
  */
 export const createSecrets = async (req: Request, res: Response) => {
   const postHogClient = await TelemetryService.getPostHogClient();
   const secretsToCreate: CreateSecretRequestBody[] = req.body.secrets;
-  const { workspaceId, environment } = req.params
-  const sanitizedSecretesToCreate: SanitizedSecretForCreate[] = []
+  const { workspaceId, environment } = req.params;
+  const sanitizedSecretesToCreate: SanitizedSecretForCreate[] = [];
 
-  secretsToCreate.forEach(rawSecret => {
+  secretsToCreate.forEach((rawSecret) => {
     const safeUpdateFields: SanitizedSecretForCreate = {
       secretKeyCiphertext: rawSecret.secretKeyCiphertext,
       secretKeyIV: rawSecret.secretKeyIV,
@@ -97,140 +111,163 @@ export const createSecrets = async (req: Request, res: Response) => {
       user: new Types.ObjectId(req.user._id),
       algorithm: ALGORITHM_AES_256_GCM,
       keyEncoding: ENCODING_SCHEME_UTF8
-    }
+    };
 
-    sanitizedSecretesToCreate.push(safeUpdateFields)
-  })
+    sanitizedSecretesToCreate.push(safeUpdateFields);
+  });
 
-  const [bulkCreateError, secrets] = await to(Secret.insertMany(sanitizedSecretesToCreate).then())
+  const [bulkCreateError, secrets] = await to(Secret.insertMany(sanitizedSecretesToCreate).then());
   if (bulkCreateError) {
     if (bulkCreateError instanceof ValidationError) {
-      throw RouteValidationError({ message: bulkCreateError.message, stack: bulkCreateError.stack })
+      throw RouteValidationError({
+        message: bulkCreateError.message,
+        stack: bulkCreateError.stack
+      });
     }
 
-    throw InternalServerError({ message: "Unable to process your batch create request. Please try again", stack: bulkCreateError.stack })
+    throw InternalServerError({
+      message: "Unable to process your batch create request. Please try again",
+      stack: bulkCreateError.stack
+    });
   }
 
   if (postHogClient) {
     postHogClient.capture({
-      event: 'secrets added',
+      event: "secrets added",
       distinctId: req.user.email,
       properties: {
         numberOfSecrets: (secretsToCreate ?? []).length,
         workspaceId,
         environment,
-        channel: req.headers?.['user-agent']?.toLowerCase().includes('mozilla') ? 'web' : 'cli',
-        userAgent: req.headers?.['user-agent']
+        channel: req.headers?.["user-agent"]?.toLowerCase().includes("mozilla") ? "web" : "cli",
+        userAgent: req.headers?.["user-agent"]
       }
     });
   }
 
   res.status(200).send({
     secrets
-  })
-}
+  });
+};
 
 /**
  * Delete secrets in workspace with id [workspaceId] and environment [environment]
- * @param req 
- * @param res 
+ * @param req
+ * @param res
  */
 export const deleteSecrets = async (req: Request, res: Response) => {
   const postHogClient = await TelemetryService.getPostHogClient();
-  const { workspaceId, environmentName } = req.params
-  const secretIdsToDelete: string[] = req.body.secretIds
+  const { workspaceId, environmentName } = req.params;
+  const secretIdsToDelete: string[] = req.body.secretIds;
 
-  const [secretIdsUserCanDeleteError, secretIdsUserCanDelete] = await to(Secret.find({ workspace: workspaceId, environment: environmentName }, { _id: 1 }).then())
+  const [secretIdsUserCanDeleteError, secretIdsUserCanDelete] = await to(
+    Secret.find({ workspace: workspaceId, environment: environmentName }, { _id: 1 }).then()
+  );
   if (secretIdsUserCanDeleteError) {
-    throw InternalServerError({ message: `Unable to fetch secrets you own: [error=${secretIdsUserCanDeleteError.message}]` })
+    throw InternalServerError({
+      message: `Unable to fetch secrets you own: [error=${secretIdsUserCanDeleteError.message}]`
+    });
   }
 
-  const secretsUserCanDeleteSet: Set<string> = new Set(secretIdsUserCanDelete.map(objectId => objectId._id.toString()));
-  const deleteOperationsToPerform: AnyBulkWriteOperation<ISecret>[] = []
+  const secretsUserCanDeleteSet: Set<string> = new Set(
+    secretIdsUserCanDelete.map((objectId) => objectId._id.toString())
+  );
+  const deleteOperationsToPerform: AnyBulkWriteOperation<ISecret>[] = [];
 
   let numSecretsDeleted = 0;
-  secretIdsToDelete.forEach(secretIdToDelete => {
+  secretIdsToDelete.forEach((secretIdToDelete) => {
     if (secretsUserCanDeleteSet.has(secretIdToDelete)) {
-      const deleteOperation = { deleteOne: { filter: { _id: new Types.ObjectId(secretIdToDelete) } } }
-      deleteOperationsToPerform.push(deleteOperation)
+      const deleteOperation = {
+        deleteOne: { filter: { _id: new Types.ObjectId(secretIdToDelete) } }
+      };
+      deleteOperationsToPerform.push(deleteOperation);
       numSecretsDeleted++;
     } else {
-      throw RouteValidationError({ message: "You cannot delete secrets that you do not have access to" })
+      throw RouteValidationError({
+        message: "You cannot delete secrets that you do not have access to"
+      });
     }
-  })
+  });
 
-  const [bulkDeleteError, bulkDelete] = await to(Secret.bulkWrite(deleteOperationsToPerform).then())
+  const [bulkDeleteError] = await to(Secret.bulkWrite(deleteOperationsToPerform).then());
   if (bulkDeleteError) {
     if (bulkDeleteError instanceof ValidationError) {
-      throw RouteValidationError({ message: "Unable to apply modifications, please try again", stack: bulkDeleteError.stack })
+      throw RouteValidationError({
+        message: "Unable to apply modifications, please try again",
+        stack: bulkDeleteError.stack
+      });
     }
-    throw InternalServerError()
+    throw InternalServerError();
   }
 
   if (postHogClient) {
     postHogClient.capture({
-      event: 'secrets deleted',
+      event: "secrets deleted",
       distinctId: req.user.email,
       properties: {
         numberOfSecrets: numSecretsDeleted,
         environment: environmentName,
         workspaceId,
-        channel: req.headers?.['user-agent']?.toLowerCase().includes('mozilla') ? 'web' : 'cli',
-        userAgent: req.headers?.['user-agent']
+        channel: req.headers?.["user-agent"]?.toLowerCase().includes("mozilla") ? "web" : "cli",
+        userAgent: req.headers?.["user-agent"]
       }
     });
   }
 
-  res.status(200).send()
-}
+  res.status(200).send();
+};
 
 /**
  * Delete secret with id [secretId]
- * @param req 
+ * @param req
  * @param res
  */
 export const deleteSecret = async (req: Request, res: Response) => {
   const postHogClient = await TelemetryService.getPostHogClient();
-  await Secret.findByIdAndDelete(req._secret._id)
+  await Secret.findByIdAndDelete(req._secret._id);
 
   if (postHogClient) {
     postHogClient.capture({
-      event: 'secrets deleted',
+      event: "secrets deleted",
       distinctId: req.user.email,
       properties: {
         numberOfSecrets: 1,
         workspaceId: req._secret.workspace.toString(),
         environment: req._secret.environment,
-        channel: req.headers?.['user-agent']?.toLowerCase().includes('mozilla') ? 'web' : 'cli',
-        userAgent: req.headers?.['user-agent']
+        channel: req.headers?.["user-agent"]?.toLowerCase().includes("mozilla") ? "web" : "cli",
+        userAgent: req.headers?.["user-agent"]
       }
     });
   }
 
   res.status(200).send({
     secret: req._secret
-  })
-}
+  });
+};
 
 /**
  * Update secrets for workspace with id [workspaceId] and environment [environment]
- * @param req 
- * @param res 
- * @returns 
+ * @param req
+ * @param res
+ * @returns
  */
 export const updateSecrets = async (req: Request, res: Response) => {
   const postHogClient = await TelemetryService.getPostHogClient();
-  const { workspaceId, environmentName } = req.params
+  const { workspaceId, environmentName } = req.params;
   const secretsModificationsRequested: ModifySecretRequestBody[] = req.body.secrets;
-  const [secretIdsUserCanModifyError, secretIdsUserCanModify] = await to(Secret.find({ workspace: workspaceId, environment: environmentName }, { _id: 1 }).then())
+  const [secretIdsUserCanModifyError, secretIdsUserCanModify] = await to(
+    Secret.find({ workspace: workspaceId, environment: environmentName }, { _id: 1 }).then()
+  );
   if (secretIdsUserCanModifyError) {
-    throw InternalServerError({ message: "Unable to fetch secrets you own" })
+    throw InternalServerError({ message: "Unable to fetch secrets you own" });
   }
 
-  const secretsUserCanModifySet: Set<string> = new Set(secretIdsUserCanModify.map(objectId => objectId._id.toString()));
-  const updateOperationsToPerform: any = []
+  const secretsUserCanModifySet: Set<string> = new Set(
+    secretIdsUserCanModify.map((objectId) => objectId._id.toString())
+  );
+  const updateOperationsToPerform: any = [];
 
-  secretsModificationsRequested.forEach(userModifiedSecret => {
+  secretsModificationsRequested.forEach((userModifiedSecret) => {
     if (secretsUserCanModifySet.has(userModifiedSecret._id.toString())) {
       const sanitizedSecret: SanitizedSecretModify = {
         secretKeyCiphertext: userModifiedSecret.secretKeyCiphertext,
@@ -244,56 +281,70 @@ export const updateSecrets = async (req: Request, res: Response) => {
         secretCommentCiphertext: userModifiedSecret.secretCommentCiphertext,
         secretCommentIV: userModifiedSecret.secretCommentIV,
         secretCommentTag: userModifiedSecret.secretCommentTag,
-        secretCommentHash: userModifiedSecret.secretCommentHash,
-      }
+        secretCommentHash: userModifiedSecret.secretCommentHash
+      };
 
-      const updateOperation = { updateOne: { filter: { _id: userModifiedSecret._id, workspace: workspaceId }, update: { $inc: { version: 1 }, $set: sanitizedSecret } } }
-      updateOperationsToPerform.push(updateOperation)
+      const updateOperation = {
+        updateOne: {
+          filter: { _id: userModifiedSecret._id, workspace: workspaceId },
+          update: { $inc: { version: 1 }, $set: sanitizedSecret }
+        }
+      };
+      updateOperationsToPerform.push(updateOperation);
     } else {
-      throw UnauthorizedRequestError({ message: "You do not have permission to modify one or more of the requested secrets" })
+      throw UnauthorizedRequestError({
+        message: "You do not have permission to modify one or more of the requested secrets"
+      });
     }
-  })
+  });
 
-  const [bulkModificationInfoError, bulkModificationInfo] = await to(Secret.bulkWrite(updateOperationsToPerform).then())
+  const [bulkModificationInfoError, bulkModificationInfo] = await to(
+    Secret.bulkWrite(updateOperationsToPerform).then()
+  );
   if (bulkModificationInfoError) {
     if (bulkModificationInfoError instanceof ValidationError) {
-      throw RouteValidationError({ message: "Unable to apply modifications, please try again", stack: bulkModificationInfoError.stack })
+      throw RouteValidationError({
+        message: "Unable to apply modifications, please try again",
+        stack: bulkModificationInfoError.stack
+      });
     }
 
-    throw InternalServerError()
+    throw InternalServerError();
   }
 
   if (postHogClient) {
     postHogClient.capture({
-      event: 'secrets modified',
+      event: "secrets modified",
       distinctId: req.user.email,
       properties: {
         numberOfSecrets: (secretsModificationsRequested ?? []).length,
         environment: environmentName,
         workspaceId,
-        channel: req.headers?.['user-agent']?.toLowerCase().includes('mozilla') ? 'web' : 'cli',
-        userAgent: req.headers?.['user-agent']
+        channel: req.headers?.["user-agent"]?.toLowerCase().includes("mozilla") ? "web" : "cli",
+        userAgent: req.headers?.["user-agent"]
       }
     });
   }
 
-  return res.status(200).send()
-}
+  return res.status(200).send();
+};
 
 /**
  * Update a secret within workspace with id [workspaceId] and environment [environment]
- * @param req 
- * @param res 
- * @returns 
+ * @param req
+ * @param res
+ * @returns
  */
 export const updateSecret = async (req: Request, res: Response) => {
   const postHogClient = await TelemetryService.getPostHogClient();
-  const { workspaceId, environmentName } = req.params
+  const { workspaceId, environmentName } = req.params;
   const secretModificationsRequested: ModifySecretRequestBody = req.body.secret;
 
-  const [secretIdUserCanModifyError, secretIdUserCanModify] = await to(Secret.findOne({ workspace: workspaceId, environment: environmentName }, { _id: 1 }).then())
+  const [secretIdUserCanModifyError, secretIdUserCanModify] = await to(
+    Secret.findOne({ workspace: workspaceId, environment: environmentName }, { _id: 1 }).then()
+  );
   if (secretIdUserCanModifyError && !secretIdUserCanModify) {
-    throw BadRequestError()
+    throw BadRequestError();
   }
 
   const sanitizedSecret: SanitizedSecretModify = {
@@ -308,45 +359,53 @@ export const updateSecret = async (req: Request, res: Response) => {
     secretCommentCiphertext: secretModificationsRequested.secretCommentCiphertext,
     secretCommentIV: secretModificationsRequested.secretCommentIV,
     secretCommentTag: secretModificationsRequested.secretCommentTag,
-    secretCommentHash: secretModificationsRequested.secretCommentHash,
-  }
+    secretCommentHash: secretModificationsRequested.secretCommentHash
+  };
 
-  const [error, singleModificationUpdate] = await to(Secret.updateOne({ _id: secretModificationsRequested._id, workspace: workspaceId }, { $inc: { version: 1 }, $set: sanitizedSecret }).then())
+  const [error, singleModificationUpdate] = await to(
+    Secret.updateOne(
+      { _id: secretModificationsRequested._id, workspace: workspaceId },
+      { $inc: { version: 1 }, $set: sanitizedSecret }
+    ).then()
+  );
   if (error instanceof ValidationError) {
-    throw RouteValidationError({ message: "Unable to apply modifications, please try again", stack: error.stack })
+    throw RouteValidationError({
+      message: "Unable to apply modifications, please try again",
+      stack: error.stack
+    });
   }
 
   if (postHogClient) {
     postHogClient.capture({
-      event: 'secrets modified',
+      event: "secrets modified",
       distinctId: req.user.email,
       properties: {
         numberOfSecrets: 1,
         environment: environmentName,
         workspaceId,
-        channel: req.headers?.['user-agent']?.toLowerCase().includes('mozilla') ? 'web' : 'cli',
-        userAgent: req.headers?.['user-agent']
+        channel: req.headers?.["user-agent"]?.toLowerCase().includes("mozilla") ? "web" : "cli",
+        userAgent: req.headers?.["user-agent"]
       }
     });
   }
 
-  return res.status(200).send(singleModificationUpdate)
-}
+  return res.status(200).send(singleModificationUpdate);
+};
 
 /**
  * Return secrets for workspace with id [workspaceId], environment [environment] and user
  * with id [req.user._id]
- * @param req 
- * @param res 
- * @returns 
+ * @param req
+ * @param res
+ * @returns
  */
 export const getSecrets = async (req: Request, res: Response) => {
   const postHogClient = await TelemetryService.getPostHogClient();
   const { environment } = req.query;
   const { workspaceId } = req.params;
 
-  let userId: Types.ObjectId | undefined = undefined // used for getting personal secrets for user
-  let userEmail: string | undefined = undefined // used for posthog 
+  let userId: Types.ObjectId | undefined = undefined; // used for getting personal secrets for user
+  let userEmail: string | undefined = undefined; // used for posthog
   if (req.user) {
     userId = req.user._id;
     userEmail = req.user.email;
@@ -354,47 +413,50 @@ export const getSecrets = async (req: Request, res: Response) => {
 
   if (req.serviceTokenData) {
     userId = req.serviceTokenData.user;
-    
-    const user = await User.findById(req.serviceTokenData.user, 'email');
+
+    const user = await User.findById(req.serviceTokenData.user, "email");
     if (!user) throw AccountNotFoundError();
     userEmail = user.email;
   }
 
-  const [err, secrets] = await to(Secret.find(
-    {
+  const [err, secrets] = await to(
+    Secret.find({
       workspace: workspaceId,
       environment,
       $or: [{ user: userId }, { user: { $exists: false } }],
       type: { $in: [SECRET_SHARED, SECRET_PERSONAL] }
-    }
-  ).then())
+    }).then()
+  );
 
   if (err) {
-    throw RouteValidationError({ message: "Failed to get secrets, please try again", stack: err.stack })
+    throw RouteValidationError({
+      message: "Failed to get secrets, please try again",
+      stack: err.stack
+    });
   }
 
   if (postHogClient) {
     postHogClient.capture({
-      event: 'secrets pulled',
+      event: "secrets pulled",
       distinctId: userEmail,
       properties: {
         numberOfSecrets: (secrets ?? []).length,
         environment,
         workspaceId,
-        channel: req.headers?.['user-agent']?.toLowerCase().includes('mozilla') ? 'web' : 'cli',
-        userAgent: req.headers?.['user-agent']
+        channel: req.headers?.["user-agent"]?.toLowerCase().includes("mozilla") ? "web" : "cli",
+        userAgent: req.headers?.["user-agent"]
       }
     });
   }
 
-  return res.json(secrets)
-}
+  return res.json(secrets);
+};
 
 /**
  * Return secret with id [secretId]
- * @param req 
- * @param res 
- * @returns 
+ * @param req
+ * @param res
+ * @returns
  */
 export const getSecret = async (req: Request, res: Response) => {
   // if (postHogClient) {
@@ -414,4 +476,4 @@ export const getSecret = async (req: Request, res: Response) => {
   return res.status(200).send({
     secret: req._secret
   });
-}
+};

backend/src/controllers/v2/secretsController.ts

@@ -3,19 +3,19 @@ import { Request, Response } from "express";
 import { ISecret, Secret, ServiceTokenData } from "../../models";
 import { IAction, SecretVersion } from "../../ee/models";
 import {
-  SECRET_PERSONAL,
   ACTION_ADD_SECRETS,
+  ACTION_DELETE_SECRETS,
   ACTION_READ_SECRETS,
   ACTION_UPDATE_SECRETS,
-  ACTION_DELETE_SECRETS,
   ALGORITHM_AES_256_GCM,
   ENCODING_SCHEME_UTF8,
+  SECRET_PERSONAL,
 } from "../../variables";
 import { BadRequestError, UnauthorizedRequestError } from "../../utils/errors";
 import { EventService } from "../../services";
 import { eventPushSecrets } from "../../events";
-import { EESecretService, EELogService } from "../../ee/services";
-import { TelemetryService, SecretService } from "../../services";
+import { EELogService, EESecretService } from "../../ee/services";
+import { SecretService, TelemetryService } from "../../services";
 import { getChannelFromUserAgent } from "../../utils/posthog";
 import { PERMISSION_WRITE_SECRETS } from "../../variables";
 import {
@@ -25,7 +25,7 @@ import {
 } from "../../ee/helpers/checkMembershipPermissions";
 import Tag from "../../models/tag";
 import _ from "lodash";
-import { BatchSecretRequest, BatchSecret } from "../../types/secret";
+import { BatchSecret, BatchSecretRequest } from "../../types/secret";
 import Folder from "../../models/folder";
 import {
   getFolderByPath,

backend/src/controllers/v2/serviceAccountsController.ts

@@ -1,18 +1,18 @@
-import { Request, Response } from 'express';
-import { Types } from 'mongoose';
-import crypto from 'crypto';
-import bcrypt from 'bcrypt';
+import { Request, Response } from "express";
+import { Types } from "mongoose";
+import crypto from "crypto";
+import bcrypt from "bcrypt";
 import { 
     ServiceAccount,
     ServiceAccountKey,
     ServiceAccountOrganizationPermission,
-    ServiceAccountWorkspacePermission
-} from '../../models';
+    ServiceAccountWorkspacePermission,
+} from "../../models";
 import {
-    CreateServiceAccountDto
-} from '../../interfaces/serviceAccounts/dto';
-import { BadRequestError, ServiceAccountNotFoundError } from '../../utils/errors';
-import { getSaltRounds } from '../../config';
+    CreateServiceAccountDto,
+} from "../../interfaces/serviceAccounts/dto";
+import { BadRequestError, ServiceAccountNotFoundError } from "../../utils/errors";
+import { getSaltRounds } from "../../config";
 
 /**
  * Return service account tied to the request (service account) client
@@ -23,11 +23,11 @@ export const getCurrentServiceAccount = async (req: Request, res: Response) => {
     const serviceAccount = await ServiceAccount.findById(req.serviceAccount._id);
     
     if (!serviceAccount) {
-        throw ServiceAccountNotFoundError({ message: 'Failed to find service account' });
+        throw ServiceAccountNotFoundError({ message: "Failed to find service account" });
     }
     
     return res.status(200).send({
-        serviceAccount
+        serviceAccount,
     });
 }
 
@@ -42,11 +42,11 @@ export const getServiceAccountById = async (req: Request, res: Response) => {
     const serviceAccount = await ServiceAccount.findById(serviceAccountId);
     
     if (!serviceAccount) {
-        throw ServiceAccountNotFoundError({ message: 'Failed to find service account' });
+        throw ServiceAccountNotFoundError({ message: "Failed to find service account" });
     }
     
     return res.status(200).send({
-        serviceAccount
+        serviceAccount,
     });
 }
 
@@ -71,7 +71,7 @@ export const createServiceAccount = async (req: Request, res: Response) => {
         expiresAt.setSeconds(expiresAt.getSeconds() + expiresIn);
     }
 
-    const secret = crypto.randomBytes(16).toString('base64');
+    const secret = crypto.randomBytes(16).toString("base64");
     const secretHash = await bcrypt.hash(secret, await getSaltRounds());
     
     // create service account
@@ -82,7 +82,7 @@ export const createServiceAccount = async (req: Request, res: Response) => {
         publicKey,
         lastUsed: new Date(),
         expiresAt,
-        secretHash
+        secretHash,
     }).save();
     
     const serviceAccountObj = serviceAccount.toObject();
@@ -91,14 +91,14 @@ export const createServiceAccount = async (req: Request, res: Response) => {
 
     // provision default org-level permission for service account
     await new ServiceAccountOrganizationPermission({
-        serviceAccount: serviceAccount._id
+        serviceAccount: serviceAccount._id,
     }).save();
     
-    const secretId = Buffer.from(serviceAccount._id.toString(), 'hex').toString('base64');
+    const secretId = Buffer.from(serviceAccount._id.toString(), "hex").toString("base64");
 
     return res.status(200).send({
         serviceAccountAccessKey: `sa.${secretId}.${secret}`,
-        serviceAccount: serviceAccountObj
+        serviceAccount: serviceAccountObj,
     });
 }
 
@@ -114,18 +114,18 @@ export const changeServiceAccountName = async (req: Request, res: Response) => {
     
     const serviceAccount = await ServiceAccount.findOneAndUpdate(
         {
-            _id: new Types.ObjectId(serviceAccountId)
+            _id: new Types.ObjectId(serviceAccountId),
         },
         {
-            name
+            name,
         },
         {
-            new: true
+            new: true,
         }
     );
     
     return res.status(200).send({
-        serviceAccount
+        serviceAccount,
     });
 }
 
@@ -140,7 +140,7 @@ export const addServiceAccountKey = async (req: Request, res: Response) => {
     const {
         workspaceId,
         encryptedKey,
-        nonce
+        nonce,
     } = req.body;
     
     const serviceAccountKey = await new ServiceAccountKey({
@@ -148,7 +148,7 @@ export const addServiceAccountKey = async (req: Request, res: Response) => {
         nonce,
         sender: req.user._id,
         serviceAccount: req.serviceAccount._d,
-        workspace: new Types.ObjectId(workspaceId)
+        workspace: new Types.ObjectId(workspaceId),
     }).save();
 
     return serviceAccountKey;
@@ -161,11 +161,11 @@ export const addServiceAccountKey = async (req: Request, res: Response) => {
  */
 export const getServiceAccountWorkspacePermissions = async (req: Request, res: Response) => {
     const serviceAccountWorkspacePermissions = await ServiceAccountWorkspacePermission.find({
-        serviceAccount: req.serviceAccount._id
-    }).populate('workspace');
+        serviceAccount: req.serviceAccount._id,
+    }).populate("workspace");
     
     return res.status(200).send({
-        serviceAccountWorkspacePermissions
+        serviceAccountWorkspacePermissions,
     });
 }
 
@@ -182,34 +182,34 @@ export const addServiceAccountWorkspacePermission = async (req: Request, res: Re
         read = false,
         write = false,
         encryptedKey,
-        nonce
+        nonce,
     } = req.body;
     
     if (!req.membership.workspace.environments.some((e: { name: string; slug: string }) => e.slug === environment)) {
         return res.status(400).send({
-            message: 'Failed to validate workspace environment'
+            message: "Failed to validate workspace environment",
         });
     }
     
     const existingPermission = await ServiceAccountWorkspacePermission.findOne({
         serviceAccount: new Types.ObjectId(serviceAccountId),
         workspace: new Types.ObjectId(workspaceId),
-        environment
+        environment,
     });
     
-    if (existingPermission) throw BadRequestError({ message: 'Failed to add workspace permission to service account due to already-existing ' });
+    if (existingPermission) throw BadRequestError({ message: "Failed to add workspace permission to service account due to already-existing " });
 
     const serviceAccountWorkspacePermission = await new ServiceAccountWorkspacePermission({
         serviceAccount: new Types.ObjectId(serviceAccountId),
         workspace: new Types.ObjectId(workspaceId),
         environment,
         read,
-        write
+        write,
     }).save();
     
     const existingServiceAccountKey = await ServiceAccountKey.findOne({
         serviceAccount: new Types.ObjectId(serviceAccountId),
-        workspace: new Types.ObjectId(workspaceId) 
+        workspace: new Types.ObjectId(workspaceId), 
     });
     
     if (!existingServiceAccountKey) {
@@ -218,12 +218,12 @@ export const addServiceAccountWorkspacePermission = async (req: Request, res: Re
             nonce,
             sender: req.user._id,
             serviceAccount: new Types.ObjectId(serviceAccountId),
-            workspace: new Types.ObjectId(workspaceId)
+            workspace: new Types.ObjectId(workspaceId),
         }).save();
     }
 
     return res.status(200).send({
-        serviceAccountWorkspacePermission
+        serviceAccountWorkspacePermission,
     });
 }
 
@@ -240,19 +240,19 @@ export const deleteServiceAccountWorkspacePermission = async (req: Request, res:
         const { serviceAccount, workspace } = serviceAccountWorkspacePermission;
         const count = await ServiceAccountWorkspacePermission.countDocuments({
             serviceAccount,
-            workspace
+            workspace,
         });
         
         if (count === 0) {
             await ServiceAccountKey.findOneAndDelete({
                 serviceAccount,
-                workspace
+                workspace,
             });
         }
     }
 
     return res.status(200).send({
-        serviceAccountWorkspacePermission
+        serviceAccountWorkspacePermission,
     });
 }
 
@@ -269,20 +269,20 @@ export const deleteServiceAccount = async (req: Request, res: Response) => {
 
     if (serviceAccount) {
         await ServiceAccountKey.deleteMany({
-            serviceAccount: serviceAccount._id
+            serviceAccount: serviceAccount._id,
         });
 
         await ServiceAccountOrganizationPermission.deleteMany({
-            serviceAccount: new Types.ObjectId(serviceAccountId)
+            serviceAccount: new Types.ObjectId(serviceAccountId),
         });
 
         await ServiceAccountWorkspacePermission.deleteMany({
-            serviceAccount: new Types.ObjectId(serviceAccountId)
+            serviceAccount: new Types.ObjectId(serviceAccountId),
         });
     }
 
     return res.status(200).send({
-        serviceAccount
+        serviceAccount,
     });
 }
 
@@ -297,10 +297,10 @@ export const getServiceAccountKeys = async (req: Request, res: Response) => {
     
     const serviceAccountKeys = await ServiceAccountKey.find({
         serviceAccount: req.serviceAccount._id,
-        ...(workspaceId ? { workspace: new Types.ObjectId(workspaceId) } : {})
+        ...(workspaceId ? { workspace: new Types.ObjectId(workspaceId) } : {}),
     });
     
     return res.status(200).send({
-        serviceAccountKeys
+        serviceAccountKeys,
     });
 }

backend/src/controllers/v2/serviceTokenDataController.ts

@@ -1,13 +1,10 @@
 import { Request, Response } from "express";
 import crypto from "crypto";
 import bcrypt from "bcrypt";
-import { User, ServiceAccount, ServiceTokenData } from "../../models";
-import { userHasWorkspaceAccess } from "../../ee/helpers/checkMembershipPermissions";
+import { ServiceAccount, ServiceTokenData, User } from "../../models";
 import {
-  PERMISSION_READ_SECRETS,
   AUTH_MODE_JWT,
   AUTH_MODE_SERVICE_ACCOUNT,
-  AUTH_MODE_SERVICE_TOKEN,
 } from "../../variables";
 import { getSaltRounds } from "../../config";
 import { BadRequestError } from "../../utils/errors";

backend/src/controllers/v2/signupController.ts

@@ -1,14 +1,14 @@
-import { Request, Response } from 'express';
-import { User, MembershipOrg } from '../../models';
-import { completeAccount } from '../../helpers/user';
+import { Request, Response } from "express";
+import { MembershipOrg, User } from "../../models";
+import { completeAccount } from "../../helpers/user";
 import {
-	initializeDefaultOrg
-} from '../../helpers/signup';
-import { issueAuthTokens } from '../../helpers/auth';
-import { INVITED, ACCEPTED } from '../../variables';
-import { standardRequest } from '../../config/request';
-import { getLoopsApiKey, getHttpsEnabled } from '../../config';
-import { updateSubscriptionOrgQuantity } from '../../helpers/organization';
+	initializeDefaultOrg,
+} from "../../helpers/signup";
+import { issueAuthTokens } from "../../helpers/auth";
+import { ACCEPTED, INVITED } from "../../variables";
+import { standardRequest } from "../../config/request";
+import { getHttpsEnabled, getLoopsApiKey } from "../../config";
+import { updateSubscriptionOrgQuantity } from "../../helpers/organization";
 
 /**
  * Complete setting up user by adding their personal and auth information as part of the
@@ -32,7 +32,7 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
     encryptedPrivateKeyTag,
     salt,
     verifier,
-    organizationName
+    organizationName,
   }: {
     email: string;
     firstName: string;
@@ -56,7 +56,7 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
     // case 1: user doesn't exist.
     // case 2: user has already completed account
     return res.status(403).send({
-      error: 'Failed to complete account for complete user'
+      error: "Failed to complete account for complete user",
     });
   }
 
@@ -74,28 +74,28 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
     encryptedPrivateKeyIV,
     encryptedPrivateKeyTag,
     salt,
-    verifier
+    verifier,
   });
 
   if (!user)
-    throw new Error('Failed to complete account for non-existent user'); // ensure user is non-null
+    throw new Error("Failed to complete account for non-existent user"); // ensure user is non-null
 
   // initialize default organization and workspace
   await initializeDefaultOrg({
     organizationName,
-    user
+    user,
   });
 
   // update organization membership statuses that are
   // invited to completed with user attached
   const membershipsToUpdate = await MembershipOrg.find({
     inviteEmail: email,
-    status: INVITED
+    status: INVITED,
   });
   
   membershipsToUpdate.forEach(async (membership) => {
     await updateSubscriptionOrgQuantity({
-      organizationId: membership.organization.toString()
+      organizationId: membership.organization.toString(),
     });
   });
 
@@ -104,11 +104,11 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
   await MembershipOrg.updateMany(
     {
       inviteEmail: email,
-      status: INVITED
+      status: INVITED,
     },
     {
       user,
-      status: ACCEPTED
+      status: ACCEPTED,
     }
   );
 
@@ -116,7 +116,7 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
   const tokens = await issueAuthTokens({
     userId: user._id,
     ip: req.realIP,
-    userAgent: req.headers['user-agent'] ?? ''
+    userAgent: req.headers["user-agent"] ?? "",
   });
 
   token = tokens.token;
@@ -127,27 +127,27 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
       "email": email,
       "eventName": "Sign Up",
       "firstName": firstName,
-      "lastName": lastName
+      "lastName": lastName,
     }, {
       headers: {
         "Accept": "application/json",
-        "Authorization": "Bearer " + (await getLoopsApiKey())
+        "Authorization": "Bearer " + (await getLoopsApiKey()),
       },
     });
   }
 
   // store (refresh) token in httpOnly cookie
-  res.cookie('jid', tokens.refreshToken, {
+  res.cookie("jid", tokens.refreshToken, {
     httpOnly: true,
-    path: '/',
-    sameSite: 'strict',
-    secure: await getHttpsEnabled()
+    path: "/",
+    sameSite: "strict",
+    secure: await getHttpsEnabled(),
   });
 
 	return res.status(200).send({
-		message: 'Successfully set up account',
+		message: "Successfully set up account",
 		user,
-		token
+		token,
 	});
 };
 
@@ -172,7 +172,7 @@ export const completeAccountInvite = async (req: Request, res: Response) => {
     encryptedPrivateKeyIV,
     encryptedPrivateKeyTag,
     salt,
-    verifier
+    verifier,
   } = req.body;
 
   // get user
@@ -182,16 +182,16 @@ export const completeAccountInvite = async (req: Request, res: Response) => {
     // case 1: user doesn't exist.
     // case 2: user has already completed account
     return res.status(403).send({
-      error: 'Failed to complete account for complete user'
+      error: "Failed to complete account for complete user",
     });
   }
 
   const membershipOrg = await MembershipOrg.findOne({
     inviteEmail: email,
-    status: INVITED
+    status: INVITED,
   });
 
-  if (!membershipOrg) throw new Error('Failed to find invitations for email');
+  if (!membershipOrg) throw new Error("Failed to find invitations for email");
 
   // complete setting up user's account
   user = await completeAccount({
@@ -207,33 +207,33 @@ export const completeAccountInvite = async (req: Request, res: Response) => {
     encryptedPrivateKeyIV,
     encryptedPrivateKeyTag,
     salt,
-    verifier
+    verifier,
   });
 
   if (!user)
-    throw new Error('Failed to complete account for non-existent user');
+    throw new Error("Failed to complete account for non-existent user");
   
   // update organization membership statuses that are
   // invited to completed with user attached
   const membershipsToUpdate = await MembershipOrg.find({
     inviteEmail: email,
-    status: INVITED
+    status: INVITED,
   });
   
   membershipsToUpdate.forEach(async (membership) => {
     await updateSubscriptionOrgQuantity({
-      organizationId: membership.organization.toString()
+      organizationId: membership.organization.toString(),
     });
   });
 
   await MembershipOrg.updateMany(
     {
       inviteEmail: email,
-      status: INVITED
+      status: INVITED,
     },
     {
       user,
-      status: ACCEPTED
+      status: ACCEPTED,
     }
   );
 
@@ -241,22 +241,22 @@ export const completeAccountInvite = async (req: Request, res: Response) => {
   const tokens = await issueAuthTokens({
     userId: user._id,
     ip: req.realIP,
-    userAgent: req.headers['user-agent'] ?? ''
+    userAgent: req.headers["user-agent"] ?? "",
   });
 
   token = tokens.token;
 
   // store (refresh) token in httpOnly cookie
-  res.cookie('jid', tokens.refreshToken, {
+  res.cookie("jid", tokens.refreshToken, {
     httpOnly: true,
-    path: '/',
-    sameSite: 'strict',
-    secure: await getHttpsEnabled()
+    path: "/",
+    sameSite: "strict",
+    secure: await getHttpsEnabled(),
   });
 
 	return res.status(200).send({
-		message: 'Successfully set up account',
+		message: "Successfully set up account",
 		user,
-		token
+		token,
 	});
 };

backend/src/controllers/v2/tagController.ts

@@ -1,71 +1,65 @@
-import { Request, Response } from 'express';
-import { Types } from 'mongoose';
-import {
-	Membership, Secret,
-} from '../../models';
-import Tag, { ITag } from '../../models/tag';
-import { Builder } from "builder-pattern"
-import to from 'await-to-js';
-import { BadRequestError, UnauthorizedRequestError } from '../../utils/errors';
-import { MongoError } from 'mongodb';
-import { userHasWorkspaceAccess } from '../../ee/helpers/checkMembershipPermissions';
+import { Request, Response } from "express";
+import { Types } from "mongoose";
+import { Membership, Secret } from "../../models";
+import Tag, { ITag } from "../../models/tag";
+import { Builder } from "builder-pattern";
+import to from "await-to-js";
+import { BadRequestError, UnauthorizedRequestError } from "../../utils/errors";
+import { MongoError } from "mongodb";
 
 export const createWorkspaceTag = async (req: Request, res: Response) => {
-	const { workspaceId } = req.params
-	const { name, slug } = req.body
-	const sanitizedTagToCreate = Builder<ITag>()
-		.name(name)
-		.workspace(new Types.ObjectId(workspaceId))
-		.slug(slug)
-		.user(new Types.ObjectId(req.user._id))
-		.build();
+  const { workspaceId } = req.params;
+  const { name, slug } = req.body;
+  const sanitizedTagToCreate = Builder<ITag>()
+    .name(name)
+    .workspace(new Types.ObjectId(workspaceId))
+    .slug(slug)
+    .user(new Types.ObjectId(req.user._id))
+    .build();
 
-	const [err, createdTag] = await to(Tag.create(sanitizedTagToCreate))
+  const [err, createdTag] = await to(Tag.create(sanitizedTagToCreate));
 
-	if (err) {
-		if ((err as MongoError).code === 11000) {
-			throw BadRequestError({ message: "Tags must be unique in a workspace" })
-		}
+  if (err) {
+    if ((err as MongoError).code === 11000) {
+      throw BadRequestError({ message: "Tags must be unique in a workspace" });
+    }
 
-		throw err
-	}
+    throw err;
+  }
 
-	res.json(createdTag)
-}
+  res.json(createdTag);
+};
 
 export const deleteWorkspaceTag = async (req: Request, res: Response) => {
-	const { tagId } = req.params
+  const { tagId } = req.params;
 
-	const tagFromDB = await Tag.findById(tagId)
-	if (!tagFromDB) {
-		throw BadRequestError()
-	}
+  const tagFromDB = await Tag.findById(tagId);
+  if (!tagFromDB) {
+    throw BadRequestError();
+  }
 
-	// can only delete if the request user is one that belongs to the same workspace as the tag
-	const membership = await Membership.findOne({
-		user: req.user,
-		workspace: tagFromDB.workspace
-	});
+  // can only delete if the request user is one that belongs to the same workspace as the tag
+  const membership = await Membership.findOne({
+    user: req.user,
+    workspace: tagFromDB.workspace
+  });
 
-	if (!membership) {
-		UnauthorizedRequestError({ message: 'Failed to validate membership' });
-	}
+  if (!membership) {
+    UnauthorizedRequestError({ message: "Failed to validate membership" });
+  }
 
-	const result = await Tag.findByIdAndDelete(tagId);
+  const result = await Tag.findByIdAndDelete(tagId);
 
-	// remove the tag from secrets
-	await Secret.updateMany(
-		{ tags: { $in: [tagId] } },
-		{ $pull: { tags: tagId } }
-	);
+  // remove the tag from secrets
+  await Secret.updateMany({ tags: { $in: [tagId] } }, { $pull: { tags: tagId } });
 
-	res.json(result);
-}
+  res.json(result);
+};
 
 export const getWorkspaceTags = async (req: Request, res: Response) => {
-	const { workspaceId } = req.params
-	const workspaceTags = await Tag.find({ workspace: workspaceId })
-	return res.json({
-		workspaceTags
-	})
-}
+  const { workspaceId } = req.params;
+  const workspaceTags = await Tag.find({ workspace: workspaceId });
+  return res.json({
+    workspaceTags
+  });
+};

backend/src/controllers/v2/usersController.ts

@@ -1,8 +1,8 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
 import {
+    MembershipOrg,
     User,
-    MembershipOrg
-} from '../../models';
+} from "../../models";
 
 /**
  * Return the current user.
@@ -38,10 +38,10 @@ export const getMe = async (req: Request, res: Response) => {
     */
     const user = await User
         .findById(req.user._id)
-        .select('+salt +publicKey +encryptedPrivateKey +iv +tag +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag');
+        .select("+salt +publicKey +encryptedPrivateKey +iv +tag +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag");
     
     return res.status(200).send({
-        user
+        user,
     });
 }
 
@@ -60,7 +60,7 @@ export const updateMyMfaEnabled = async (req: Request, res: Response) => {
     if (isMfaEnabled) { 
         // TODO: adapt this route/controller 
         // to work for different forms of MFA
-        req.user.mfaMethods = ['email'];
+        req.user.mfaMethods = ["email"];
     } else {
         req.user.mfaMethods = [];
     }
@@ -70,7 +70,7 @@ export const updateMyMfaEnabled = async (req: Request, res: Response) => {
     const user = req.user;
     
     return res.status(200).send({
-        user
+        user,
     });
 }
 
@@ -109,11 +109,11 @@ export const getMyOrganizations = async (req: Request, res: Response) => {
     */
   const organizations = (
     await MembershipOrg.find({
-      user: req.user._id
-    }).populate('organization')
+      user: req.user._id,
+    }).populate("organization")
   ).map((m) => m.organization);
 
 	return res.status(200).send({
-		organizations
+		organizations,
 	});
 }

backend/src/controllers/v2/workspaceController.ts

@@ -1,25 +1,19 @@
-import { Request, Response } from 'express';
-import { Types } from 'mongoose';
+import { Request, Response } from "express";
+import { Types } from "mongoose";
 import {
-	Workspace,
-	Secret,
-	Membership,
-	MembershipOrg,
-	Integration,
-	IntegrationAuth,
 	Key,
-	IUser,
-	ServiceToken,
-	ServiceTokenData
-} from '../../models';
+	Membership,
+	ServiceTokenData,
+	Workspace,
+} from "../../models";
 import {
-	v2PushSecrets as push,
 	pullSecrets as pull,
-	reformatPullSecrets
-} from '../../helpers/secret';
-import { pushKeys } from '../../helpers/key';
-import { TelemetryService, EventService } from '../../services';
-import { eventPushSecrets } from '../../events';
+	v2PushSecrets as push,
+	reformatPullSecrets,
+} from "../../helpers/secret";
+import { pushKeys } from "../../helpers/key";
+import { EventService, TelemetryService } from "../../services";
+import { eventPushSecrets } from "../../events";
 
 interface V2PushSecret {
 	type: string; // personal or shared
@@ -54,12 +48,12 @@ export const pushWorkspaceSecrets = async (req: Request, res: Response) => {
   // validate environment
   const workspaceEnvs = req.membership.workspace.environments;
   if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-    throw new Error('Failed to validate environment');
+    throw new Error("Failed to validate environment");
   }
 
   // sanitize secrets
   secrets = secrets.filter(
-    (s: V2PushSecret) => s.secretKeyCiphertext !== '' && s.secretValueCiphertext !== ''
+    (s: V2PushSecret) => s.secretKeyCiphertext !== "" && s.secretValueCiphertext !== ""
   );
 
   await push({
@@ -67,26 +61,26 @@ export const pushWorkspaceSecrets = async (req: Request, res: Response) => {
     workspaceId,
     environment,
     secrets,
-    channel: channel ? channel : 'cli',
-    ipAddress: req.realIP
+    channel: channel ? channel : "cli",
+    ipAddress: req.realIP,
   });
 
   await pushKeys({
     userId: req.user._id,
     workspaceId,
-    keys
+    keys,
   });
 
   if (postHogClient) {
     postHogClient.capture({
-      event: 'secrets pushed',
+      event: "secrets pushed",
       distinctId: req.user.email,
       properties: {
         numberOfSecrets: secrets.length,
         environment,
         workspaceId,
-        channel: channel ? channel : 'cli'
-      }
+        channel: channel ? channel : "cli",
+      },
     });
   }
 
@@ -94,12 +88,12 @@ export const pushWorkspaceSecrets = async (req: Request, res: Response) => {
   EventService.handleEvent({
     event: eventPushSecrets({
       workspaceId: new Types.ObjectId(workspaceId),
-      environment
-    })
+      environment,
+    }),
   });
 
 	return res.status(200).send({
-		message: 'Successfully uploaded workspace secrets'
+		message: "Successfully uploaded workspace secrets",
 	});
 };
 
@@ -126,18 +120,18 @@ export const pullSecrets = async (req: Request, res: Response) => {
   // validate environment
   const workspaceEnvs = req.membership.workspace.environments;
   if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-    throw new Error('Failed to validate environment');
+    throw new Error("Failed to validate environment");
   }
 
   secrets = await pull({
     userId,
     workspaceId,
     environment,
-    channel: channel ? channel : 'cli',
-    ipAddress: req.realIP
+    channel: channel ? channel : "cli",
+    ipAddress: req.realIP,
   });
 
-  if (channel !== 'cli') {
+  if (channel !== "cli") {
     secrets = reformatPullSecrets({ secrets });
   }
 
@@ -145,18 +139,18 @@ export const pullSecrets = async (req: Request, res: Response) => {
     // capture secrets pushed event in production
     postHogClient.capture({
       distinctId: req.user.email,
-      event: 'secrets pulled',
+      event: "secrets pulled",
       properties: {
         numberOfSecrets: secrets.length,
         environment,
         workspaceId,
-        channel: channel ? channel : 'cli'
-      }
+        channel: channel ? channel : "cli",
+      },
     });
   }
 
 	return res.status(200).send({
-		secrets
+		secrets,
 	});
 };
 
@@ -194,10 +188,10 @@ export const getWorkspaceKey = async (req: Request, res: Response) => {
 
   key = await Key.findOne({
     workspace: workspaceId,
-    receiver: req.user._id
-  }).populate('sender', '+publicKey');
+    receiver: req.user._id,
+  }).populate("sender", "+publicKey");
 
-  if (!key) throw new Error('Failed to find workspace key');
+  if (!key) throw new Error("Failed to find workspace key");
 
 	return res.status(200).json(key);
 }
@@ -209,12 +203,12 @@ export const getWorkspaceServiceTokenData = async (
 
   const serviceTokenData = await ServiceTokenData
     .find({
-      workspace: workspaceId
+      workspace: workspaceId,
     })
-    .select('+encryptedKey +iv +tag');
+    .select("+encryptedKey +iv +tag");
 
 	return res.status(200).send({
-		serviceTokenData
+		serviceTokenData,
 	});
 }
 
@@ -261,11 +255,11 @@ export const getWorkspaceMemberships = async (req: Request, res: Response) => {
   const { workspaceId } = req.params;
 
   const memberships = await Membership.find({
-    workspace: workspaceId
-  }).populate('user', '+publicKey');
+    workspace: workspaceId,
+  }).populate("user", "+publicKey");
 
 	return res.status(200).send({
-		memberships
+		memberships,
 	});
 }
 
@@ -330,21 +324,21 @@ export const updateWorkspaceMembership = async (req: Request, res: Response) =>
     }   
     */
   const {
-    membershipId
+    membershipId,
   } = req.params;
   const { role } = req.body;
   
   const membership = await Membership.findByIdAndUpdate(
     membershipId,
     {
-      role
+      role,
     }, {
-      new: true
+      new: true,
     }
   );
 
 	return res.status(200).send({
-		membership
+		membership,
 	}); 
 }
 
@@ -392,20 +386,20 @@ export const deleteWorkspaceMembership = async (req: Request, res: Response) =>
     }   
     */
   const { 
-    membershipId
+    membershipId,
   } = req.params;
   
   const membership = await Membership.findByIdAndDelete(membershipId);
   
-  if (!membership) throw new Error('Failed to delete workspace membership');
+  if (!membership) throw new Error("Failed to delete workspace membership");
   
   await Key.deleteMany({
     receiver: membership.user,
-    workspace: membership.workspace
+    workspace: membership.workspace,
   });
 	
 	return res.status(200).send({
-		membership
+		membership,
 	});
 }
 
@@ -421,18 +415,18 @@ export const toggleAutoCapitalization = async (req: Request, res: Response) => {
 
   const workspace = await Workspace.findOneAndUpdate(
     {
-      _id: workspaceId
+      _id: workspaceId,
     },
     {
-      autoCapitalization
+      autoCapitalization,
     },
     {
-      new: true
+      new: true,
     }
   );
 
 	return res.status(200).send({
-		message: 'Successfully changed autoCapitalization setting',
-		workspace
+		message: "Successfully changed autoCapitalization setting",
+		workspace,
 	});
 };

backend/src/controllers/v3/authController.ts

@@ -1,29 +1,29 @@
 /* eslint-disable @typescript-eslint/no-var-requires */
-import { Request, Response } from 'express';
-import jwt from 'jsonwebtoken';
-import * as Sentry from '@sentry/node';
-import * as bigintConversion from 'bigint-conversion';
-const jsrp = require('jsrp');
-import { User, LoginSRPDetail } from '../../models';
-import { issueAuthTokens, createToken, validateProviderAuthToken } from '../../helpers/auth';
-import { checkUserDevice } from '../../helpers/user';
-import { sendMail } from '../../helpers/nodemailer';
-import { TokenService } from '../../services';
-import { EELogService } from '../../ee/services';
-import { BadRequestError, InternalServerError } from '../../utils/errors';
+import { Request, Response } from "express";
+import jwt from "jsonwebtoken";
+import * as Sentry from "@sentry/node";
+import * as bigintConversion from "bigint-conversion";
+const jsrp = require("jsrp");
+import { LoginSRPDetail, User } from "../../models";
+import { createToken, issueAuthTokens, validateProviderAuthToken } from "../../helpers/auth";
+import { checkUserDevice } from "../../helpers/user";
+import { sendMail } from "../../helpers/nodemailer";
+import { TokenService } from "../../services";
+import { EELogService } from "../../ee/services";
+import { BadRequestError, InternalServerError } from "../../utils/errors";
 import {
+    ACTION_LOGIN,
     TOKEN_EMAIL_MFA,
-    ACTION_LOGIN
-} from '../../variables';
-import { getChannelFromUserAgent } from '../../utils/posthog'; // TODO: move this
+} from "../../variables";
+import { getChannelFromUserAgent } from "../../utils/posthog"; // TODO: move this
 import {
+    getHttpsEnabled,
     getJwtMfaLifetime,
     getJwtMfaSecret,
-    getHttpsEnabled,
-} from '../../config';
-import { AuthProvider } from '../../models/user';
+} from "../../config";
+import { AuthProvider } from "../../models/user";
 
-declare module 'jsonwebtoken' {
+declare module "jsonwebtoken" {
     export interface ProviderAuthJwtPayload extends jwt.JwtPayload {
         userId: string;
         email: string;
@@ -43,7 +43,7 @@ export const login1 = async (req: Request, res: Response) => {
         const {
             email,
             providerAuthToken,
-            clientPublicKey
+            clientPublicKey,
         }: {
             email: string;
             clientPublicKey: string,
@@ -52,9 +52,9 @@ export const login1 = async (req: Request, res: Response) => {
 
         const user = await User.findOne({
             email,
-        }).select('+salt +verifier');
+        }).select("+salt +verifier");
 
-        if (!user) throw new Error('Failed to find user');
+        if (!user) throw new Error("Failed to find user");
 
         if (user.authProvider) {
             await validateProviderAuthToken({
@@ -68,13 +68,13 @@ export const login1 = async (req: Request, res: Response) => {
         server.init(
             {
                 salt: user.salt,
-                verifier: user.verifier
+                verifier: user.verifier,
             },
             async () => {
                 // generate server-side public key
                 const serverPublicKey = server.getPublicKey();
                 await LoginSRPDetail.findOneAndReplace({
-                    email: email
+                    email: email,
                 }, {
                     email,
                     userId: user.id,
@@ -84,7 +84,7 @@ export const login1 = async (req: Request, res: Response) => {
 
                 return res.status(200).send({
                     serverPublicKey,
-                    salt: user.salt
+                    salt: user.salt,
                 });
             }
         );
@@ -92,7 +92,7 @@ export const login1 = async (req: Request, res: Response) => {
         Sentry.setUser(null);
         Sentry.captureException(err);
         return res.status(400).send({
-            message: 'Failed to start authentication process'
+            message: "Failed to start authentication process",
         });
     }
 };
@@ -107,15 +107,15 @@ export const login1 = async (req: Request, res: Response) => {
 export const login2 = async (req: Request, res: Response) => {
     try {
 
-        if (!req.headers['user-agent']) throw InternalServerError({ message: 'User-Agent header is required' });
+        if (!req.headers["user-agent"]) throw InternalServerError({ message: "User-Agent header is required" });
 
         const { email, clientProof, providerAuthToken } = req.body;
 
         const user = await User.findOne({
             email,
-        }).select('+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag +devices');
+        }).select("+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag +devices");
 
-        if (!user) throw new Error('Failed to find user');
+        if (!user) throw new Error("Failed to find user");
 
         if (user.authProvider) {
             await validateProviderAuthToken({
@@ -136,7 +136,7 @@ export const login2 = async (req: Request, res: Response) => {
             {
                 salt: user.salt,
                 verifier: user.verifier,
-                b: loginSRPDetail.serverBInt
+                b: loginSRPDetail.serverBInt,
             },
             async () => {
                 server.setClientPublicKey(loginSRPDetail.clientPublicKey);
@@ -150,52 +150,52 @@ export const login2 = async (req: Request, res: Response) => {
                         // generate temporary MFA token
                         const token = createToken({
                             payload: {
-                                userId: user._id.toString()
+                                userId: user._id.toString(),
                             },
                             expiresIn: await getJwtMfaLifetime(),
-                            secret: await getJwtMfaSecret()
+                            secret: await getJwtMfaSecret(),
                         });
 
                         const code = await TokenService.createToken({
                             type: TOKEN_EMAIL_MFA,
-                            email
+                            email,
                         });
 
                         // send MFA code [code] to [email]
                         await sendMail({
-                            template: 'emailMfa.handlebars',
-                            subjectLine: 'Infisical MFA code',
+                            template: "emailMfa.handlebars",
+                            subjectLine: "Infisical MFA code",
                             recipients: [user.email],
                             substitutions: {
-                                code
-                            }
+                                code,
+                            },
                         });
 
                         return res.status(200).send({
                             mfaEnabled: true,
-                            token
+                            token,
                         });
                     }
 
                     await checkUserDevice({
                         user,
                         ip: req.realIP,
-                        userAgent: req.headers['user-agent'] ?? ''
+                        userAgent: req.headers["user-agent"] ?? "",
                     });
 
                     // issue tokens
                     const tokens = await issueAuthTokens({ 
                         userId: user._id,
                         ip: req.realIP,
-                        userAgent: req.headers['user-agent'] ?? ''
+                        userAgent: req.headers["user-agent"] ?? "",
                     });
 
                     // store (refresh) token in httpOnly cookie
-                    res.cookie('jid', tokens.refreshToken, {
+                    res.cookie("jid", tokens.refreshToken, {
                         httpOnly: true,
-                        path: '/',
-                        sameSite: 'strict',
-                        secure: await getHttpsEnabled()
+                        path: "/",
+                        sameSite: "strict",
+                        secure: await getHttpsEnabled(),
                     });
 
                     // case: user does not have MFA enablgged
@@ -221,7 +221,7 @@ export const login2 = async (req: Request, res: Response) => {
                         publicKey: user.publicKey,
                         encryptedPrivateKey: user.encryptedPrivateKey,
                         iv: user.iv,
-                        tag: user.tag
+                        tag: user.tag,
                     }
 
                     if (
@@ -236,21 +236,21 @@ export const login2 = async (req: Request, res: Response) => {
 
                     const loginAction = await EELogService.createAction({
                         name: ACTION_LOGIN,
-                        userId: user._id
+                        userId: user._id,
                     });
 
                     loginAction && await EELogService.createLog({
                         userId: user._id,
                         actions: [loginAction],
-                        channel: getChannelFromUserAgent(req.headers['user-agent']),
-                        ipAddress: req.realIP
+                        channel: getChannelFromUserAgent(req.headers["user-agent"]),
+                        ipAddress: req.realIP,
                     });
 
                     return res.status(200).send(response);
                 }
 
                 return res.status(400).send({
-                    message: 'Failed to authenticate. Try again?'
+                    message: "Failed to authenticate. Try again?",
                 });
             }
         );
@@ -258,7 +258,7 @@ export const login2 = async (req: Request, res: Response) => {
         Sentry.setUser(null);
         Sentry.captureException(err);
         return res.status(400).send({
-            message: 'Failed to authenticate. Try again?'
+            message: "Failed to authenticate. Try again?",
         });
     }
 };

backend/src/controllers/v3/index.ts

@@ -1,7 +1,7 @@
-import * as secretsController from './secretsController';
-import * as workspacesController from './workspacesController';
-import * as authController from './authController';
-import * as signupController from './signupController';
+import * as secretsController from "./secretsController";
+import * as workspacesController from "./workspacesController";
+import * as authController from "./authController";
+import * as signupController from "./signupController";
 
 export {
     authController,

backend/src/controllers/v3/secretsController.ts

@@ -1,6 +1,6 @@
 import { Request, Response } from "express";
 import { Types } from "mongoose";
-import { SecretService, EventService } from "../../services";
+import { EventService, SecretService } from "../../services";
 import { eventPushSecrets } from "../../events";
 import { BotService } from "../../services";
 import { repackageSecretToRaw } from "../../helpers/secrets";
@@ -25,18 +25,18 @@ export const getSecretsRaw = async (req: Request, res: Response) => {
   });
 
   const key = await BotService.getWorkspaceKeyWithBot({
-    workspaceId: new Types.ObjectId(workspaceId)
+    workspaceId: new Types.ObjectId(workspaceId),
   });
 
   return res.status(200).send({
     secrets: secrets.map((secret) => {
       const rep = repackageSecretToRaw({
         secret,
-        key
+        key,
       });
 
       return rep;
-    })
+    }),
   });
 };
 
@@ -62,14 +62,14 @@ export const getSecretByNameRaw = async (req: Request, res: Response) => {
   });
 
   const key = await BotService.getWorkspaceKeyWithBot({
-    workspaceId: new Types.ObjectId(workspaceId)
+    workspaceId: new Types.ObjectId(workspaceId),
   });
 
   return res.status(200).send({
     secret: repackageSecretToRaw({
       secret,
-      key
-    })
+      key,
+    }),
   });
 };
 
@@ -86,26 +86,26 @@ export const createSecretRaw = async (req: Request, res: Response) => {
     type,
     secretValue,
     secretComment,
-    secretPath = "/"
+    secretPath = "/",
   } = req.body;
 
   const key = await BotService.getWorkspaceKeyWithBot({
-    workspaceId: new Types.ObjectId(workspaceId)
+    workspaceId: new Types.ObjectId(workspaceId),
   });
 
   const secretKeyEncrypted = encryptSymmetric128BitHexKeyUTF8({
     plaintext: secretName,
-    key
+    key,
   });
 
   const secretValueEncrypted = encryptSymmetric128BitHexKeyUTF8({
     plaintext: secretValue,
-    key
+    key,
   });
 
   const secretCommentEncrypted = encryptSymmetric128BitHexKeyUTF8({
     plaintext: secretComment,
-    key
+    key,
   });
 
   const secret = await SecretService.createSecret({
@@ -123,7 +123,7 @@ export const createSecretRaw = async (req: Request, res: Response) => {
     secretPath,
     secretCommentCiphertext: secretCommentEncrypted.ciphertext,
     secretCommentIV: secretCommentEncrypted.iv,
-    secretCommentTag: secretCommentEncrypted.tag
+    secretCommentTag: secretCommentEncrypted.tag,
   });
 
   await EventService.handleEvent({
@@ -139,8 +139,8 @@ export const createSecretRaw = async (req: Request, res: Response) => {
   return res.status(200).send({
     secret: repackageSecretToRaw({
       secret: secretWithoutBlindIndex,
-      key
-    })
+      key,
+    }),
   });
 }
 
@@ -160,12 +160,12 @@ export const updateSecretByNameRaw = async (req: Request, res: Response) => {
   } = req.body;
 
   const key = await BotService.getWorkspaceKeyWithBot({
-    workspaceId: new Types.ObjectId(workspaceId)
+    workspaceId: new Types.ObjectId(workspaceId),
   });
 
   const secretValueEncrypted = encryptSymmetric128BitHexKeyUTF8({
     plaintext: secretValue,
-    key
+    key,
   });
 
   const secret = await SecretService.updateSecret({
@@ -190,8 +190,8 @@ export const updateSecretByNameRaw = async (req: Request, res: Response) => {
   return res.status(200).send({
     secret: repackageSecretToRaw({
       secret,
-      key
-    })
+      key,
+    }),
   });
 };
 
@@ -206,7 +206,7 @@ export const deleteSecretByNameRaw = async (req: Request, res: Response) => {
     workspaceId,
     environment,
     type,
-    secretPath = "/"
+    secretPath = "/",
   } = req.body;
 
   const { secret } = await SecretService.deleteSecret({
@@ -226,14 +226,14 @@ export const deleteSecretByNameRaw = async (req: Request, res: Response) => {
   });
 
   const key = await BotService.getWorkspaceKeyWithBot({
-    workspaceId: new Types.ObjectId(workspaceId)
+    workspaceId: new Types.ObjectId(workspaceId),
   });
 
   return res.status(200).send({
     secret: repackageSecretToRaw({
       secret,
-      key
-    })
+      key,
+    }),
   });
 };
 
@@ -324,7 +324,7 @@ export const createSecret = async (req: Request, res: Response) => {
     secretPath,
     secretCommentCiphertext,
     secretCommentIV,
-    secretCommentTag
+    secretCommentTag,
   });
 
   await EventService.handleEvent({
@@ -395,7 +395,7 @@ export const deleteSecretByName = async (req: Request, res: Response) => {
     workspaceId,
     environment,
     type,
-    secretPath = "/"
+    secretPath = "/",
   } = req.body;
 
   const { secret } = await SecretService.deleteSecret({

backend/src/controllers/v3/signupController.ts

@@ -1,17 +1,17 @@
-import jwt from 'jsonwebtoken';
-import { Request, Response } from 'express';
-import * as Sentry from '@sentry/node';
-import { User, MembershipOrg } from '../../models';
-import { completeAccount } from '../../helpers/user';
+import jwt from "jsonwebtoken";
+import { Request, Response } from "express";
+import * as Sentry from "@sentry/node";
+import { MembershipOrg, User } from "../../models";
+import { completeAccount } from "../../helpers/user";
 import {
-	initializeDefaultOrg
-} from '../../helpers/signup';
-import { issueAuthTokens, validateProviderAuthToken } from '../../helpers/auth';
-import { INVITED, ACCEPTED } from '../../variables';
-import { standardRequest } from '../../config/request';
-import { getLoopsApiKey, getHttpsEnabled, getJwtSignupSecret } from '../../config';
-import { BadRequestError } from '../../utils/errors';
-import { TelemetryService } from '../../services';
+	initializeDefaultOrg,
+} from "../../helpers/signup";
+import { issueAuthTokens, validateProviderAuthToken } from "../../helpers/auth";
+import { ACCEPTED, INVITED } from "../../variables";
+import { standardRequest } from "../../config/request";
+import { getHttpsEnabled, getJwtSignupSecret, getLoopsApiKey } from "../../config";
+import { BadRequestError } from "../../utils/errors";
+import { TelemetryService } from "../../services";
 
 /**
  * Complete setting up user by adding their personal and auth information as part of the
@@ -63,7 +63,7 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
 			// case 1: user doesn't exist.
 			// case 2: user has already completed account
 			return res.status(403).send({
-				error: 'Failed to complete account for complete user'
+				error: "Failed to complete account for complete user",
 			});
 		}
 
@@ -74,16 +74,16 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
 				user,
 			});
 		} else {
-			const [AUTH_TOKEN_TYPE, AUTH_TOKEN_VALUE] = <[string, string]>req.headers['authorization']?.split(' ', 2) ?? [null, null]
+			const [AUTH_TOKEN_TYPE, AUTH_TOKEN_VALUE] = <[string, string]>req.headers["authorization"]?.split(" ", 2) ?? [null, null]
 			if (AUTH_TOKEN_TYPE === null) {
-				throw BadRequestError({ message: `Missing Authorization Header in the request header.` });
+				throw BadRequestError({ message: "Missing Authorization Header in the request header." });
 			}
-			if (AUTH_TOKEN_TYPE.toLowerCase() !== 'bearer') {
+			if (AUTH_TOKEN_TYPE.toLowerCase() !== "bearer") {
 				throw BadRequestError({ message: `The provided authentication type '${AUTH_TOKEN_TYPE}' is not supported.` })
 			}
 			if (AUTH_TOKEN_VALUE === null) {
 				throw BadRequestError({
-					message: 'Missing Authorization Body in the request header',
+					message: "Missing Authorization Body in the request header",
 				})
 			}
 
@@ -110,16 +110,16 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
 			encryptedPrivateKeyIV,
 			encryptedPrivateKeyTag,
 			salt,
-			verifier
+			verifier,
 		});
 
 		if (!user)
-			throw new Error('Failed to complete account for non-existent user'); // ensure user is non-null
+			throw new Error("Failed to complete account for non-existent user"); // ensure user is non-null
 
 		// initialize default organization and workspace
 		await initializeDefaultOrg({
 			organizationName,
-			user
+			user,
 		});
 
 		// update organization membership statuses that are
@@ -127,11 +127,11 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
 		await MembershipOrg.updateMany(
 			{
 				inviteEmail: email,
-				status: INVITED
+				status: INVITED,
 			},
 			{
 				user,
-				status: ACCEPTED
+				status: ACCEPTED,
 			}
 		);
 
@@ -139,7 +139,7 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
 		const tokens = await issueAuthTokens({
 			userId: user._id,
 			ip: req.realIP,
-			userAgent: req.headers['user-agent'] ?? ''
+			userAgent: req.headers["user-agent"] ?? "",
 		});
 
 		token = tokens.token;
@@ -150,45 +150,45 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
 				"email": email,
 				"eventName": "Sign Up",
 				"firstName": firstName,
-				"lastName": lastName
+				"lastName": lastName,
 			}, {
 				headers: {
 					"Accept": "application/json",
-					"Authorization": "Bearer " + (await getLoopsApiKey())
+					"Authorization": "Bearer " + (await getLoopsApiKey()),
 				},
 			});
 		}
 
 		// store (refresh) token in httpOnly cookie
-		res.cookie('jid', tokens.refreshToken, {
+		res.cookie("jid", tokens.refreshToken, {
 			httpOnly: true,
-			path: '/',
-			sameSite: 'strict',
-			secure: await getHttpsEnabled()
+			path: "/",
+			sameSite: "strict",
+			secure: await getHttpsEnabled(),
 		});
 
 		const postHogClient = await TelemetryService.getPostHogClient();
 		if (postHogClient) {
 			postHogClient.capture({
-				event: 'User Signed Up',
+				event: "User Signed Up",
 				distinctId: email,
 				properties: {
 					email,
-					attributionSource
-				}
+					attributionSource,
+				},
 			});
 		}
 	} catch (err) {
 		Sentry.setUser(null);
 		Sentry.captureException(err);
 		return res.status(400).send({
-			message: 'Failed to complete account setup'
+			message: "Failed to complete account setup",
 		});
 	}
 
 	return res.status(200).send({
-		message: 'Successfully set up account',
+		message: "Successfully set up account",
 		user,
-		token
+		token,
 	});
 };

backend/src/controllers/v3/workspacesController.ts

@@ -1,7 +1,7 @@
-import { Request, Response } from 'express';
-import { Types } from 'mongoose';
-import { Secret } from '../../models';
-import { SecretService } from'../../services';
+import { Request, Response } from "express";
+import { Types } from "mongoose";
+import { Secret } from "../../models";
+import { SecretService } from"../../services";
 
 /**
  * Return whether or not all secrets in workspace with id [workspaceId]
@@ -16,8 +16,8 @@ export const getWorkspaceBlindIndexStatus = async (req: Request, res: Response)
     const secretsWithoutBlindIndex = await Secret.countDocuments({
         workspace: new Types.ObjectId(workspaceId),
         secretBlindIndex: {
-            $exists: false
-        }
+            $exists: false,
+        },
     });
 
     return res.status(200).send(secretsWithoutBlindIndex === 0);
@@ -30,11 +30,11 @@ export const getWorkspaceSecrets = async (req: Request, res: Response) => {
     const { workspaceId } = req.params;
 
     const secrets = await Secret.find({
-        workspace: new Types.ObjectId (workspaceId)
+        workspace: new Types.ObjectId (workspaceId),
     });
     
     return res.status(200).send({
-        secrets
+        secrets,
     });
 }
 
@@ -51,14 +51,14 @@ export const nameWorkspaceSecrets = async (req: Request, res: Response) => {
 
     const { workspaceId } = req.params;
     const { 
-        secretsToUpdate 
+        secretsToUpdate, 
     }: {
         secretsToUpdate: SecretToUpdate[];
     } = req.body;
 
     // get secret blind index salt
     const salt = await SecretService.getSecretBlindIndexSalt({
-        workspaceId: new Types.ObjectId(workspaceId)
+        workspaceId: new Types.ObjectId(workspaceId),
     });
 
     // update secret blind indices
@@ -66,18 +66,18 @@ export const nameWorkspaceSecrets = async (req: Request, res: Response) => {
         secretsToUpdate.map(async (secretToUpdate: SecretToUpdate) => {
             const secretBlindIndex = await SecretService.generateSecretBlindIndexWithSalt({
                 secretName: secretToUpdate.secretName,
-                salt
+                salt,
             });
     
             return ({
                 updateOne: {
                     filter: {
-                        _id: new Types.ObjectId(secretToUpdate._id)
+                        _id: new Types.ObjectId(secretToUpdate._id),
                     },
                     update: {
-                        secretBlindIndex
-                    }
-                }
+                        secretBlindIndex,
+                    },
+                },
             });
         })
     );
@@ -85,6 +85,6 @@ export const nameWorkspaceSecrets = async (req: Request, res: Response) => {
     await Secret.bulkWrite(operations);
 
     return res.status(200).send({
-        message: 'Successfully named workspace secrets'
+        message: "Successfully named workspace secrets",
     });
 }