fix: frontend/package.json to reduce vulnerabilities

The following vulnerabilities are fixed with an upgrade:
- https://snyk.io/vuln/SNYK-JS-NEXT-6032387

.goreleaser.yaml

@@ -108,7 +108,7 @@ brews:
       zsh_completion.install "completions/infisical.zsh" => "_infisical"
       fish_completion.install "completions/infisical.fish"
       man1.install "manpages/infisical.1.gz"
-  - name: "infisical@{{.Version}}"
+  - name: 'infisical@{{.Version}}'
     tap:
       owner: Infisical
       name: homebrew-get-cli
@@ -186,14 +186,12 @@ aurs:
       # man pages
       install -Dm644 "./manpages/infisical.1.gz" "${pkgdir}/usr/share/man/man1/infisical.1.gz"
 
-dockers:
-  - dockerfile: docker/alpine
-    goos: linux
-    goarch: amd64
-    ids:
-      - all-other-builds
-    image_templates:
-      - "infisical/cli:{{ .Version }}"
-      - "infisical/cli:{{ .Major }}.{{ .Minor }}"
-      - "infisical/cli:{{ .Major }}"
-      - "infisical/cli:latest"
+# dockers:
+#   - dockerfile: cli/docker/Dockerfile
+#     goos: linux
+#     goarch: amd64
+#     ids:
+#       - infisical
+#     image_templates:
+#       - "infisical/cli:{{ .Version }}"
+#       - "infisical/cli:latest"

README.md

@@ -129,7 +129,7 @@ Note that this security address should be used only for undisclosed vulnerabilit
 
 ## Contributing
 
-Whether it's big or small, we love contributions. Check out our guide to see how to [get started](https://infisical.com/docs/contributing/getting-started).
+Whether it's big or small, we love contributions. Check out our guide to see how to [get started](https://infisical.com/docs/contributing/overview).
 
 Not sure where to get started? You can:
 

backend/package.json

@@ -6,22 +6,20 @@
     "@godaddy/terminus": "^4.12.0",
     "@node-saml/passport-saml": "^4.0.4",
     "@octokit/rest": "^19.0.5",
-    "@sentry/node": "^7.77.0",
+    "@sentry/node": "^7.49.0",
     "@sentry/tracing": "^7.48.0",
-    "@serdnam/pino-cloudwatch-transport": "^1.0.4",
     "@types/crypto-js": "^4.1.1",
     "@types/libsodium-wrappers": "^0.7.10",
     "@ucast/mongo2js": "^1.3.4",
-    "ajv": "^8.12.0",
     "argon2": "^0.30.3",
     "aws-sdk": "^2.1364.0",
-    "axios": "^1.6.0",
+    "axios": "^1.3.5",
     "axios-retry": "^3.4.0",
     "bcrypt": "^5.1.0",
     "bigint-conversion": "^2.4.0",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",
-    "crypto-js": "^4.2.0",
+    "crypto-js": "^4.1.1",
     "dotenv": "^16.0.1",
     "express": "^4.18.1",
     "express-async-errors": "^3.1.1",
@@ -31,27 +29,22 @@
     "helmet": "^5.1.1",
     "infisical-node": "^1.2.1",
     "ioredis": "^5.3.2",
-    "jmespath": "^0.16.0",
     "js-yaml": "^4.1.0",
     "jsonwebtoken": "^9.0.0",
     "jsrp": "^0.2.4",
     "libsodium-wrappers": "^0.7.10",
     "lodash": "^4.17.21",
+    "mongodb": "^5.7.0",
     "mongoose": "^7.4.1",
-    "mysql2": "^3.6.2",
     "nanoid": "^3.3.6",
     "node-cache": "^5.1.2",
     "nodemailer": "^6.8.0",
-    "ora": "^5.4.1",
     "passport": "^0.6.0",
     "passport-github": "^1.1.0",
     "passport-gitlab2": "^5.0.0",
     "passport-google-oauth20": "^2.0.0",
-    "pg": "^8.11.3",
-    "pino": "^8.16.1",
-    "pino-http": "^8.5.1",
     "posthog-node": "^2.6.0",
-    "probot": "^12.3.3",
+    "probot": "^12.3.1",
     "query-string": "^7.1.3",
     "rate-limit-mongo": "^2.3.2",
     "rimraf": "^3.0.2",
@@ -60,19 +53,16 @@
     "tweetnacl-util": "^0.15.1",
     "typescript": "^4.9.3",
     "utility-types": "^3.10.0",
+    "winston": "^3.8.2",
+    "winston-loki": "^6.0.6",
     "zod": "^3.22.3"
   },
-  "overrides": {
-    "rate-limit-mongo": {
-      "mongodb": "5.8.0"
-    }
-  },
   "name": "infisical-api",
   "version": "1.0.0",
   "main": "src/index.js",
   "scripts": {
     "start": "node build/index.js",
-    "dev": "nodemon index.js",
+    "dev": "nodemon",
     "swagger-autogen": "node ./swagger/index.ts",
     "build": "rimraf ./build && tsc && cp -R ./src/templates ./build && cp -R ./src/data ./build",
     "lint": "eslint . --ext .ts",
@@ -97,8 +87,6 @@
   "devDependencies": {
     "@jest/globals": "^29.3.1",
     "@posthog/plugin-scaffold": "^1.3.4",
-    "@swc/core": "^1.3.99",
-    "@swc/helpers": "^0.5.3",
     "@types/bcrypt": "^5.0.0",
     "@types/bcryptjs": "^2.4.2",
     "@types/bull": "^4.10.0",
@@ -106,15 +94,12 @@
     "@types/cors": "^2.8.12",
     "@types/express": "^4.17.14",
     "@types/jest": "^29.5.0",
-    "@types/jmespath": "^0.15.1",
     "@types/jsonwebtoken": "^8.5.9",
     "@types/lodash": "^4.14.191",
     "@types/node": "^18.11.3",
     "@types/nodemailer": "^6.4.6",
     "@types/passport": "^1.0.12",
-    "@types/pg": "^8.10.7",
     "@types/picomatch": "^2.3.0",
-    "@types/pino": "^7.0.5",
     "@types/supertest": "^2.0.12",
     "@types/swagger-jsdoc": "^6.0.1",
     "@types/swagger-ui-express": "^4.1.3",
@@ -128,8 +113,6 @@
     "jest-junit": "^15.0.0",
     "nodemon": "^2.0.19",
     "npm": "^8.19.3",
-    "pino-pretty": "^10.2.3",
-    "regenerator-runtime": "^0.14.0",
     "smee-client": "^1.2.3",
     "supertest": "^6.3.3",
     "swagger-autogen": "^2.23.5",

backend/src/bootstrap.ts

@@ -1,43 +0,0 @@
-import ora from "ora";
-import nodemailer from "nodemailer";
-import { getSmtpHost, getSmtpPort } from "./config";
-import { logger } from "./utils/logging";
-import mongoose from "mongoose";
-import { redisClient } from "./services/RedisService";
-
-type BootstrapOpt = {
-  transporter: nodemailer.Transporter;
-};
-
-export const bootstrap = async ({ transporter }: BootstrapOpt) => {
-  const spinner = ora().start();
-  spinner.info("Checking configurations...");
-  spinner.info("Testing smtp connection");
-
-  await transporter
-    .verify()
-    .then(async () => {
-      spinner.succeed("SMTP successfully connected");
-    })
-    .catch(async (err) => {
-      spinner.fail(`SMTP - Failed to connect to ${await getSmtpHost()}:${await getSmtpPort()}`);
-      logger.error(err);
-    });
-
-  spinner.info("Testing mongodb connection");
-  if (mongoose.connection.readyState !== mongoose.ConnectionStates.connected) {
-    spinner.fail("Mongo DB - Failed to connect");
-  } else {
-    spinner.succeed("Mongodb successfully connected");
-  }
-
-  spinner.info("Testing redis connection");
-  const redisPing = await redisClient?.ping();
-  if (!redisPing) {
-    spinner.fail("Redis - Failed to connect");
-  } else {
-    spinner.succeed("Redis successfully connected");
-  }
-
-  spinner.stop();
-};

backend/src/config/index.ts

@@ -3,171 +3,100 @@ import { GITLAB_URL } from "../variables";
 import InfisicalClient from "infisical-node";
 
 export const client = new InfisicalClient({
-  token: process.env.INFISICAL_TOKEN!
+  token: process.env.INFISICAL_TOKEN!,
 });
 
 export const getPort = async () => (await client.getSecret("PORT")).secretValue || 4000;
 export const getEncryptionKey = async () => {
   const secretValue = (await client.getSecret("ENCRYPTION_KEY")).secretValue;
   return secretValue === "" ? undefined : secretValue;
-};
+}
 export const getRootEncryptionKey = async () => {
   const secretValue = (await client.getSecret("ROOT_ENCRYPTION_KEY")).secretValue;
   return secretValue === "" ? undefined : secretValue;
-};
-export const getInviteOnlySignup = async () =>
-  (await client.getSecret("INVITE_ONLY_SIGNUP")).secretValue === "true";
-export const getSaltRounds = async () =>
-  parseInt((await client.getSecret("SALT_ROUNDS")).secretValue) || 10;
-export const getAuthSecret = async () =>
-  (await client.getSecret("JWT_AUTH_SECRET")).secretValue ??
-  (await client.getSecret("AUTH_SECRET")).secretValue;
-export const getJwtAuthLifetime = async () =>
-  (await client.getSecret("JWT_AUTH_LIFETIME")).secretValue || "10d";
-export const getJwtMfaLifetime = async () =>
-  (await client.getSecret("JWT_MFA_LIFETIME")).secretValue || "5m";
-export const getJwtRefreshLifetime = async () =>
-  (await client.getSecret("JWT_REFRESH_LIFETIME")).secretValue || "90d";
-export const getJwtServiceSecret = async () =>
-  (await client.getSecret("JWT_SERVICE_SECRET")).secretValue; // TODO: deprecate (related to ST V1)
-export const getJwtSignupLifetime = async () =>
-  (await client.getSecret("JWT_SIGNUP_LIFETIME")).secretValue || "15m";
-export const getJwtProviderAuthLifetime = async () =>
-  (await client.getSecret("JWT_PROVIDER_AUTH_LIFETIME")).secretValue || "15m";
+}
+export const getInviteOnlySignup = async () => (await client.getSecret("INVITE_ONLY_SIGNUP")).secretValue === "true"
+export const getSaltRounds = async () => parseInt((await client.getSecret("SALT_ROUNDS")).secretValue) || 10;
+export const getAuthSecret = async () => (await client.getSecret("JWT_AUTH_SECRET")).secretValue ?? (await client.getSecret("AUTH_SECRET")).secretValue;
+export const getJwtAuthLifetime = async () => (await client.getSecret("JWT_AUTH_LIFETIME")).secretValue || "10d";
+export const getJwtMfaLifetime = async () => (await client.getSecret("JWT_MFA_LIFETIME")).secretValue || "5m";
+export const getJwtRefreshLifetime = async () => (await client.getSecret("JWT_REFRESH_LIFETIME")).secretValue || "90d";
+export const getJwtServiceSecret = async () => (await client.getSecret("JWT_SERVICE_SECRET")).secretValue; // TODO: deprecate (related to ST V1)
+export const getJwtSignupLifetime = async () => (await client.getSecret("JWT_SIGNUP_LIFETIME")).secretValue || "15m";
+export const getJwtProviderAuthLifetime = async () => (await client.getSecret("JWT_PROVIDER_AUTH_LIFETIME")).secretValue || "15m";
+export const getJwtServiceTokenSecret = async () => (await client.getSecret("JWT_SERVICE_TOKEN_SECRET")).secretValue;
 export const getMongoURL = async () => (await client.getSecret("MONGO_URL")).secretValue;
-export const getNodeEnv = async () =>
-  (await client.getSecret("NODE_ENV")).secretValue || "production";
-export const getVerboseErrorOutput = async () =>
-  (await client.getSecret("VERBOSE_ERROR_OUTPUT")).secretValue === "true" && true;
+export const getNodeEnv = async () => (await client.getSecret("NODE_ENV")).secretValue || "production";
+export const getVerboseErrorOutput = async () => (await client.getSecret("VERBOSE_ERROR_OUTPUT")).secretValue === "true" && true;
 export const getLokiHost = async () => (await client.getSecret("LOKI_HOST")).secretValue;
 export const getClientIdAzure = async () => (await client.getSecret("CLIENT_ID_AZURE")).secretValue;
-export const getClientIdHeroku = async () =>
-  (await client.getSecret("CLIENT_ID_HEROKU")).secretValue;
-export const getClientIdVercel = async () =>
-  (await client.getSecret("CLIENT_ID_VERCEL")).secretValue;
-export const getClientIdNetlify = async () =>
-  (await client.getSecret("CLIENT_ID_NETLIFY")).secretValue;
-export const getClientIdGitHub = async () =>
-  (await client.getSecret("CLIENT_ID_GITHUB")).secretValue;
-export const getClientIdGitLab = async () =>
-  (await client.getSecret("CLIENT_ID_GITLAB")).secretValue;
-export const getClientIdBitBucket = async () =>
-  (await client.getSecret("CLIENT_ID_BITBUCKET")).secretValue;
-export const getClientIdGCPSecretManager = async () =>
-  (await client.getSecret("CLIENT_ID_GCP_SECRET_MANAGER")).secretValue;
-export const getClientSecretAzure = async () =>
-  (await client.getSecret("CLIENT_SECRET_AZURE")).secretValue;
-export const getClientSecretHeroku = async () =>
-  (await client.getSecret("CLIENT_SECRET_HEROKU")).secretValue;
-export const getClientSecretVercel = async () =>
-  (await client.getSecret("CLIENT_SECRET_VERCEL")).secretValue;
-export const getClientSecretNetlify = async () =>
-  (await client.getSecret("CLIENT_SECRET_NETLIFY")).secretValue;
-export const getClientSecretGitHub = async () =>
-  (await client.getSecret("CLIENT_SECRET_GITHUB")).secretValue;
-export const getClientSecretGitLab = async () =>
-  (await client.getSecret("CLIENT_SECRET_GITLAB")).secretValue;
-export const getClientSecretBitBucket = async () =>
-  (await client.getSecret("CLIENT_SECRET_BITBUCKET")).secretValue;
-export const getClientSecretGCPSecretManager = async () =>
-  (await client.getSecret("CLIENT_SECRET_GCP_SECRET_MANAGER")).secretValue;
-export const getClientSlugVercel = async () =>
-  (await client.getSecret("CLIENT_SLUG_VERCEL")).secretValue;
+export const getClientIdHeroku = async () => (await client.getSecret("CLIENT_ID_HEROKU")).secretValue;
+export const getClientIdVercel = async () => (await client.getSecret("CLIENT_ID_VERCEL")).secretValue;
+export const getClientIdNetlify = async () => (await client.getSecret("CLIENT_ID_NETLIFY")).secretValue;
+export const getClientIdGitHub = async () => (await client.getSecret("CLIENT_ID_GITHUB")).secretValue;
+export const getClientIdGitLab = async () => (await client.getSecret("CLIENT_ID_GITLAB")).secretValue;
+export const getClientIdBitBucket = async () => (await client.getSecret("CLIENT_ID_BITBUCKET")).secretValue;
+export const getClientIdGCPSecretManager = async () => (await client.getSecret("CLIENT_ID_GCP_SECRET_MANAGER")).secretValue;
+export const getClientSecretAzure = async () => (await client.getSecret("CLIENT_SECRET_AZURE")).secretValue;
+export const getClientSecretHeroku = async () => (await client.getSecret("CLIENT_SECRET_HEROKU")).secretValue;
+export const getClientSecretVercel = async () => (await client.getSecret("CLIENT_SECRET_VERCEL")).secretValue;
+export const getClientSecretNetlify = async () => (await client.getSecret("CLIENT_SECRET_NETLIFY")).secretValue;
+export const getClientSecretGitHub = async () => (await client.getSecret("CLIENT_SECRET_GITHUB")).secretValue;
+export const getClientSecretGitLab = async () => (await client.getSecret("CLIENT_SECRET_GITLAB")).secretValue;
+export const getClientSecretBitBucket = async () => (await client.getSecret("CLIENT_SECRET_BITBUCKET")).secretValue;
+export const getClientSecretGCPSecretManager = async () => (await client.getSecret("CLIENT_SECRET_GCP_SECRET_MANAGER")).secretValue;
+export const getClientSlugVercel = async () => (await client.getSecret("CLIENT_SLUG_VERCEL")).secretValue;
 
-export const getClientIdGoogleLogin = async () =>
-  (await client.getSecret("CLIENT_ID_GOOGLE_LOGIN")).secretValue;
-export const getClientSecretGoogleLogin = async () =>
-  (await client.getSecret("CLIENT_SECRET_GOOGLE_LOGIN")).secretValue;
-export const getClientIdGitHubLogin = async () =>
-  (await client.getSecret("CLIENT_ID_GITHUB_LOGIN")).secretValue;
-export const getClientSecretGitHubLogin = async () =>
-  (await client.getSecret("CLIENT_SECRET_GITHUB_LOGIN")).secretValue;
-export const getClientIdGitLabLogin = async () =>
-  (await client.getSecret("CLIENT_ID_GITLAB_LOGIN")).secretValue;
-export const getClientSecretGitLabLogin = async () =>
-  (await client.getSecret("CLIENT_SECRET_GITLAB_LOGIN")).secretValue;
-export const getUrlGitLabLogin = async () =>
-  (await client.getSecret("URL_GITLAB_LOGIN")).secretValue || GITLAB_URL;
+export const getClientIdGoogleLogin = async () => (await client.getSecret("CLIENT_ID_GOOGLE_LOGIN")).secretValue;
+export const getClientSecretGoogleLogin = async () => (await client.getSecret("CLIENT_SECRET_GOOGLE_LOGIN")).secretValue;
+export const getClientIdGitHubLogin = async () => (await client.getSecret("CLIENT_ID_GITHUB_LOGIN")).secretValue;
+export const getClientSecretGitHubLogin = async () => (await client.getSecret("CLIENT_SECRET_GITHUB_LOGIN")).secretValue;
+export const getClientIdGitLabLogin = async () => (await client.getSecret("CLIENT_ID_GITLAB_LOGIN")).secretValue;
+export const getClientSecretGitLabLogin = async () => (await client.getSecret("CLIENT_SECRET_GITLAB_LOGIN")).secretValue;
+export const getUrlGitLabLogin = async () => (await client.getSecret("URL_GITLAB_LOGIN")).secretValue || GITLAB_URL;
 
-export const getAwsCloudWatchLog = async () => {
-  const logGroupName =
-    (await client.getSecret("AWS_CLOUDWATCH_LOG_GROUP_NAME")).secretValue || "infisical-log-stream";
-  const region = (await client.getSecret("AWS_CLOUDWATCH_LOG_REGION")).secretValue;
-  const accessKeyId = (await client.getSecret("AWS_CLOUDWATCH_LOG_ACCESS_KEY_ID")).secretValue;
-  const accessKeySecret = (await client.getSecret("AWS_CLOUDWATCH_LOG_ACCESS_KEY_SECRET"))
-    .secretValue;
-  const interval = parseInt(
-    (await client.getSecret("AWS_CLOUDWATCH_LOG_INTERVAL")).secretValue || 1000,
-    10
-  );
-  if (!region || !accessKeyId || !accessKeySecret) return;
-  return { logGroupName, region, accessKeySecret, accessKeyId, interval };
-};
-
-export const getPostHogHost = async () =>
-  (await client.getSecret("POSTHOG_HOST")).secretValue || "https://app.posthog.com";
-export const getPostHogProjectApiKey = async () =>
-  (await client.getSecret("POSTHOG_PROJECT_API_KEY")).secretValue ||
-  "phc_nSin8j5q2zdhpFDI1ETmFNUIuTG4DwKVyIigrY10XiE";
+export const getPostHogHost = async () => (await client.getSecret("POSTHOG_HOST")).secretValue || "https://app.posthog.com";
+export const getPostHogProjectApiKey = async () => (await client.getSecret("POSTHOG_PROJECT_API_KEY")).secretValue || "phc_nSin8j5q2zdhpFDI1ETmFNUIuTG4DwKVyIigrY10XiE";
 export const getSentryDSN = async () => (await client.getSecret("SENTRY_DSN")).secretValue;
 export const getSiteURL = async () => (await client.getSecret("SITE_URL")).secretValue;
 export const getSmtpHost = async () => (await client.getSecret("SMTP_HOST")).secretValue;
-export const getSmtpSecure = async () =>
-  (await client.getSecret("SMTP_SECURE")).secretValue === "true" || false;
-export const getSmtpPort = async () =>
-  parseInt((await client.getSecret("SMTP_PORT")).secretValue) || 587;
+export const getSmtpSecure = async () => (await client.getSecret("SMTP_SECURE")).secretValue === "true" || false;
+export const getSmtpPort = async () => parseInt((await client.getSecret("SMTP_PORT")).secretValue) || 587;
 export const getSmtpUsername = async () => (await client.getSecret("SMTP_USERNAME")).secretValue;
 export const getSmtpPassword = async () => (await client.getSecret("SMTP_PASSWORD")).secretValue;
-export const getSmtpFromAddress = async () =>
-  (await client.getSecret("SMTP_FROM_ADDRESS")).secretValue;
-export const getSmtpFromName = async () =>
-  (await client.getSecret("SMTP_FROM_NAME")).secretValue || "Infisical";
+export const getSmtpFromAddress = async () => (await client.getSecret("SMTP_FROM_ADDRESS")).secretValue;
+export const getSmtpFromName = async () => (await client.getSecret("SMTP_FROM_NAME")).secretValue || "Infisical";
 
-export const getSecretScanningWebhookProxy = async () =>
-  (await client.getSecret("SECRET_SCANNING_WEBHOOK_PROXY")).secretValue;
-export const getSecretScanningWebhookSecret = async () =>
-  (await client.getSecret("SECRET_SCANNING_WEBHOOK_SECRET")).secretValue;
-export const getSecretScanningGitAppId = async () =>
-  (await client.getSecret("SECRET_SCANNING_GIT_APP_ID")).secretValue;
-export const getSecretScanningPrivateKey = async () =>
-  (await client.getSecret("SECRET_SCANNING_PRIVATE_KEY")).secretValue;
+export const getSecretScanningWebhookProxy = async () => (await client.getSecret("SECRET_SCANNING_WEBHOOK_PROXY")).secretValue;
+export const getSecretScanningWebhookSecret = async () => (await client.getSecret("SECRET_SCANNING_WEBHOOK_SECRET")).secretValue;
+export const getSecretScanningGitAppId = async () => (await client.getSecret("SECRET_SCANNING_GIT_APP_ID")).secretValue;
+export const getSecretScanningPrivateKey = async () => (await client.getSecret("SECRET_SCANNING_PRIVATE_KEY")).secretValue;
 
 export const getRedisUrl = async () => (await client.getSecret("REDIS_URL")).secretValue;
-export const getIsInfisicalCloud = async () =>
-  (await client.getSecret("INFISICAL_CLOUD")).secretValue === "true";
 
 export const getLicenseKey = async () => {
   const secretValue = (await client.getSecret("LICENSE_KEY")).secretValue;
   return secretValue === "" ? undefined : secretValue;
-};
+}
 export const getLicenseServerKey = async () => {
   const secretValue = (await client.getSecret("LICENSE_SERVER_KEY")).secretValue;
   return secretValue === "" ? undefined : secretValue;
-};
-export const getLicenseServerUrl = async () =>
-  (await client.getSecret("LICENSE_SERVER_URL")).secretValue || "https://portal.infisical.com";
+}
+export const getLicenseServerUrl = async () => (await client.getSecret("LICENSE_SERVER_URL")).secretValue || "https://portal.infisical.com";
 
-export const getTelemetryEnabled = async () =>
-  (await client.getSecret("TELEMETRY_ENABLED")).secretValue !== "false" && true;
+export const getTelemetryEnabled = async () => (await client.getSecret("TELEMETRY_ENABLED")).secretValue !== "false" && true;
 export const getLoopsApiKey = async () => (await client.getSecret("LOOPS_API_KEY")).secretValue;
-export const getSmtpConfigured = async () =>
-  (await client.getSecret("SMTP_HOST")).secretValue == "" ||
-  (await client.getSecret("SMTP_HOST")).secretValue == undefined
-    ? false
-    : true;
+export const getSmtpConfigured = async () => (await client.getSecret("SMTP_HOST")).secretValue == "" || (await client.getSecret("SMTP_HOST")).secretValue == undefined ? false : true
 export const getHttpsEnabled = async () => {
   if ((await getNodeEnv()) != "production") {
     // no https for anything other than prod
-    return false;
+    return false
   }
 
-  if (
-    (await client.getSecret("HTTPS_ENABLED")).secretValue == undefined ||
-    (await client.getSecret("HTTPS_ENABLED")).secretValue == ""
-  ) {
+  if ((await client.getSecret("HTTPS_ENABLED")).secretValue == undefined || (await client.getSecret("HTTPS_ENABLED")).secretValue == "") {
     // default when no value present
-    return true;
+    return true
   }
 
-  return (await client.getSecret("HTTPS_ENABLED")).secretValue === "true" && true;
-};
+  return (await client.getSecret("HTTPS_ENABLED")).secretValue === "true" && true
+}

backend/src/config/serverConfig.ts

@@ -1,24 +0,0 @@
-import { IServerConfig, ServerConfig } from "../models/serverConfig";
-
-let serverConfig: IServerConfig;
-
-export const serverConfigInit = async () => {
-  const cfg = await ServerConfig.findOne({});
-  if (!cfg) {
-    const cfg = new ServerConfig();
-    await cfg.save();
-    serverConfig = cfg;
-  } else {
-    serverConfig = cfg;
-  }
-  return serverConfig;
-};
-
-export const getServerConfig = () => serverConfig;
-
-export const updateServerConfig = async (data: Partial<IServerConfig>) => {
-  const cfg = await ServerConfig.findByIdAndUpdate(serverConfig._id, data, { new: true });
-  if (!cfg) throw new Error("Failed to update server config");
-  serverConfig = cfg;
-  return serverConfig;
-};

backend/src/controllers/v1/adminController.ts

@@ -1,100 +0,0 @@
-import { Request, Response } from "express";
-import { getHttpsEnabled } from "../../config";
-import { getServerConfig, updateServerConfig as setServerConfig } from "../../config/serverConfig";
-import { initializeDefaultOrg, issueAuthTokens } from "../../helpers";
-import { validateRequest } from "../../helpers/validation";
-import { User } from "../../models";
-import { TelemetryService } from "../../services";
-import { BadRequestError, UnauthorizedRequestError } from "../../utils/errors";
-import * as reqValidator from "../../validation/admin";
-
-export const getServerConfigInfo = (_req: Request, res: Response) => {
-  const config = getServerConfig();
-  return res.send({ config });
-};
-
-export const updateServerConfig = async (req: Request, res: Response) => {
-  const {
-    body: { allowSignUp }
-  } = await validateRequest(reqValidator.UpdateServerConfigV1, req);
-  const config = await setServerConfig({ allowSignUp });
-  return res.send({ config });
-};
-
-export const adminSignUp = async (req: Request, res: Response) => {
-  const cfg = getServerConfig();
-  if (cfg.initialized) throw UnauthorizedRequestError({ message: "Admin has been created" });
-  const {
-    body: {
-      email,
-      publicKey,
-      salt,
-      lastName,
-      verifier,
-      firstName,
-      protectedKey,
-      protectedKeyIV,
-      protectedKeyTag,
-      encryptedPrivateKey,
-      encryptedPrivateKeyIV,
-      encryptedPrivateKeyTag
-    }
-  } = await validateRequest(reqValidator.SignupV1, req);
-  let user = await User.findOne({ email });
-  if (user) throw BadRequestError({ message: "User already exist" });
-  user = new User({
-    email,
-    firstName,
-    lastName,
-    encryptionVersion: 2,
-    protectedKey,
-    protectedKeyIV,
-    protectedKeyTag,
-    publicKey,
-    encryptedPrivateKey,
-    iv: encryptedPrivateKeyIV,
-    tag: encryptedPrivateKeyTag,
-    salt,
-    verifier,
-    superAdmin: true
-  });
-  await user.save();
-  await initializeDefaultOrg({ organizationName: "Admin Org", user });
-
-  await setServerConfig({ initialized: true });
-
-  // issue tokens
-  const tokens = await issueAuthTokens({
-    userId: user._id,
-    ip: req.realIP,
-    userAgent: req.headers["user-agent"] ?? ""
-  });
-
-  const token = tokens.token;
-
-  const postHogClient = await TelemetryService.getPostHogClient();
-  if (postHogClient) {
-    postHogClient.capture({
-      event: "admin initialization",
-      properties: {
-        email: user.email,
-        lastName,
-        firstName
-      }
-    });
-  }
-
-  // store (refresh) token in httpOnly cookie
-  res.cookie("jid", tokens.refreshToken, {
-    httpOnly: true,
-    path: "/",
-    sameSite: "strict",
-    secure: await getHttpsEnabled()
-  });
-
-  return res.status(200).send({
-    message: "Successfully set up admin account",
-    user,
-    token
-  });
-};

backend/src/controllers/v1/authController.ts

@@ -3,41 +3,31 @@ import jwt from "jsonwebtoken";
 import * as bigintConversion from "bigint-conversion";
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const jsrp = require("jsrp");
-import { 
-  LoginSRPDetail,
-  TokenVersion,
-  User
-} from "../../models";
+import { LoginSRPDetail, TokenVersion, User } from "../../models";
 import { clearTokens, createToken, issueAuthTokens } from "../../helpers/auth";
 import { checkUserDevice } from "../../helpers/user";
-import { AuthTokenType } from "../../variables";
 import { 
-  BadRequestError, 
-  UnauthorizedRequestError
-} from "../../utils/errors";
+  ACTION_LOGIN,
+  ACTION_LOGOUT, 
+  AuthTokenType 
+} from "../../variables";
+import { BadRequestError, UnauthorizedRequestError } from "../../utils/errors";
+import { EELogService } from "../../ee/services";
+import { getUserAgentType } from "../../utils/posthog";
 import {
   getAuthSecret,
   getHttpsEnabled,
-  getJwtAuthLifetime,
+  getJwtAuthLifetime
 } from "../../config";
 import { ActorType } from "../../ee/models";
 import { validateRequest } from "../../helpers/validation";
 import * as reqValidator from "../../validation/auth";
 
 declare module "jsonwebtoken" {
-  export interface AuthnJwtPayload extends jwt.JwtPayload {
-    authTokenType: AuthTokenType;
-  }
   export interface UserIDJwtPayload extends jwt.JwtPayload {
     userId: string;
     refreshVersion?: number;
   }
-  export interface IdentityAccessTokenJwtPayload extends jwt.JwtPayload {
-    _id: string;
-    clientSecretId: string;
-    identityAccessTokenId: string;
-    authTokenType: string;
-  }
 }
 
 /**
@@ -147,6 +137,19 @@ export const login2 = async (req: Request, res: Response) => {
           secure: await getHttpsEnabled()
         });
 
+        const loginAction = await EELogService.createAction({
+          name: ACTION_LOGIN,
+          userId: user._id
+        });
+
+        loginAction &&
+          (await EELogService.createLog({
+            userId: user._id,
+            actions: [loginAction],
+            channel: getUserAgentType(req.headers["user-agent"]),
+            ipAddress: req.realIP
+          }));
+
         // return (access) token in response
         return res.status(200).send({
           token: tokens.token,
@@ -183,6 +186,19 @@ export const logout = async (req: Request, res: Response) => {
     secure: (await getHttpsEnabled()) as boolean
   });
 
+  const logoutAction = await EELogService.createAction({
+    name: ACTION_LOGOUT,
+    userId: req.user._id
+  });
+
+  logoutAction &&
+    (await EELogService.createLog({
+      userId: req.user._id,
+      actions: [logoutAction],
+      channel: getUserAgentType(req.headers["user-agent"]),
+      ipAddress: req.realIP
+    }));
+
   return res.status(200).send({
     message: "Successfully logged out."
   });
@@ -274,4 +290,4 @@ export const getNewToken = async (req: Request, res: Response) => {
 
 export const handleAuthProviderCallback = (req: Request, res: Response) => {
   res.redirect(`/login/provider/success?token=${encodeURIComponent(req.providerAuthToken)}`);
-};
+};

backend/src/controllers/v1/botController.ts

@@ -7,7 +7,7 @@ import * as reqValidator from "../../validation/bot";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import { ForbiddenError } from "@casl/ability";
 import { BadRequestError } from "../../utils/errors";
@@ -28,11 +28,7 @@ export const getBotByWorkspaceId = async (req: Request, res: Response) => {
   const {
     params: { workspaceId }
   } = await validateRequest(reqValidator.GetBotByWorkspaceIdV1, req);
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -74,11 +70,7 @@ export const setBotActiveState = async (req: Request, res: Response) => {
   }
   const userId = req.user._id;
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: bot.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(userId, bot.workspace.toString());
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.Integrations

backend/src/controllers/v1/index.ts

@@ -1,5 +1,4 @@
 import * as authController from "./authController";
-import * as universalAuthController from "./universalAuthController";
 import * as botController from "./botController";
 import * as integrationAuthController from "./integrationAuthController";
 import * as integrationController from "./integrationController";
@@ -17,11 +16,8 @@ import * as workspaceController from "./workspaceController";
 import * as secretScanningController from "./secretScanningController";
 import * as webhookController from "./webhookController";
 import * as secretImpsController from "./secretImpsController";
-import * as adminController from "./adminController";
-
 export {
   authController,
-  universalAuthController,
   botController,
   integrationAuthController,
   integrationController,
@@ -38,6 +34,5 @@ export {
   workspaceController,
   secretScanningController,
   webhookController,
-  secretImpsController,
-  adminController
+  secretImpsController
 };

backend/src/controllers/v1/integrationAuthController.ts

@@ -2,7 +2,7 @@ import { Request, Response } from "express";
 import { Types } from "mongoose";
 import { standardRequest } from "../../config/request";
 import { getApps, getTeams, revokeAccess } from "../../integrations";
-import { Bot, IIntegrationAuth, Integration, IntegrationAuth, Workspace } from "../../models";
+import { Bot, IntegrationAuth, Workspace } from "../../models";
 import { EventType } from "../../ee/models";
 import { IntegrationService } from "../../services";
 import { EEAuditLogService } from "../../ee/services";
@@ -10,7 +10,6 @@ import {
   ALGORITHM_AES_256_GCM,
   ENCODING_SCHEME_UTF8,
   INTEGRATION_BITBUCKET_API_URL,
-  INTEGRATION_CHECKLY_API_URL,
   INTEGRATION_GCP_SECRET_MANAGER,
   INTEGRATION_NORTHFLANK_API_URL,
   INTEGRATION_QOVERY_API_URL,
@@ -25,10 +24,11 @@ import * as reqValidator from "../../validation/integrationAuth";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import { ForbiddenError } from "@casl/ability";
 import { getIntegrationAuthAccessHelper } from "../../helpers";
+import { ObjectId } from "mongodb";
 
 /***
  * Return integration authorization with id [integrationAuthId]
@@ -40,15 +40,15 @@ export const getIntegrationAuth = async (req: Request, res: Response) => {
 
   const integrationAuth = await IntegrationAuth.findById(integrationAuthId);
 
-  if (!integrationAuth) return res.status(400).send({
-    message: "Failed to find integration authorization"
-  });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
-  });
+  if (!integrationAuth)
+    return res.status(400).send({
+      message: "Failed to find integration authorization"
+    });
 
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -79,11 +79,7 @@ export const oAuthExchange = async (req: Request, res: Response) => {
   } = await validateRequest(reqValidator.OauthExchangeV1, req);
   if (!INTEGRATION_SET.has(integration)) throw new Error("Failed to validate integration");
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.Integrations
@@ -130,15 +126,12 @@ export const oAuthExchange = async (req: Request, res: Response) => {
 export const saveIntegrationToken = async (req: Request, res: Response) => {
   // TODO: refactor
   // TODO: check if access token is valid for each integration
+  let integrationAuth;
   const {
     body: { workspaceId, integration, url, accessId, namespace, accessToken, refreshToken }
   } = await validateRequest(reqValidator.SaveIntegrationAccessTokenV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.Integrations
@@ -151,21 +144,31 @@ export const saveIntegrationToken = async (req: Request, res: Response) => {
 
   if (!bot) throw new Error("Bot must be enabled to save integration access token");
 
-  let integrationAuth = await new IntegrationAuth({
-    workspace: new Types.ObjectId(workspaceId),
-    integration,
-    url,
-    namespace,
-    algorithm: ALGORITHM_AES_256_GCM,
-    keyEncoding: ENCODING_SCHEME_UTF8,
-    ...(integration === INTEGRATION_GCP_SECRET_MANAGER
-      ? {
-          metadata: {
-            authMethod: "serviceAccount"
+  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,
+      ...(integration === INTEGRATION_GCP_SECRET_MANAGER
+        ? {
+            metadata: {
+              authMethod: "serviceAccount"
+            }
           }
-        }
-      : {})
-  }).save();
+        : {})
+    },
+    {
+      new: true,
+      upsert: true
+    }
+  );
 
   // encrypt and save integration access details
   if (refreshToken) {
@@ -177,12 +180,12 @@ export const saveIntegrationToken = async (req: Request, res: Response) => {
 
   // encrypt and save integration access details
   if (accessId || accessToken) {
-    integrationAuth = (await IntegrationService.setIntegrationAuthAccess({
+    integrationAuth = await IntegrationService.setIntegrationAuthAccess({
       integrationAuthId: integrationAuth._id.toString(),
       accessId,
       accessToken,
       accessExpiresAt: undefined
-    })) as IIntegrationAuth;
+    });
   }
 
   if (!integrationAuth) throw new Error("Failed to save integration access token");
@@ -219,14 +222,13 @@ export const getIntegrationAuthApps = async (req: Request, res: Response) => {
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken, accessId } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
-  });
-  
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -258,14 +260,13 @@ export const getIntegrationAuthTeams = async (req: Request, res: Response) => {
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
-  });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -295,14 +296,13 @@ export const getIntegrationAuthVercelBranches = async (req: Request, res: Respon
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
-  });
-  
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -345,60 +345,6 @@ export const getIntegrationAuthVercelBranches = async (req: Request, res: Respon
   });
 };
 
-/**
- * Return list of Checkly groups for a specific user
- * @param req
- * @param res
- */
-export const getIntegrationAuthChecklyGroups = async (req: Request, res: Response) => {
-  const {
-    params: { integrationAuthId },
-    query: { accountId }
-  } = await validateRequest(reqValidator.GetIntegrationAuthChecklyGroupsV1, req);
-  
-  const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
-  });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
-  });
-  
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Read,
-    ProjectPermissionSub.Integrations
-  );
-
-  interface ChecklyGroup {
-    id: number;
-    name: string;
-  }
-  
-  if (accountId && accountId !== "") {
-    const { data }: { data: ChecklyGroup[] } = (
-      await standardRequest.get(`${INTEGRATION_CHECKLY_API_URL}/v1/check-groups`, {
-          headers: {
-              Authorization: `Bearer ${accessToken}`,
-              Accept: "application/json",
-              "X-Checkly-Account": accountId
-          }
-      })
-    );
-    
-    return res.status(200).send({
-      groups: data.map((g: ChecklyGroup) => ({
-        name: g.name,
-        groupId: g.id,
-      }))
-    });
-  }
-
-  return res.status(200).send({
-    groups: []
-  });
-}
-
 /**
  * Return list of Qovery Orgs for a specific user
  * @param req
@@ -411,14 +357,13 @@ export const getIntegrationAuthQoveryOrgs = async (req: Request, res: Response)
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
-  });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -464,14 +409,13 @@ export const getIntegrationAuthQoveryProjects = async (req: Request, res: Respon
   
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
-  });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -526,14 +470,13 @@ export const getIntegrationAuthQoveryEnvironments = async (req: Request, res: Re
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
-  });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -588,14 +531,13 @@ export const getIntegrationAuthQoveryApps = async (req: Request, res: Response)
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
-  });
-  
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -650,14 +592,13 @@ export const getIntegrationAuthQoveryContainers = async (req: Request, res: Resp
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
-  });
-  
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -712,14 +653,13 @@ export const getIntegrationAuthQoveryJobs = async (req: Request, res: Response)
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
-  });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -775,14 +715,13 @@ export const getIntegrationAuthRailwayEnvironments = async (req: Request, res: R
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
-  });
-  
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -869,14 +808,13 @@ export const getIntegrationAuthRailwayServices = async (req: Request, res: Respo
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
-  });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -994,14 +932,13 @@ export const getIntegrationAuthBitBucketWorkspaces = async (req: Request, res: R
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
-  });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -1051,14 +988,13 @@ export const getIntegrationAuthNorthflankSecretGroups = async (req: Request, res
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
-  });
-  
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -1140,14 +1076,13 @@ export const getIntegrationAuthTeamCityBuildConfigs = async (req: Request, res:
   
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
-  });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -1197,78 +1132,26 @@ export const getIntegrationAuthTeamCityBuildConfigs = async (req: Request, res:
   });
 };
 
-/**
- * Delete all integration authorizations and integrations for workspace with id [workspaceId]
- * with integration name [integration]
- * @param req
- * @param res
- * @returns
- */
-export const deleteIntegrationAuths = async (req: Request, res: Response) => {
-  const {
-    query: { integration, workspaceId }
-  } = await validateRequest(reqValidator.DeleteIntegrationAuthsV1, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Delete,
-    ProjectPermissionSub.Integrations
-  );
-  
-  const integrationAuths = await IntegrationAuth.deleteMany({
-    integration,
-    workspace: new Types.ObjectId(workspaceId)
-  });
-
-  const integrations = await Integration.deleteMany({
-    integration,
-    workspace: new Types.ObjectId(workspaceId)
-  });
-
-  await EEAuditLogService.createAuditLog(
-    req.authData,
-    {
-      type: EventType.UNAUTHORIZE_INTEGRATION,
-      metadata: {
-        integration
-      }
-    },
-    {
-      workspaceId: new Types.ObjectId(workspaceId)
-    }
-  );
-
-  return res.status(200).send({
-    integrationAuths,
-    integrations
-  });
-}
-
 /**
  * Delete integration authorization with id [integrationAuthId]
  * @param req
  * @param res
  * @returns
  */
-export const deleteIntegrationAuthById = async (req: Request, res: Response) => {
+export const deleteIntegrationAuth = async (req: Request, res: Response) => {
   const {
     params: { integrationAuthId }
   } = await validateRequest(reqValidator.DeleteIntegrationAuthV1, req);
 
   // TODO(akhilmhdh): remove class -> static function path and makes these into reusable independent functions
   const { integrationAuth, accessToken } = await getIntegrationAuthAccessHelper({
-    integrationAuthId: new Types.ObjectId(integrationAuthId)
+    integrationAuthId: new ObjectId(integrationAuthId)
   });
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace
-  });
-  
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Delete,
     ProjectPermissionSub.Integrations

backend/src/controllers/v1/integrationController.ts

@@ -13,7 +13,7 @@ import * as reqValidator from "../../validation/integration";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import { ForbiddenError } from "@casl/ability";
 
@@ -51,12 +51,11 @@ export const createIntegration = async (req: Request, res: Response) => {
     );
 
   if (!integrationAuth) throw BadRequestError({ message: "Integration auth not found" });
-  
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integrationAuth.workspace._id
-  });
-  
+
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace._id.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.Integrations
@@ -165,11 +164,10 @@ export const updateIntegration = async (req: Request, res: Response) => {
   const integration = await Integration.findById(integrationId);
   if (!integration) throw BadRequestError({ message: "Integration not found" });
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integration.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integration.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.Integrations
@@ -236,11 +234,10 @@ export const deleteIntegration = async (req: Request, res: Response) => {
   const integration = await Integration.findById(integrationId);
   if (!integration) throw BadRequestError({ message: "Integration not found" });
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: integration.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integration.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Delete,
     ProjectPermissionSub.Integrations
@@ -251,21 +248,6 @@ export const deleteIntegration = async (req: Request, res: Response) => {
   });
 
   if (!deletedIntegration) throw new Error("Failed to find integration");
- 
-  const numOtherIntegrationsUsingSameAuth = await Integration.countDocuments({
-    integrationAuth: deletedIntegration.integrationAuth,
-    _id: {
-      $nin: [deletedIntegration._id]
-    }
-  });
-  
-  if (numOtherIntegrationsUsingSameAuth === 0) {
-    // no other integrations are using the same integration auth
-    // -> delete integration auth associated with the integration being deleted
-    await IntegrationAuth.deleteOne({
-      _id: deletedIntegration.integrationAuth
-    });
-  }
 
   await EEAuditLogService.createAuditLog(
     req.authData,
@@ -303,11 +285,7 @@ export const manualSync = async (req: Request, res: Response) => {
     body: { workspaceId, environment }
   } = await validateRequest(reqValidator.ManualSyncV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.Integrations

backend/src/controllers/v1/keyController.ts

@@ -9,7 +9,7 @@ import * as reqValidator from "../../validation/key";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import { ForbiddenError } from "@casl/ability";
 
@@ -26,11 +26,7 @@ export const uploadKey = async (req: Request, res: Response) => {
     body: { key }
   } = await validateRequest(reqValidator.UploadKeyV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.Member

backend/src/controllers/v1/membershipController.ts

@@ -4,15 +4,15 @@ import { IUser, Key, Membership, MembershipOrg, User, Workspace } from "../../mo
 import { EventType, Role } from "../../ee/models";
 import { deleteMembership as deleteMember, findMembership } from "../../helpers/membership";
 import { sendMail } from "../../helpers/nodemailer";
-import { ACCEPTED, ADMIN, CUSTOM, MEMBER, NO_ACCESS, VIEWER } from "../../variables";
+import { ACCEPTED, ADMIN, CUSTOM, MEMBER, VIEWER } from "../../variables";
 import { getSiteURL } from "../../config";
-import { EEAuditLogService, EELicenseService } from "../../ee/services";
+import { EEAuditLogService } from "../../ee/services";
 import { validateRequest } from "../../helpers/validation";
 import * as reqValidator from "../../validation/membership";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import { ForbiddenError } from "@casl/ability";
 import { BadRequestError } from "../../utils/errors";
@@ -63,12 +63,11 @@ export const deleteMembership = async (req: Request, res: Response) => {
   if (!membershipToDelete) {
     throw new Error("Failed to delete workspace membership that doesn't exist");
   }
-  
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: membershipToDelete.workspace
-  });
-  
+
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    membershipToDelete.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Delete,
     ProjectPermissionSub.Member
@@ -119,17 +118,16 @@ export const changeMembershipRole = async (req: Request, res: Response) => {
     throw new Error("Failed to find membership to change role");
   }
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: membershipToChangeRole.workspace
-  });
-  
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    membershipToChangeRole.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.Member
   );
 
-  const isCustomRole = ![ADMIN, MEMBER, VIEWER, NO_ACCESS].includes(role);
+  const isCustomRole = ![ADMIN, MEMBER, VIEWER].includes(role);
   if (isCustomRole) {
     const wsRole = await Role.findOne({
       slug: role,
@@ -137,13 +135,6 @@ export const changeMembershipRole = async (req: Request, res: Response) => {
       workspace: membershipToChangeRole.workspace
     });
     if (!wsRole) throw BadRequestError({ message: "Role not found" });
-
-    const plan = await EELicenseService.getPlan(wsRole.organization);
-
-    if (!plan.rbac) return res.status(400).send({
-      message: "Failed to assign custom role due to RBAC restriction. Upgrade plan to assign custom role to member."
-    });
-
     const membership = await Membership.findByIdAndUpdate(membershipId, {
       role: CUSTOM,
       customRole: wsRole
@@ -200,12 +191,7 @@ export const inviteUserToWorkspace = async (req: Request, res: Response) => {
     params: { workspaceId },
     body: { email }
   } = await validateRequest(InviteUserToWorkspaceV1, req);
-  
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.Member

backend/src/controllers/v1/membershipOrgController.ts

@@ -21,7 +21,7 @@ import { validateRequest } from "../../helpers/validation";
 import {
   OrgPermissionActions,
   OrgPermissionSubjects,
-  getAuthDataOrgPermissions
+  getUserOrgPermissions
 } from "../../ee/services/RoleService";
 import { ForbiddenError } from "@casl/ability";
 
@@ -44,12 +44,11 @@ export const deleteMembershipOrg = async (req: Request, _res: Response) => {
   if (!membershipOrgToDelete) {
     throw new Error("Failed to delete organization membership that doesn't exist");
   }
-  
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: membershipOrgToDelete.organization
-  });
 
+  const { permission, membership: membershipOrg } = await getUserOrgPermissions(
+    req.user._id,
+    membershipOrgToDelete.organization.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Delete,
     OrgPermissionSubjects.Member
@@ -61,7 +60,7 @@ export const deleteMembershipOrg = async (req: Request, _res: Response) => {
   });
 
   await updateSubscriptionOrgQuantity({
-    organizationId: membershipOrgToDelete.organization.toString()
+    organizationId: membershipOrg.organization.toString()
   });
 
   return membershipOrgToDelete;
@@ -97,11 +96,7 @@ export const inviteUserToOrganization = async (req: Request, res: Response) => {
     body: { inviteeEmail, organizationId }
   } = await validateRequest(reqValidator.InviteUserToOrgv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
-  
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Create,
     OrgPermissionSubjects.Member

backend/src/controllers/v1/organizationController.ts

@@ -1,5 +1,4 @@
 import { Request, Response } from "express";
-import { Types } from "mongoose";
 import {
   IncidentContactOrg,
   Membership,
@@ -15,7 +14,7 @@ import { ACCEPTED } from "../../variables";
 import {
   OrgPermissionActions,
   OrgPermissionSubjects,
-  getAuthDataOrgPermissions
+  getUserOrgPermissions
 } from "../../ee/services/RoleService";
 import { OrganizationNotFoundError } from "../../utils/errors";
 import { ForbiddenError } from "@casl/ability";
@@ -45,10 +44,7 @@ export const getOrganization = async (req: Request, res: Response) => {
   } = await validateRequest(reqValidator.GetOrgv1, req);
 
   // ensure user has membership
-  await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  })
+  await getUserOrgPermissions(req.user._id, organizationId);
 
   const organization = await Organization.findById(organizationId);
   if (!organization) {
@@ -72,12 +68,8 @@ export const getOrganizationMembers = async (req: Request, res: Response) => {
   const {
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgMembersv1, req);
-  
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
-  
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Member
@@ -103,10 +95,7 @@ export const getOrganizationWorkspaces = async (req: Request, res: Response) =>
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgWorkspacesv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  })
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Workspace
@@ -148,10 +137,7 @@ export const changeOrganizationName = async (req: Request, res: Response) => {
     body: { name }
   } = await validateRequest(reqValidator.ChangeOrgNamev1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Edit,
     OrgPermissionSubjects.Settings
@@ -186,10 +172,7 @@ export const getOrganizationIncidentContacts = async (req: Request, res: Respons
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgIncidentContactv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.IncidentAccount
@@ -216,10 +199,7 @@ export const addOrganizationIncidentContact = async (req: Request, res: Response
     body: { email }
   } = await validateRequest(reqValidator.CreateOrgIncideContact, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Create,
     OrgPermissionSubjects.IncidentAccount
@@ -248,10 +228,7 @@ export const deleteOrganizationIncidentContact = async (req: Request, res: Respo
     body: { email }
   } = await validateRequest(reqValidator.DelOrgIncideContact, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Delete,
     OrgPermissionSubjects.IncidentAccount
@@ -280,10 +257,7 @@ export const createOrganizationPortalSession = async (req: Request, res: Respons
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgPlanBillingInfov1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Edit,
     OrgPermissionSubjects.Billing
@@ -347,10 +321,7 @@ export const getOrganizationMembersAndTheirWorkspaces = async (req: Request, res
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgMembersv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Member

backend/src/controllers/v1/secretImpsController.ts

@@ -1,6 +1,4 @@
-
 import { Request, Response } from "express";
-import { Types } from "mongoose";
 import { isValidScope } from "../../helpers";
 import { Folder, IServiceTokenData, SecretImport, ServiceTokenData } from "../../models";
 import { getAllImportedSecrets } from "../../services/SecretImportService";
@@ -17,14 +15,14 @@ import * as reqValidator from "../../validation/secretImports";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import { ForbiddenError, subject } from "@casl/ability";
 
 export const createSecretImp = async (req: Request, res: Response) => {
   /* 
     #swagger.summary = 'Create secret import'
-    #swagger.description = 'Create secret import'
+    #swagger.description = 'Create a new secret import for a specified workspace and environment'
 
     #swagger.requestBody = {
         content: {
@@ -34,36 +32,36 @@ export const createSecretImp = async (req: Request, res: Response) => {
                     "properties": {
                         "workspaceId": {
                             "type": "string",
-                            "description": "ID of workspace where to create secret import",
+                            "description": "ID of the workspace where the secret import will be created",
                             "example": "someWorkspaceId"
                         },
                         "environment": {
                             "type": "string",
-                            "description": "Slug of environment where to create secret import",
-                            "example": "dev"
+                            "description": "Environment to import to",
+                            "example": "production"
                         },
-                        "directory": {
+                        "folderId": {
                             "type": "string",
-                            "description": "Path where to create secret import like / or /foo/bar. Default is /",
-                            "example": "/foo/bar"
+                            "description": "Folder ID. Use root for the root folder.",
+                            "example": "my_folder"
                         },
                         "secretImport": {
                             "type": "object",
                             "properties": {
                               "environment": {
                                 "type": "string",
-                                "description": "Slug of environment to import from",
+                                "description": "Import from environment",
                                 "example": "development"
                               },
                               "secretPath": {
                                 "type": "string",
-                                "description": "Path where to import from like / or /foo/bar.",
+                                "description": "Import from secret path",
                                 "example": "/user/oauth"
                               }
                             }
                         }
                     },
-                    "required": ["workspaceId", "environment", "directory", "secretImport"]
+                    "required": ["workspaceId", "environment", "folderName"]
                 }
             }
         }
@@ -107,21 +105,11 @@ export const createSecretImp = async (req: Request, res: Response) => {
       throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
     }
   } else {
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: new Types.ObjectId(workspaceId)
-    });
-
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
     ForbiddenError.from(permission).throwUnlessCan(
       ProjectPermissionActions.Create,
       subject(ProjectPermissionSub.Secrets, { environment, secretPath: directory })
     );
-
-    ForbiddenError.from(permission).throwUnlessCan(
-      ProjectPermissionActions.Create,
-      subject(ProjectPermissionSub.Secrets, { environment: secretImport.environment, secretPath: secretImport.secretPath })
-    );
-
   }
 
   const folders = await Folder.findOne({
@@ -218,12 +206,12 @@ export const createSecretImp = async (req: Request, res: Response) => {
  */
 export const updateSecretImport = async (req: Request, res: Response) => {
   /*
-    #swagger.summary = 'Update secret import'
-    #swagger.description = 'Update secret import'
+    #swagger.summary = 'Update a secret import'
+    #swagger.description = 'Updates an existing secret import based on the provided ID and new import details'
 
     #swagger.parameters['id'] = {
         in: 'path',
-        description: 'ID of secret import to update',
+        description: 'ID of the secret import to be updated',
         required: true,
         type: 'string',
         example: 'import12345'
@@ -237,19 +225,19 @@ export const updateSecretImport = async (req: Request, res: Response) => {
                     "properties": {
                         "secretImports": {
                             "type": "array",
-                            "description": "List of secret imports to update to",
+                            "description": "List of new secret imports",
                             "items": {
                                 "type": "object",
                                 "properties": {
                                     "environment": {
                                         "type": "string",
-                                        "description": "Slug of environment to import from",
-                                        "example": "dev"
+                                        "description": "Environment of the secret import",
+                                        "example": "production"
                                     },
                                     "secretPath": {
                                         "type": "string",
-                                        "description": "Path where to import secrets from like / or /foo/bar",
-                                        "example": "/foo/bar"
+                                        "description": "Path of the secret import",
+                                        "example": "/path/to/secret"
                                     }
                                 },
                                 "required": ["environment", "secretPath"]
@@ -325,11 +313,10 @@ export const updateSecretImport = async (req: Request, res: Response) => {
     }
   } else {
     // non token entry check
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: importSecDoc.workspace
-    });
-
+    const { permission } = await getUserProjectPermissions(
+      req.user._id,
+      importSecDoc.workspace.toString()
+    );
     ForbiddenError.from(permission).throwUnlessCan(
       ProjectPermissionActions.Edit,
       subject(ProjectPermissionSub.Secrets, {
@@ -337,13 +324,6 @@ export const updateSecretImport = async (req: Request, res: Response) => {
         secretPath
       })
     );
-
-    secretImports.forEach(({ environment, secretPath }) => {
-      ForbiddenError.from(permission).throwUnlessCan(
-        ProjectPermissionActions.Create,
-        subject(ProjectPermissionSub.Secrets, { environment, secretPath })
-      );
-    })
   }
 
   const orderBefore = importSecDoc.imports;
@@ -384,7 +364,7 @@ export const deleteSecretImport = async (req: Request, res: Response) => {
 
     #swagger.parameters['id'] = {
         in: 'path',
-        description: 'ID of parent secret import document from which to delete secret import',
+        description: 'ID of the secret import',
         required: true,
         type: 'string',
         example: '12345abcde'
@@ -398,12 +378,12 @@ export const deleteSecretImport = async (req: Request, res: Response) => {
                     "properties": {
                         "secretImportEnv": {
                             "type": "string",
-                            "description": "Slug of environment of import to delete",
+                            "description": "Import from environment",
                             "example": "someWorkspaceId"
                         },
                         "secretImportPath": {
                             "type": "string",
-                            "description": "Path like / or /foo/bar of import to delete",
+                            "description": "Import from secret path",
                             "example": "production"
                         }
                     },
@@ -462,11 +442,10 @@ export const deleteSecretImport = async (req: Request, res: Response) => {
       throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
     }
   } else {
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: importSecDoc.workspace
-    });
-
+    const { permission } = await getUserProjectPermissions(
+      req.user._id,
+      importSecDoc.workspace.toString()
+    );
     ForbiddenError.from(permission).throwUnlessCan(
       ProjectPermissionActions.Delete,
       subject(ProjectPermissionSub.Secrets, {
@@ -510,12 +489,12 @@ export const deleteSecretImport = async (req: Request, res: Response) => {
  */
 export const getSecretImports = async (req: Request, res: Response) => {
   /*
-    #swagger.summary = 'Get secret imports'
-    #swagger.description = 'Get secret imports'
+    #swagger.summary = 'Retrieve secret imports'
+    #swagger.description = 'Fetches the secret imports based on the workspaceId, environment, and folderId'
 
     #swagger.parameters['workspaceId'] = {
         in: 'query',
-        description: 'ID of workspace where to get secret imports from',
+        description: 'ID of the workspace of secret imports to get',
         required: true,
         type: 'string',
         example: 'workspace12345'
@@ -523,15 +502,15 @@ export const getSecretImports = async (req: Request, res: Response) => {
 
     #swagger.parameters['environment'] = {
         in: 'query',
-        description: 'Slug of environment where to get secret imports from',
+        description: 'Environment of secret imports to get',
         required: true,
         type: 'string',
         example: 'production'
     }
 
-    #swagger.parameters['directory'] = {
+    #swagger.parameters['folderId'] = {
         in: 'query',
-        description: 'Path where to get secret imports from like / or /foo/bar. Default is /',
+        description: 'ID of the folder containing the secret imports. Default: root',
         required: false,
         type: 'string',
         example: 'folder12345'
@@ -545,7 +524,8 @@ export const getSecretImports = async (req: Request, res: Response) => {
                     "type": "object",
                     "properties": {
                         "secretImport": {
-                          $ref: '#/definitions/SecretImport'
+                            "type": "object",
+                            "description": "Details of a secret import"
                         }
                     }
                 }
@@ -571,11 +551,7 @@ export const getSecretImports = async (req: Request, res: Response) => {
       throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
     }
   } else {
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: new Types.ObjectId(workspaceId)
-    });
-
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
     ForbiddenError.from(permission).throwUnlessCan(
       ProjectPermissionActions.Read,
       subject(ProjectPermissionSub.Secrets, {
@@ -629,11 +605,7 @@ export const getAllSecretsFromImport = async (req: Request, res: Response) => {
       throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
     }
   } else {
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: new Types.ObjectId(workspaceId)
-    });
-
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
     ForbiddenError.from(permission).throwUnlessCan(
       ProjectPermissionActions.Read,
       subject(ProjectPermissionSub.Secrets, {
@@ -686,11 +658,10 @@ export const getAllSecretsFromImport = async (req: Request, res: Response) => {
     permissionCheckFn = (env: string, secPath: string) =>
       isValidScope(req.authData.authPayload as IServiceTokenData, env, secPath);
   } else {
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: importSecDoc.workspace
-    });
-
+    const { permission } = await getUserProjectPermissions(
+      req.user._id,
+      importSecDoc.workspace.toString()
+    );
     ForbiddenError.from(permission).throwUnlessCan(
       ProjectPermissionActions.Read,
       subject(ProjectPermissionSub.Secrets, {

backend/src/controllers/v1/secretScanningController.ts

@@ -21,7 +21,7 @@ import * as reqValidator from "../../validation/secretScanning";
 import {
   OrgPermissionActions,
   OrgPermissionSubjects,
-  getAuthDataOrgPermissions
+  getUserOrgPermissions
 } from "../../ee/services/RoleService";
 import { ForbiddenError } from "@casl/ability";
 
@@ -37,11 +37,8 @@ export const createInstallationSession = async (req: Request, res: Response) =>
       message: "Failed to find organization"
     });
   }
-  
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Create,
     OrgPermissionSubjects.SecretScanning
@@ -73,12 +70,11 @@ export const linkInstallationToOrganization = async (req: Request, res: Response
   if (!installationSession) {
     throw UnauthorizedRequestError();
   }
-  
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: installationSession.organization
-  });
 
+  const { permission } = await getUserOrgPermissions(
+    req.user._id,
+    installationSession.organization.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Edit,
     OrgPermissionSubjects.SecretScanning
@@ -146,10 +142,7 @@ export const getRisksForOrganization = async (req: Request, res: Response) => {
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgRisksv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.SecretScanning
@@ -169,10 +162,7 @@ export const updateRisksStatus = async (req: Request, res: Response) => {
     body: { status }
   } = await validateRequest(reqValidator.UpdateRiskStatusv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Edit,
     OrgPermissionSubjects.SecretScanning

backend/src/controllers/v1/secretsFolderController.ts

@@ -17,7 +17,7 @@ import {
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import { BadRequestError, UnauthorizedRequestError } from "../../utils/errors";
 import * as reqValidator from "../../validation/folders";
@@ -27,12 +27,11 @@ const ERR_FOLDER_NOT_FOUND = BadRequestError({ message: "The folder doesn't exis
 // verify workspace id/environment
 export const createFolder = async (req: Request, res: Response) => {
   /* 
-    #swagger.summary = 'Create folder'
-    #swagger.description = 'Create folder'
+    #swagger.summary = 'Create a folder'
+    #swagger.description = 'Create a new folder in a specified workspace and environment'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
     #swagger.requestBody = {
@@ -43,23 +42,23 @@ export const createFolder = async (req: Request, res: Response) => {
                     "properties": {
                         "workspaceId": {
                             "type": "string",
-                            "description": "ID of the workspace where to create folder",
+                            "description": "ID of the workspace where the folder will be created",
                             "example": "someWorkspaceId"
                         },
                         "environment": {
                             "type": "string",
-                            "description": "Slug of environment where to create folder",
+                            "description": "Environment where the folder will reside",
                             "example": "production"
                         },
                         "folderName": {
                             "type": "string",
-                            "description": "Name of folder to create",
+                            "description": "Name of the folder to be created",
                             "example": "my_folder"
                         },
-                        "directory": {
+                        "parentFolderId": {
                             "type": "string",
-                            "description": "Path where to create folder like / or /foo/bar. Default is /",
-                            "example": "/foo/bar"
+                            "description": "ID of the parent folder under which this folder will be created. If not specified, it will be created at the root level.",
+                            "example": "someParentFolderId"
                         }
                     },
                     "required": ["workspaceId", "environment", "folderName"]
@@ -79,21 +78,14 @@ export const createFolder = async (req: Request, res: Response) => {
                             "properties": {
                                 "id": {
                                     "type": "string",
-                                    "description": "ID of folder",
                                     "example": "someFolderId"
                                 },
                                 "name": {
                                     "type": "string",
-                                    "description": "Name of folder",
                                     "example": "my_folder"
-                                },
-                                "version": {
-                                    "type": "number",
-                                    "description": "Version of folder",
-                                    "example": 1
                                 }
                             },
-                            "description": "Details of created folder"
+                            "description": "Details of the created folder"
                         }
                     }
                 }
@@ -125,11 +117,7 @@ export const createFolder = async (req: Request, res: Response) => {
     }
   } else {
     // user check
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: new Types.ObjectId(workspaceId)
-    });
-
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
     ForbiddenError.from(permission).throwUnlessCan(
       ProjectPermissionActions.Create,
       subject(ProjectPermissionSub.Secrets, { environment, secretPath: directory })
@@ -231,18 +219,18 @@ export const createFolder = async (req: Request, res: Response) => {
  */
 export const updateFolderById = async (req: Request, res: Response) => {
   /* 
-    #swagger.summary = 'Update folder'
-    #swagger.description = 'Update folder'
+    #swagger.summary = 'Update a folder by ID'
+    #swagger.description = 'Update the name of a folder in a specified workspace and environment by its ID'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
-    #swagger.parameters['folderName'] = {
-        "description": "Name of folder to update",
+    #swagger.parameters['folderId'] = {
+        "description": "ID of the folder to be updated",
         "required": true,
-        "type": "string"
+        "type": "string",
+        "in": "path"
     }
 
     #swagger.requestBody = {
@@ -253,23 +241,18 @@ export const updateFolderById = async (req: Request, res: Response) => {
                     "properties": {
                         "workspaceId": {
                             "type": "string",
-                            "description": "ID of workspace where to update folder",
+                            "description": "ID of the workspace where the folder is located",
                             "example": "someWorkspaceId"
                         },
                         "environment": {
                             "type": "string",
-                            "description": "Slug of environment where to update folder",
+                            "description": "Environment where the folder is located",
                             "example": "production"
                         },
                         "name": {
                             "type": "string",
-                            "description": "Name of folder to update to",
+                            "description": "New name for the folder",
                             "example": "updated_folder_name"
-                        },
-                        "directory": {
-                            "type": "string",
-                            "description": "Path where to update folder like / or /foo/bar. Default is /",
-                            "example": "/foo/bar"
                         }
                     },
                     "required": ["workspaceId", "environment", "name"]
@@ -286,7 +269,6 @@ export const updateFolderById = async (req: Request, res: Response) => {
                     "properties": {
                         "message": {
                             "type": "string",
-                            "description": "Success message",
                             "example": "Successfully updated folder"
                         },
                         "folder": {
@@ -294,13 +276,11 @@ export const updateFolderById = async (req: Request, res: Response) => {
                             "properties": {
                                 "name": {
                                     "type": "string",
-                                    "description": "Name of updated folder",
                                     "example": "updated_folder_name"
                                 },
                                 "id": {
                                     "type": "string",
-                                    "description": "ID of created folder",
-                                    "example": "abc123"
+                                    "example": "someFolderId"
                                 }
                             },
                             "description": "Details of the updated folder"
@@ -336,11 +316,7 @@ export const updateFolderById = async (req: Request, res: Response) => {
       throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
     }
   } else {
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: new Types.ObjectId(workspaceId)
-    });
-  
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
     ForbiddenError.from(permission).throwUnlessCan(
       ProjectPermissionActions.Edit,
       subject(ProjectPermissionSub.Secrets, { environment, secretPath: directory })
@@ -411,16 +387,15 @@ export const updateFolderById = async (req: Request, res: Response) => {
  */
 export const deleteFolder = async (req: Request, res: Response) => {
   /* 
-    #swagger.summary = 'Delete folder'
-    #swagger.description = 'Delete folder'
+    #swagger.summary = 'Delete a folder by ID'
+    #swagger.description = 'Delete the specified folder from a specified workspace and environment using its ID'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
-    #swagger.parameters['folderName'] = {
-        "description": "Name of folder to delete",
+    #swagger.parameters['folderId'] = {
+        "description": "ID of the folder to be deleted",
         "required": true,
         "type": "string",
         "in": "path"
@@ -434,18 +409,13 @@ export const deleteFolder = async (req: Request, res: Response) => {
                     "properties": {
                         "workspaceId": {
                             "type": "string",
-                            "description": "ID of the workspace where to delete folder",
+                            "description": "ID of the workspace where the folder is located",
                             "example": "someWorkspaceId"
                         },
                         "environment": {
                             "type": "string",
-                            "description": "Slug of environment where to delete folder",
+                            "description": "Environment where the folder is located",
                             "example": "production"
-                        },
-                        "directory": {
-                            "type": "string",
-                            "description": "Path where to delete folder like / or /foo/bar. Default is /",
-                            "example": "/foo/bar"
                         }
                     },
                     "required": ["workspaceId", "environment"]
@@ -462,7 +432,6 @@ export const deleteFolder = async (req: Request, res: Response) => {
                     "properties": {
                         "message": {
                             "type": "string",
-                            "description": "Success message",
                             "example": "successfully deleted folders"
                         },
                         "folders": {
@@ -472,17 +441,15 @@ export const deleteFolder = async (req: Request, res: Response) => {
                                 "properties": {
                                     "id": {
                                         "type": "string",
-                                        "description": "ID of deleted folder",
-                                        "example": "abc123"
+                                        "example": "someFolderId"
                                     },
                                     "name": {
                                         "type": "string",
-                                        "description": "Name of deleted folder",
                                         "example": "someFolderName"
                                     }
                                 }
                             },
-                            "description": "List of IDs and names of deleted folders"
+                            "description": "List of IDs and names of the deleted folders"
                         }
                     }
                 }
@@ -510,11 +477,7 @@ export const deleteFolder = async (req: Request, res: Response) => {
     }
   } else {
     // check that user is a member of the workspace
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: new Types.ObjectId(workspaceId)
-    });
-
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
     ForbiddenError.from(permission).throwUnlessCan(
       ProjectPermissionActions.Delete,
       subject(ProjectPermissionSub.Secrets, { environment, secretPath: directory })
@@ -577,37 +540,43 @@ export const deleteFolder = async (req: Request, res: Response) => {
 
 /**
  * Get folders for workspace with id [workspaceId] and environment [environment]
- * considering directory/path [directory]
+ * considering [parentFolderId] and [parentFolderPath]
  * @param req
  * @param res
  * @returns
  */
 export const getFolders = async (req: Request, res: Response) => {
   /*
-    #swagger.summary = 'Get folders'
-    #swagger.description = 'Get folders'
+    #swagger.summary = 'Retrieve folders based on specific conditions'
+    #swagger.description = 'Fetches folders from the specified workspace and environment, optionally providing either a parentFolderId or a parentFolderPath to narrow down results'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
     #swagger.parameters['workspaceId'] = {
-        "description": "ID of the workspace where to get folders from",
+        "description": "ID of the workspace from which the folders are to be fetched",
         "required": true,
         "type": "string",
         "in": "query"
     }
 
     #swagger.parameters['environment'] = {
-        "description": "Slug of environment where to get folders from",
+        "description": "Environment where the folder is located",
         "required": true,
         "type": "string",
         "in": "query"
     }
 
-    #swagger.parameters['directory'] = {
-        "description": "Path where to get fodlers from like / or /foo/bar. Default is /",
+    #swagger.parameters['parentFolderId'] = {
+        "description": "ID of the parent folder",
+        "required": false,
+        "type": "string",
+        "in": "query"
+    }
+
+    #swagger.parameters['parentFolderPath'] = {
+        "description": "Path of the parent folder, like /folder1/folder2",
         "required": false,
         "type": "string",
         "in": "query"
@@ -635,6 +604,23 @@ export const getFolders = async (req: Request, res: Response) => {
                                 }
                             },
                             "description": "List of folders"
+                        },
+                        "dir": {
+                            "type": "array",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "name": {
+                                        "type": "string",
+                                        "example": "parentFolderName"
+                                    },
+                                    "id": {
+                                        "type": "string",
+                                        "example": "parentFolderId"
+                                    }
+                                }
+                            },
+                            "description": "List of directories"
                         }
                     }
                 }
@@ -661,10 +647,7 @@ export const getFolders = async (req: Request, res: Response) => {
     }
   } else {
     // check that user is a member of the workspace
-    await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: new Types.ObjectId(workspaceId)
-    });
+    await getUserProjectPermissions(req.user._id, workspaceId);
   }
 
   const folders = await Folder.findOne({ workspace: workspaceId, environment });

backend/src/controllers/v1/signupController.ts

@@ -2,8 +2,10 @@ import { Request, Response } from "express";
 import { AuthMethod, User } from "../../models";
 import { checkEmailVerification, sendEmailVerification } from "../../helpers/signup";
 import { createToken } from "../../helpers/auth";
+import { BadRequestError } from "../../utils/errors";
 import {
   getAuthSecret,
+  getInviteOnlySignup,
   getJwtSignupLifetime,
   getSmtpConfigured
 } from "../../config";
@@ -66,6 +68,16 @@ export const verifyEmailSignup = async (req: Request, res: Response) => {
     });
   }
 
+  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({});
+    if (userCount != 0) {
+      throw BadRequestError({
+        message: "New user sign ups are not allowed at this time. You must be invited to sign up."
+      });
+    }
+  }
+
   // verify email
   if (await getSmtpConfigured()) {
     await checkEmailVerification({

backend/src/controllers/v1/webhookController.ts

@@ -1,36 +1,27 @@
 import { Request, Response } from "express";
 import { Types } from "mongoose";
-import { client, getEncryptionKey, getRootEncryptionKey } from "../../config";
+import { client, getRootEncryptionKey } from "../../config";
 import { Webhook } from "../../models";
 import { getWebhookPayload, triggerWebhookRequest } from "../../services/WebhookService";
 import { BadRequestError, ResourceNotFoundError } from "../../utils/errors";
 import { EEAuditLogService } from "../../ee/services";
 import { EventType } from "../../ee/models";
-import {
-  ALGORITHM_AES_256_GCM,
-  ENCODING_SCHEME_BASE64,
-  ENCODING_SCHEME_UTF8
-} from "../../variables";
+import { ALGORITHM_AES_256_GCM, ENCODING_SCHEME_BASE64 } from "../../variables";
 import { validateRequest } from "../../helpers/validation";
 import * as reqValidator from "../../validation/webhooks";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import { ForbiddenError } from "@casl/ability";
-import { encryptSymmetric128BitHexKeyUTF8 } from "../../utils/crypto";
 
 export const createWebhook = async (req: Request, res: Response) => {
   const {
     body: { webhookUrl, webhookSecretKey, environment, workspaceId, secretPath }
   } = await validateRequest(reqValidator.CreateWebhookV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.Webhooks
@@ -40,31 +31,17 @@ export const createWebhook = async (req: Request, res: Response) => {
     workspace: workspaceId,
     environment,
     secretPath,
-    url: webhookUrl
+    url: webhookUrl,
+    algorithm: ALGORITHM_AES_256_GCM,
+    keyEncoding: ENCODING_SCHEME_BASE64
   });
 
   if (webhookSecretKey) {
-    const encryptionKey = await getEncryptionKey();
     const rootEncryptionKey = await getRootEncryptionKey();
-
-    if (rootEncryptionKey) {
-      const { ciphertext, iv, tag } = client.encryptSymmetric(webhookSecretKey, rootEncryptionKey);
-      webhook.iv = iv;
-      webhook.tag = tag;
-      webhook.encryptedSecretKey = ciphertext;
-      webhook.algorithm = ALGORITHM_AES_256_GCM;
-      webhook.keyEncoding = ENCODING_SCHEME_BASE64;
-    } else if (encryptionKey) {
-      const { ciphertext, iv, tag } = encryptSymmetric128BitHexKeyUTF8({
-        plaintext: webhookSecretKey,
-        key: encryptionKey
-      });
-      webhook.iv = iv;
-      webhook.tag = tag;
-      webhook.encryptedSecretKey = ciphertext;
-      webhook.algorithm = ALGORITHM_AES_256_GCM;
-      webhook.keyEncoding = ENCODING_SCHEME_UTF8;
-    }
+    const { ciphertext, iv, tag } = client.encryptSymmetric(webhookSecretKey, rootEncryptionKey);
+    webhook.iv = iv;
+    webhook.tag = tag;
+    webhook.encryptedSecretKey = ciphertext;
   }
 
   await webhook.save();
@@ -102,11 +79,11 @@ export const updateWebhook = async (req: Request, res: Response) => {
   if (!webhook) {
     throw BadRequestError({ message: "Webhook not found!!" });
   }
-  
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: webhook.workspace
-  });
+
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    webhook.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.Webhooks
@@ -150,11 +127,10 @@ export const deleteWebhook = async (req: Request, res: Response) => {
     throw ResourceNotFoundError({ message: "Webhook not found!!" });
   }
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: webhook.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    webhook.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Delete,
     ProjectPermissionSub.Webhooks
@@ -198,11 +174,10 @@ export const testWebhook = async (req: Request, res: Response) => {
     throw BadRequestError({ message: "Webhook not found!!" });
   }
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: webhook.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    webhook.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Webhooks
@@ -242,12 +217,8 @@ export const listWebhooks = async (req: Request, res: Response) => {
   const {
     query: { environment, workspaceId, secretPath }
   } = await validateRequest(reqValidator.ListWebhooksV1, req);
-  
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
+
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Webhooks

backend/src/controllers/v1/workspaceController.ts

@@ -17,7 +17,7 @@ import { OrganizationNotFoundError } from "../../utils/errors";
 import {
   OrgPermissionActions,
   OrgPermissionSubjects,
-  getAuthDataOrgPermissions
+  getUserOrgPermissions
 } from "../../ee/services/RoleService";
 import { ForbiddenError } from "@casl/ability";
 import { validateRequest } from "../../helpers/validation";
@@ -25,7 +25,7 @@ import * as reqValidator from "../../validation";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 
 /**
@@ -39,11 +39,7 @@ export const getWorkspacePublicKeys = async (req: Request, res: Response) => {
     params: { workspaceId }
   } = await validateRequest(reqValidator.GetWorkspacePublicKeysV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Member
@@ -76,11 +72,7 @@ export const getWorkspaceMemberships = async (req: Request, res: Response) => {
     params: { workspaceId }
   } = await validateRequest(reqValidator.GetWorkspaceMembershipsV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Member
@@ -152,10 +144,7 @@ export const createWorkspace = async (req: Request, res: Response) => {
     });
   }
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Create,
     OrgPermissionSubjects.Workspace
@@ -206,11 +195,7 @@ export const deleteWorkspace = async (req: Request, res: Response) => {
     params: { workspaceId }
   } = await validateRequest(reqValidator.DeleteWorkspaceV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Delete,
     ProjectPermissionSub.Workspace
@@ -238,11 +223,7 @@ export const changeWorkspaceName = async (req: Request, res: Response) => {
     body: { name }
   } = await validateRequest(reqValidator.ChangeWorkspaceNameV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.Workspace
@@ -276,12 +257,7 @@ export const getWorkspaceIntegrations = async (req: Request, res: Response) => {
   const {
     params: { workspaceId }
   } = await validateRequest(reqValidator.GetWorkspaceIntegrationsV1, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -307,11 +283,7 @@ export const getWorkspaceIntegrationAuthorizations = async (req: Request, res: R
     params: { workspaceId }
   } = await validateRequest(reqValidator.GetWorkspaceIntegrationAuthorizationsV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Integrations
@@ -337,11 +309,7 @@ export const getWorkspaceServiceTokens = async (req: Request, res: Response) =>
     params: { workspaceId }
   } = await validateRequest(reqValidator.GetWorkspaceServiceTokensV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.ServiceTokens

backend/src/controllers/v2/authController.ts

@@ -8,8 +8,10 @@ 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 { AuthTokenType, TOKEN_EMAIL_MFA } from "../../variables";
+import { ACTION_LOGIN, AuthTokenType, TOKEN_EMAIL_MFA } from "../../variables";
+import { getUserAgentType } from "../../utils/posthog"; // TODO: move this
 import { getAuthSecret, getHttpsEnabled, getJwtMfaLifetime } from "../../config";
 import { validateRequest } from "../../helpers/validation";
 import * as reqValidator from "../../validation/auth";
@@ -188,6 +190,19 @@ export const login2 = async (req: Request, res: Response) => {
           response.protectedKeyTag = user.protectedKeyTag;
         }
 
+        const loginAction = await EELogService.createAction({
+          name: ACTION_LOGIN,
+          userId: user._id
+        });
+
+        loginAction &&
+          (await EELogService.createLog({
+            userId: user._id,
+            actions: [loginAction],
+            channel: getUserAgentType(req.headers["user-agent"]),
+            ipAddress: req.ip
+          }));
+
         return res.status(200).send(response);
       }
 
@@ -204,16 +219,20 @@ export const login2 = async (req: Request, res: Response) => {
  * @param res
  */
 export const sendMfaToken = async (req: Request, res: Response) => {
+  const {
+    body: { email }
+  } = await validateRequest(reqValidator.SendMfaTokenV2, req);
+
   const code = await TokenService.createToken({
     type: TOKEN_EMAIL_MFA,
-    email: req.user.email
+    email
   });
 
   // send MFA code [code] to [email]
   await sendMail({
     template: "emailMfa.handlebars",
     subjectLine: "Infisical MFA code",
-    recipients: [req.user.email],
+    recipients: [email],
     substitutions: {
       code
     }
@@ -232,17 +251,17 @@ export const sendMfaToken = async (req: Request, res: Response) => {
  */
 export const verifyMfaToken = async (req: Request, res: Response) => {
   const {
-    body: { mfaToken }
+    body: { email, mfaToken }
   } = await validateRequest(reqValidator.VerifyMfaTokenV2, req);
 
   await TokenService.validateToken({
     type: TOKEN_EMAIL_MFA,
-    email: req.user.email,
+    email,
     token: mfaToken
   });
 
   const user = await User.findOne({
-    email: req.user.email
+    email
   }).select(
     "+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag +devices"
   );
@@ -311,5 +330,18 @@ export const verifyMfaToken = async (req: Request, res: Response) => {
     resObj.protectedKeyTag = user.protectedKeyTag;
   }
 
+  const loginAction = await EELogService.createAction({
+    name: ACTION_LOGIN,
+    userId: user._id
+  });
+
+  loginAction &&
+    (await EELogService.createLog({
+      userId: user._id,
+      actions: [loginAction],
+      channel: getUserAgentType(req.headers["user-agent"]),
+      ipAddress: req.realIP
+    }));
+
   return res.status(200).send(resObj);
 };

backend/src/controllers/v2/environmentController.ts

@@ -12,15 +12,18 @@ import {
 import { EventType, SecretVersion } from "../../ee/models";
 import { EEAuditLogService, EELicenseService } from "../../ee/services";
 import { BadRequestError, WorkspaceNotFoundError } from "../../utils/errors";
+import _ from "lodash";
+import { PERMISSION_READ_SECRETS, PERMISSION_WRITE_SECRETS } from "../../variables";
 import { validateRequest } from "../../helpers/validation";
 import * as reqValidator from "../../validation/environments";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import { ForbiddenError } from "@casl/ability";
 import { SecretImport } from "../../models";
+import { ServiceAccountWorkspacePermission } from "../../models";
 import { Webhook } from "../../models";
 
 /**
@@ -36,16 +39,29 @@ export const createWorkspaceEnvironment = async (req: Request, res: Response) =>
     #swagger.description = 'Create environment'
 
     #swagger.security = [{
-        "apiKeyAuth": [],
+        "apiKeyAuth": []
     }]
 
 	#swagger.parameters['workspaceId'] = {
-		"description": "ID of workspace where to create environment",
+		"description": "ID of project",
 		"required": true,
-		"type": "string",
-    "in": "path"
+		"type": "string"
 	}
-  
+
+  /*
+    #swagger.summary = 'Create environment'
+    #swagger.description = 'Create environment'
+
+    #swagger.security = [{
+        "apiKeyAuth": []
+    }]
+
+	#swagger.parameters['workspaceId'] = {
+		"description": "ID of project",
+		"required": true,
+		"type": "string"
+	}
+
   #swagger.requestBody = {
       content: {
           "application/json": {
@@ -54,12 +70,12 @@ export const createWorkspaceEnvironment = async (req: Request, res: Response) =>
                   "properties": {
                       "environmentName": {
                           "type": "string",
-                          "description": "Name of the environment to create",
+                          "description": "Name of the environment",
                           "example": "development"
                       },
                       "environmentSlug": {
                           "type": "string",
-                          "description": "Slug of environment to create",
+                          "description": "Slug of the environment",
                           "example": "dev-environment"
                       }
                   },
@@ -70,53 +86,45 @@ export const createWorkspaceEnvironment = async (req: Request, res: Response) =>
   }
 
   #swagger.responses[200] = {
-        content: {
-            "application/json": {
-                "schema": {
-                    "type": "object",
-                    "properties": {
-                        "message": {
-                            "type": "string",
-                            "description": "Sucess message",
-                            "example": "Successfully created environment"
-                        },
-                        "workspace": {
-                            "type": "string",
-                            "description": "ID of workspace where environment was created",
-                            "example": "abc123"
-                        },
-                        "environment": {
-                            "type": "object",
-                            "properties": {
-                                "name": {
-                                    "type": "string",
-                                    "description": "Name of created environment",
-                                    "example": "Staging"
-                                },
-                                "slug": {
-                                    "type": "string",
-                                    "description": "Slug of created environment",
-                                    "example": "staging"
-                                }
-                            }
-                        }
-                    },
-                    "description": "Details of the created environment"
-                }
-            }
-        }
-    }
+      content: {
+          "application/json": {
+              "schema": {
+                  "type": "object",
+                  "properties": {
+                      "message": {
+                          "type": "string",
+                          "example": "Successfully created new environment"
+                      },
+                      "workspace": {
+                          "type": "string",
+                          "example": "someWorkspaceId"
+                      },
+                      "environment": {
+                          "type": "object",
+                          "properties": {
+                              "name": {
+                                  "type": "string",
+                                  "example": "someEnvironmentName"
+                              },
+                              "slug": {
+                                  "type": "string",
+                                  "example": "someEnvironmentSlug"
+                              }
+                          }
+                      }
+                  },
+                  "description": "Response after creating a new environment"
+              }
+          }
+      }
+  }
   */
   const {
     params: { workspaceId },
     body: { environmentName, environmentSlug }
   } = await validateRequest(reqValidator.CreateWorkspaceEnvironmentV2, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.Environments
@@ -193,11 +201,7 @@ export const reorderWorkspaceEnvironments = async (req: Request, res: Response)
     body: { environmentName, environmentSlug, otherEnvironmentSlug, otherEnvironmentName }
   } = await validateRequest(reqValidator.ReorderWorkspaceEnvironmentsV2, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.Environments
@@ -243,19 +247,15 @@ export const reorderWorkspaceEnvironments = async (req: Request, res: Response)
  */
 export const renameWorkspaceEnvironment = async (req: Request, res: Response) => {
   /*
-    #swagger.summary = 'Update environment'
-    #swagger.description = 'Update environment'
-
-    #swagger.security = [{
-        "apiKeyAuth": [],
-    }]
+    #swagger.summary = 'Rename workspace environment'
+    #swagger.description = 'Rename a specific environment within a workspace'
 
     #swagger.parameters['workspaceId'] = {
-      "description": "ID of workspace where to update environment",
-      "required": true,
-      "type": "string",
-      "in": "path"
-    }
+    "description": "ID of the workspace",
+    "required": true,
+    "type": "string",
+        "in": "path"
+  }
 
     #swagger.requestBody = {
         content: {
@@ -265,17 +265,17 @@ export const renameWorkspaceEnvironment = async (req: Request, res: Response) =>
                     "properties": {
                         "environmentName": {
                             "type": "string",
-                            "description": "Name of environment to update to",
+                            "description": "New name for the environment",
                             "example": "Staging-Renamed"
                         },
                         "environmentSlug": {
                             "type": "string",
-                            "description": "Slug of environment to update to",
+                            "description": "New slug for the environment",
                             "example": "staging-renamed"
                         },
                         "oldEnvironmentSlug": {
                             "type": "string",
-                            "description": "Current slug of environment",
+                            "description": "Current slug of the environment to rename",
                             "example": "staging-old"
                         }
                     },
@@ -293,25 +293,21 @@ export const renameWorkspaceEnvironment = async (req: Request, res: Response) =>
                     "properties": {
                         "message": {
                             "type": "string",
-                            "description": "Success message",
                             "example": "Successfully update environment"
                         },
                         "workspace": {
                             "type": "string",
-                            "description": "ID of workspace where environment was updated",
-                            "example": "abc123"
+                            "example": "someWorkspaceId"
                         },
                         "environment": {
                             "type": "object",
                             "properties": {
                                 "name": {
                                     "type": "string",
-                                    "description": "Name of updated environment",
                                     "example": "Staging-Renamed"
                                 },
                                 "slug": {
                                     "type": "string",
-                                    "description": "Slug of updated environment",
                                     "example": "staging-renamed"
                                 }
                             }
@@ -328,11 +324,7 @@ export const renameWorkspaceEnvironment = async (req: Request, res: Response) =>
     body: { environmentName, environmentSlug, oldEnvironmentSlug }
   } = await validateRequest(reqValidator.UpdateWorkspaceEnvironmentV2, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.Environments
@@ -408,6 +400,11 @@ export const renameWorkspaceEnvironment = async (req: Request, res: Response) =>
     { arrayFilters: [{ "element.environment": oldEnvironmentSlug }] },
   );
 
+  await ServiceAccountWorkspacePermission.updateMany(
+    { workspace: workspaceId, environment: oldEnvironmentSlug },
+    { environment: environmentSlug }
+  );
+
   await Webhook.updateMany(
     { workspace: workspaceId, environment: oldEnvironmentSlug },
     { environment: environmentSlug }
@@ -456,19 +453,19 @@ export const renameWorkspaceEnvironment = async (req: Request, res: Response) =>
  */
 export const deleteWorkspaceEnvironment = async (req: Request, res: Response) => {
   /*
-    #swagger.summary = 'Delete environment'
-    #swagger.description = 'Delete environment'
+    #swagger.summary = 'Delete workspace environment'
+    #swagger.description = 'Delete a specific environment from a workspace'
 
     #swagger.security = [{
         "apiKeyAuth": []
     }]
 
     #swagger.parameters['workspaceId'] = {
-      "description": "ID of workspace where to delete environment",
-      "required": true,
-      "type": "string",
-      "in": "path"
-	  }
+		"description": "ID of the workspace",
+		"required": true,
+		"type": "string",
+        "in": "path"
+	}
 
     #swagger.requestBody = {
         content: {
@@ -478,8 +475,8 @@ export const deleteWorkspaceEnvironment = async (req: Request, res: Response) =>
                     "properties": {
                         "environmentSlug": {
                             "type": "string",
-                            "description": "Slug of environment to delete",
-                            "example": "dev"
+                            "description": "Slug of the environment to delete",
+                            "example": "dev-environment"
                         }
                     },
                     "required": ["environmentSlug"]
@@ -496,18 +493,15 @@ export const deleteWorkspaceEnvironment = async (req: Request, res: Response) =>
                     "properties": {
                         "message": {
                             "type": "string",
-                            "description": "Success message",
                             "example": "Successfully deleted environment"
                         },
                         "workspace": {
                             "type": "string",
-                            "description": "ID of workspace where environment was deleted",
-                            "example": "abc123"
+                            "example": "someWorkspaceId"
                         },
                         "environment": {
                             "type": "string",
-                            "description": "Slug of deleted environment",
-                            "example": "dev"
+                            "example": "dev-environment"
                         }
                     },
                     "description": "Response after deleting an environment from a workspace"
@@ -521,11 +515,7 @@ export const deleteWorkspaceEnvironment = async (req: Request, res: Response) =>
     body: { environmentSlug }
   } = await validateRequest(reqValidator.DeleteWorkspaceEnvironmentV2, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Delete,
     ProjectPermissionSub.Environments
@@ -601,4 +591,98 @@ export const deleteWorkspaceEnvironment = async (req: Request, res: Response) =>
     workspace: workspaceId,
     environment: environmentSlug
   });
-};
+};
+
+// TODO(akhilmhdh) after rbac this can be completely removed
+export const getAllAccessibleEnvironmentsOfWorkspace = async (req: Request, res: Response) => {
+  /*
+    #swagger.summary = 'Get all accessible environments of a workspace'
+    #swagger.description = 'Fetch all environments that the user has access to in a specified workspace'
+
+    #swagger.security = [{
+        "apiKeyAuth": []
+    }]
+
+    #swagger.parameters['workspaceId'] = {
+		"description": "ID of the workspace",
+		"required": true,
+		"type": "string",
+        "in": "path"
+	}
+
+    #swagger.responses[200] = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "accessibleEnvironments": {
+                            "type": "array",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "name": {
+                                        "type": "string",
+                                        "example": "Development"
+                                    },
+                                    "slug": {
+                                        "type": "string",
+                                        "example": "development"
+                                    },
+                                    "isWriteDenied": {
+                                        "type": "boolean",
+                                        "example": false
+                                    },
+                                    "isReadDenied": {
+                                        "type": "boolean",
+                                        "example": false
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "description": "List of environments the user has access to in the specified workspace"
+                }
+            }
+        }
+    }
+  */
+  const {
+    params: { workspaceId }
+  } = await validateRequest(reqValidator.GetAllAccessibileEnvironmentsOfWorkspaceV2, req);
+
+  const { membership: workspacesUserIsMemberOf } = await getUserProjectPermissions(
+    req.user._id,
+    workspaceId
+  );
+
+  const accessibleEnvironments: any = [];
+  const deniedPermission = workspacesUserIsMemberOf.deniedPermissions;
+
+  const relatedWorkspace = await Workspace.findById(workspaceId);
+  if (!relatedWorkspace) {
+    throw BadRequestError();
+  }
+  relatedWorkspace.environments.forEach((environment) => {
+    const isReadBlocked = _.some(deniedPermission, {
+      environmentSlug: environment.slug,
+      ability: PERMISSION_READ_SECRETS
+    });
+    const isWriteBlocked = _.some(deniedPermission, {
+      environmentSlug: environment.slug,
+      ability: PERMISSION_WRITE_SECRETS
+    });
+    if (isReadBlocked && isWriteBlocked) {
+      return;
+    } else {
+      accessibleEnvironments.push({
+        name: environment.name,
+        slug: environment.slug,
+        isWriteDenied: isWriteBlocked,
+        isReadDenied: isReadBlocked
+      });
+    }
+  });
+
+  res.json({ accessibleEnvironments });
+};

backend/src/controllers/v2/index.ts

@@ -6,20 +6,20 @@ import * as workspaceController from "./workspaceController";
 import * as serviceTokenDataController from "./serviceTokenDataController";
 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 membershipController from "./membershipController";
 
 export {
-  authController,
-  signupController,
-  usersController,
-  organizationsController,
-  workspaceController,
-  serviceTokenDataController,
-  secretController,
-  secretsController,
-  environmentController,
-  tagController,
-  membershipController
-};
+    authController,
+    signupController,
+    usersController,
+    organizationsController,
+    workspaceController,
+    serviceTokenDataController,
+    secretController,
+    secretsController,
+    serviceAccountsController,
+    environmentController,
+    tagController,
+}

backend/src/controllers/v2/membershipController.ts

@@ -1,107 +0,0 @@
-import { ForbiddenError } from "@casl/ability";
-import { Request, Response } from "express";
-import { Types } from "mongoose";
-
-import { getSiteURL } from "../../config";
-import { EventType } from "../../ee/models";
-import { EEAuditLogService } from "../../ee/services";
-import {
-  ProjectPermissionActions,
-  ProjectPermissionSub,
-  getAuthDataProjectPermissions
-} from "../../ee/services/ProjectRoleService";
-import { sendMail } from "../../helpers";
-import { validateRequest } from "../../helpers/validation";
-import { IUser, Key, Membership, MembershipOrg, Workspace } from "../../models";
-import { BadRequestError } from "../../utils/errors";
-import * as reqValidator from "../../validation/membership";
-import { ACCEPTED, MEMBER } from "../../variables";
-
-export const addUserToWorkspace = async (req: Request, res: Response) => {
-  const {
-    params: { workspaceId },
-    body: { members }
-  } = await validateRequest(reqValidator.AddUserToWorkspaceV2, req);
-  // check workspace
-  const workspace = await Workspace.findById(workspaceId);
-  if (!workspace) throw new Error("Failed to find workspace");
-
-  // check permission
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Create,
-    ProjectPermissionSub.Member
-  );
-
-  // validate members are part of the organization
-  const orgMembers = await MembershipOrg.find({
-    status: ACCEPTED,
-    _id: { $in: members.map(({ orgMembershipId }) => orgMembershipId) },
-    organization: workspace.organization
-  })
-    .populate<{ user: IUser }>("user")
-    .select({ _id: 1, user: 1 })
-    .lean();
-  if (orgMembers.length !== members.length)
-    throw BadRequestError({ message: "Org member not found" });
-
-  const existingMember = await Membership.find({
-    workspace: workspaceId,
-    user: { $in: orgMembers.map(({ user }) => user) }
-  });
-  if (existingMember?.length)
-    throw BadRequestError({ message: "Some users are already part of workspace" });
-
-  await Membership.insertMany(
-    orgMembers.map(({ user }) => ({ user: user._id, workspace: workspaceId, role: MEMBER }))
-  );
-
-  const encKeyGroupedByOrgMemberId = members.reduce<Record<string, (typeof members)[number]>>(
-    (prev, curr) => ({ ...prev, [curr.orgMembershipId]: curr }),
-    {}
-  );
-  await Key.insertMany(
-    orgMembers.map(({ user, _id: id }) => ({
-      encryptedKey: encKeyGroupedByOrgMemberId[id.toString()].workspaceEncryptedKey,
-      nonce: encKeyGroupedByOrgMemberId[id.toString()].workspaceEncryptedNonce,
-      sender: req.user._id,
-      receiver: user._id,
-      workspace: workspaceId
-    }))
-  );
-
-  await sendMail({
-    template: "workspaceInvitation.handlebars",
-    subjectLine: "Infisical workspace invitation",
-    recipients: orgMembers.map(({ user }) => user.email),
-    substitutions: {
-      inviterFirstName: req.user.firstName,
-      inviterEmail: req.user.email,
-      workspaceName: workspace.name,
-      callback_url: (await getSiteURL()) + "/login"
-    }
-  });
-
-  await EEAuditLogService.createAuditLog(
-    req.authData,
-    {
-      type: EventType.ADD_BATCH_WORKSPACE_MEMBER,
-      metadata: orgMembers.map(({ user }) => ({
-        userId: user._id.toString(),
-        email: user.email
-      }))
-    },
-    {
-      workspaceId: new Types.ObjectId(workspaceId)
-    }
-  );
-
-  return res.status(200).send({
-    success: true,
-    data: orgMembers
-  });
-};

backend/src/controllers/v2/organizationsController.ts

@@ -1,33 +1,32 @@
 import { Request, Response } from "express";
 import { Types } from "mongoose";
 import { 
-  IWorkspace,
-  Identity,
-  IdentityMembership,
-  IdentityMembershipOrg, 
-  Membership,
-  MembershipOrg,
-  User,
-  Workspace
+  Membership, 
+  MembershipOrg, 
+  ServiceAccount, 
+  Workspace 
 } from "../../models";
 import { Role } from "../../ee/models";
 import { deleteMembershipOrg } from "../../helpers/membershipOrg";
-import {
+import { 
   createOrganization as create,
   deleteOrganization,
   updateSubscriptionOrgQuantity
 } from "../../helpers/organization";
 import { addMembershipsOrg } from "../../helpers/membershipOrg";
-import { BadRequestError, ResourceNotFoundError, UnauthorizedRequestError } from "../../utils/errors";
-import { ACCEPTED, ADMIN, CUSTOM, MEMBER, NO_ACCESS } from "../../variables";
+import { BadRequestError, UnauthorizedRequestError } from "../../utils/errors";
+import {
+  ACCEPTED,
+  ADMIN,
+  CUSTOM 
+} from "../../variables";
 import * as reqValidator from "../../validation/organization";
 import { validateRequest } from "../../helpers/validation";
 import {
   OrgPermissionActions,
   OrgPermissionSubjects,
-  getAuthDataOrgPermissions
+  getUserOrgPermissions
 } from "../../ee/services/RoleService";
-import { EELicenseService } from "../../ee/services";
 import { ForbiddenError } from "@casl/ability";
 
 /**
@@ -37,12 +36,11 @@ import { ForbiddenError } from "@casl/ability";
  */
 export const getOrganizationMemberships = async (req: Request, res: Response) => {
   /* 
-    #swagger.summary = 'Return organization user memberships'
-    #swagger.description = 'Return organization user memberships'
+    #swagger.summary = 'Return organization memberships'
+    #swagger.description = 'Return organization memberships'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
 	#swagger.parameters['organizationId'] = {
@@ -74,10 +72,7 @@ export const getOrganizationMemberships = async (req: Request, res: Response) =>
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgMembersv2, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Member
@@ -99,12 +94,11 @@ export const getOrganizationMemberships = async (req: Request, res: Response) =>
  */
 export const updateOrganizationMembership = async (req: Request, res: Response) => {
   /* 
-    #swagger.summary = 'Update organization user membership'
-    #swagger.description = 'Update organization user membership'
+    #swagger.summary = 'Update organization membership'
+    #swagger.description = 'Update organization membership'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
 	#swagger.parameters['organizationId'] = {
@@ -156,32 +150,16 @@ export const updateOrganizationMembership = async (req: Request, res: Response)
     params: { organizationId, membershipId },
     body: { role }
   } = await validateRequest(reqValidator.UpdateOrgMemberv2, req);
-
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Edit,
     OrgPermissionSubjects.Member
   );
 
-  const isCustomRole = ![ADMIN, MEMBER, NO_ACCESS].includes(role);
+  const isCustomRole = !["admin", "member", "owner"].includes(role);
   if (isCustomRole) {
-    const orgRole = await Role.findOne({ 
-      slug: role, 
-      isOrgRole: true,
-      organization: new Types.ObjectId(organizationId)
-    });
-
+    const orgRole = await Role.findOne({ slug: role, isOrgRole: true });
     if (!orgRole) throw BadRequestError({ message: "Role not found" });
-    
-    const plan = await EELicenseService.getPlan(new Types.ObjectId(organizationId));
-    
-    if (!plan.rbac) return res.status(400).send({
-      message:
-        "Failed to assign custom role due to RBAC restriction. Upgrade plan to assign custom role to member."
-    });
 
     const membership = await MembershipOrg.findByIdAndUpdate(membershipId, {
       role: CUSTOM,
@@ -220,12 +198,11 @@ export const updateOrganizationMembership = async (req: Request, res: Response)
  */
 export const deleteOrganizationMembership = async (req: Request, res: Response) => {
   /* 
-    #swagger.summary = 'Delete organization user membership'
-    #swagger.description = 'Delete organization user membership'
+    #swagger.summary = 'Delete organization membership'
+    #swagger.description = 'Delete organization membership'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
 	#swagger.parameters['organizationId'] = {
@@ -259,18 +236,7 @@ export const deleteOrganizationMembership = async (req: Request, res: Response)
   const {
     params: { organizationId, membershipId }
   } = await validateRequest(reqValidator.DeleteOrgMemberv2, req);
-  
-  const membershipOrg = await MembershipOrg.findOne({
-    _id: new Types.ObjectId(membershipId),
-    organization: new Types.ObjectId(organizationId)
-  });
-  
-  if (!membershipOrg) throw ResourceNotFoundError();
-  
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: membershipOrg.organization
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Delete,
     OrgPermissionSubjects.Member
@@ -302,8 +268,7 @@ export const getOrganizationWorkspaces = async (req: Request, res: Response) =>
     #swagger.description = 'Return projects in organization that user is part of'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
 	#swagger.parameters['organizationId'] = {
@@ -331,16 +296,11 @@ export const getOrganizationWorkspaces = async (req: Request, res: Response) =>
         }
     }   
     */
-  
   const {
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgWorkspacesv2, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
-
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Workspace
@@ -357,33 +317,36 @@ export const getOrganizationWorkspaces = async (req: Request, res: Response) =>
     ).map((w) => w._id.toString())
   );
 
-  let workspaces: IWorkspace[] = [];
-  
-  if (req.authData.authPayload instanceof Identity) {
-    workspaces = (
-      await IdentityMembership.find({
-        identity: req.authData.authPayload._id
-      }).populate<{ workspace: IWorkspace }>("workspace")
-    )
-      .filter((m) => workspacesSet.has(m.workspace._id.toString()))
-      .map((m) => m.workspace);
-  }
-  
-  if (req.authData.authPayload instanceof User) {
-    workspaces = (
-      await Membership.find({
-        user: req.authData.authPayload._id
-      }).populate<{ workspace: IWorkspace }>("workspace")
-    )
-      .filter((m) => workspacesSet.has(m.workspace._id.toString()))
-      .map((m) => m.workspace);
-  }
+  const workspaces = (
+    await Membership.find({
+      user: req.user._id
+    }).populate("workspace")
+  )
+    .filter((m) => workspacesSet.has(m.workspace._id.toString()))
+    .map((m) => m.workspace);
 
   return res.status(200).send({
     workspaces
   });
 };
 
+/**
+ * Return service accounts for organization with id [organizationId]
+ * @param req
+ * @param res
+ */
+export const getOrganizationServiceAccounts = async (req: Request, res: Response) => {
+  const { organizationId } = req.params;
+
+  const serviceAccounts = await ServiceAccount.find({
+    organization: new Types.ObjectId(organizationId)
+  });
+
+  return res.status(200).send({
+    serviceAccounts
+  });
+};
+
 /**
  * Create new organization named [organizationName]
  * and add user as owner
@@ -391,7 +354,7 @@ export const getOrganizationWorkspaces = async (req: Request, res: Response) =>
  * @param res
  * @returns
  */
-export const createOrganization = async (req: Request, res: Response) => {
+ export const createOrganization = async (req: Request, res: Response) => {
   const {
     body: { name }
   } = await validateRequest(reqValidator.CreateOrgv2, req);
@@ -416,90 +379,27 @@ export const createOrganization = async (req: Request, res: Response) => {
 
 /**
  * Delete organization with id [organizationId]
- * @param req
- * @param res
+ * @param req 
+ * @param res 
  */
 export const deleteOrganizationById = async (req: Request, res: Response) => {
   const {
     params: { organizationId }
   } = await validateRequest(reqValidator.DeleteOrgv2, req);
-
+  
   const membershipOrg = await MembershipOrg.findOne({
     user: req.user._id,
     organization: new Types.ObjectId(organizationId),
     role: ADMIN
   });
-
+  
   if (!membershipOrg) throw UnauthorizedRequestError();
-
+  
   const organization = await deleteOrganization({
     organizationId: new Types.ObjectId(organizationId)
   });
-
+  
   return res.status(200).send({
     organization
   });
-};
-
-/**
- * Return list of identity memberships for organization with id [organizationId]
- * @param req
- * @param res 
- * @returns 
- */
- export const getOrganizationIdentityMemberships = async (req: Request, res: Response) => {
-   /*
-    #swagger.summary = 'Return organization identity memberships'
-    #swagger.description = 'Return organization identity memberships'
-
-    #swagger.security = [{
-        "bearerAuth": []
-    }]
-    
-    #swagger.parameters['organizationId'] = {
-        "description": "ID of organization",
-        "required": true,
-        "type": "string",
-        "in": "path"
-    }
-
-    #swagger.responses[200] = {
-        content: {
-            "application/json": {
-              "schema": { 
-                "type": "object",
-                "properties": {
-                  "identityMemberships": {
-                    "type": "array",
-                    "items": {
-                      $ref: "#/components/schemas/IdentityMembershipOrg" 
-                    },
-                    "description": "Identity memberships of organization"
-                  }
-                }
-              }
-            }           
-        }
-    }
-  */
-  const {
-    params: { organizationId }
-  } = await validateRequest(reqValidator.GetOrgIdentityMembershipsV2, req);
-
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
-  ForbiddenError.from(permission).throwUnlessCan(
-    OrgPermissionActions.Read,
-    OrgPermissionSubjects.Identity
-  );
- 
-  const identityMemberships = await IdentityMembershipOrg.find({
-    organization: new Types.ObjectId(organizationId)
-  }).populate("identity customRole");
-  
-  return res.status(200).send({
-    identityMemberships
-  });
 }

backend/src/controllers/v2/secretController.ts

@@ -11,6 +11,7 @@ import {
   ValidationError as RouteValidationError,
   UnauthorizedRequestError
 } from "../../utils/errors";
+import { AnyBulkWriteOperation } from "mongodb";
 import {
   ALGORITHM_AES_256_GCM,
   ENCODING_SCHEME_UTF8,
@@ -18,7 +19,7 @@ import {
   SECRET_SHARED
 } from "../../variables";
 import { TelemetryService } from "../../services";
-import { Secret, User } from "../../models";
+import { ISecret, Secret, User } from "../../models";
 import { AccountNotFoundError } from "../../utils/errors";
 
 /**
@@ -144,22 +145,22 @@ export const deleteSecrets = async (req: Request, res: Response) => {
   const secretsUserCanDeleteSet: Set<string> = new Set(
     secretIdsUserCanDelete.map((objectId) => objectId._id.toString())
   );
+  const deleteOperationsToPerform: AnyBulkWriteOperation<ISecret>[] = [];
 
-  // Filter out IDs that user can delete and then map them to delete operations
-  const deleteOperationsToPerform = secretIdsToDelete
-    .filter(secretIdToDelete => {
-      if (!secretsUserCanDeleteSet.has(secretIdToDelete)) {
-        throw RouteValidationError({
-          message: "You cannot delete secrets that you do not have access to"
-        });
-      }
-      return true;
-    })
-    .map(secretIdToDelete => ({
-      deleteOne: { filter: { _id: new Types.ObjectId(secretIdToDelete) } }
-    }));
-
-  const numSecretsDeleted = deleteOperationsToPerform.length;
+  let numSecretsDeleted = 0;
+  secretIdsToDelete.forEach((secretIdToDelete) => {
+    if (secretsUserCanDeleteSet.has(secretIdToDelete)) {
+      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"
+      });
+    }
+  });
 
   await Secret.bulkWrite(deleteOperationsToPerform);
 

backend/src/controllers/v2/secretsController.ts

@@ -1,8 +1,12 @@
 import { Types } from "mongoose";
 import { Request, Response } from "express";
 import { Folder, ISecret, Secret, ServiceTokenData, Tag } from "../../models";
-import { AuditLog, EventType, SecretVersion } from "../../ee/models";
+import { AuditLog, EventType, IAction, SecretVersion } from "../../ee/models";
 import {
+  ACTION_ADD_SECRETS,
+  ACTION_DELETE_SECRETS,
+  ACTION_READ_SECRETS,
+  ACTION_UPDATE_SECRETS,
   ALGORITHM_AES_256_GCM,
   ENCODING_SCHEME_UTF8,
   K8_USER_AGENT_NAME,
@@ -11,7 +15,7 @@ import {
 import { BadRequestError, UnauthorizedRequestError } from "../../utils/errors";
 import { EventService } from "../../services";
 import { eventPushSecrets } from "../../events";
-import { EEAuditLogService, EESecretService } from "../../ee/services";
+import { EEAuditLogService, EELogService, EESecretService } from "../../ee/services";
 import { SecretService, TelemetryService } from "../../services";
 import { getUserAgentType } from "../../utils/posthog";
 import { PERMISSION_WRITE_SECRETS } from "../../variables";
@@ -39,7 +43,7 @@ import {
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import { ForbiddenError, subject } from "@casl/ability";
 
@@ -78,6 +82,7 @@ export const batchSecrets = async (req: Request, res: Response) => {
   const createSecrets: any[] = [];
   const updateSecrets: any[] = [];
   const deleteSecrets: { _id: Types.ObjectId; secretName: string }[] = [];
+  const actions: IAction[] = [];
 
   // get secret blind index salt
   const salt = await SecretService.getSecretBlindIndexSalt({
@@ -159,11 +164,7 @@ export const batchSecrets = async (req: Request, res: Response) => {
   }
   // not using service token  using auth
   if (!(req.authData.authPayload instanceof ServiceTokenData)) {
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: new Types.ObjectId(workspaceId)
-    });
-
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
     if (createSecrets.length)
       ForbiddenError.from(permission).throwUnlessCan(
         ProjectPermissionActions.Create,
@@ -223,6 +224,16 @@ export const batchSecrets = async (req: Request, res: Response) => {
 
     await AuditLog.insertMany(auditLogs);
 
+    const addAction = (await EELogService.createAction({
+      name: ACTION_ADD_SECRETS,
+      userId: req.user?._id,
+      serviceAccountId: req.serviceAccount?._id,
+      serviceTokenDataId: req.serviceTokenData?._id,
+      workspaceId: new Types.ObjectId(workspaceId),
+      secretIds: createdSecrets.map((n) => n._id)
+    })) as IAction;
+    actions.push(addAction);
+
     if (postHogClient) {
       postHogClient.capture({
         event: "secrets added",
@@ -339,6 +350,14 @@ export const batchSecrets = async (req: Request, res: Response) => {
 
     await AuditLog.insertMany(auditLogs);
 
+    const updateAction = (await EELogService.createAction({
+      name: ACTION_UPDATE_SECRETS,
+      userId: req.user._id,
+      workspaceId: new Types.ObjectId(workspaceId),
+      secretIds: updatedSecrets.map((u) => u._id)
+    })) as IAction;
+    actions.push(updateAction);
+
     if (postHogClient) {
       postHogClient.capture({
         event: "secrets modified",
@@ -409,6 +428,14 @@ export const batchSecrets = async (req: Request, res: Response) => {
 
     await AuditLog.insertMany(auditLogs);
 
+    const deleteAction = (await EELogService.createAction({
+      name: ACTION_DELETE_SECRETS,
+      userId: req.user._id,
+      workspaceId: new Types.ObjectId(workspaceId),
+      secretIds: deleteSecretIds
+    })) as IAction;
+    actions.push(deleteAction);
+
     if (postHogClient) {
       postHogClient.capture({
         event: "secrets deleted",
@@ -424,6 +451,17 @@ export const batchSecrets = async (req: Request, res: Response) => {
     }
   }
 
+  if (actions.length > 0) {
+    // (EE) create (audit) log
+    await EELogService.createLog({
+      userId: req.user._id.toString(),
+      workspaceId: new Types.ObjectId(workspaceId),
+      actions,
+      channel,
+      ipAddress: req.realIP
+    });
+  }
+
   // // trigger event - push secrets
   await EventService.handleEvent({
     event: eventPushSecrets({
@@ -693,6 +731,27 @@ export const createSecrets = async (req: Request, res: Response) => {
     )
   });
 
+  const addAction = await EELogService.createAction({
+    name: ACTION_ADD_SECRETS,
+    userId: req.user?._id,
+    serviceAccountId: req.serviceAccount?._id,
+    serviceTokenDataId: req.serviceTokenData?._id,
+    workspaceId: new Types.ObjectId(workspaceId),
+    secretIds: newlyCreatedSecrets.map((n) => n._id)
+  });
+
+  // (EE) create (audit) log
+  addAction &&
+    (await EELogService.createLog({
+      userId: req.user?._id,
+      serviceAccountId: req.serviceAccount?._id,
+      serviceTokenDataId: req.serviceTokenData?._id,
+      workspaceId: new Types.ObjectId(workspaceId),
+      actions: [addAction],
+      channel,
+      ipAddress: req.realIP
+    }));
+
   // (EE) take a secret snapshot
   await EESecretService.takeSecretSnapshot({
     workspaceId: new Types.ObjectId(workspaceId),
@@ -901,6 +960,22 @@ export const getSecrets = async (req: Request, res: Response) => {
     secrets = await Secret.find(secretQuery).populate("tags");
   }
 
+  // case: client authorization is via service account
+  if (req.serviceAccount) {
+    const secretQuery: any = {
+      workspace: workspaceId,
+      environment,
+      folder: folderId,
+      user: { $exists: false } // shared secrets only from workspace
+    };
+
+    if (tagIds.length > 0) {
+      secretQuery.tags = { $in: tagIds };
+    }
+
+    secrets = await Secret.find(secretQuery).populate("tags");
+  }
+
   // TODO(akhilmhdh) - secret-imp change this to org type
   let importedSecrets: any[] = [];
   if (include_imports) {
@@ -913,6 +988,28 @@ export const getSecrets = async (req: Request, res: Response) => {
     );
   }
 
+  const channel = getUserAgentType(req.headers["user-agent"]);
+
+  const readAction = await EELogService.createAction({
+    name: ACTION_READ_SECRETS,
+    userId: req.user?._id,
+    serviceAccountId: req.serviceAccount?._id,
+    serviceTokenDataId: req.serviceTokenData?._id,
+    workspaceId: new Types.ObjectId(workspaceId as string),
+    secretIds: secrets.map((n: any) => n._id)
+  });
+
+  readAction &&
+    (await EELogService.createLog({
+      userId: req.user?._id,
+      serviceAccountId: req.serviceAccount?._id,
+      serviceTokenDataId: req.serviceTokenData?._id,
+      workspaceId: new Types.ObjectId(workspaceId as string),
+      actions: [readAction],
+      channel,
+      ipAddress: req.realIP
+    }));
+
   await EEAuditLogService.createAuditLog(
     req.authData,
     {
@@ -1150,6 +1247,27 @@ export const updateSecrets = async (req: Request, res: Response) => {
     //   });
     // }, 10000);
 
+    const updateAction = await EELogService.createAction({
+      name: ACTION_UPDATE_SECRETS,
+      userId: req.user?._id,
+      serviceAccountId: req.serviceAccount?._id,
+      serviceTokenDataId: req.serviceTokenData?._id,
+      workspaceId: new Types.ObjectId(key),
+      secretIds: workspaceSecretObj[key].map((secret: ISecret) => secret._id)
+    });
+
+    // (EE) create (audit) log
+    updateAction &&
+      (await EELogService.createLog({
+        userId: req.user?._id,
+        serviceAccountId: req.serviceAccount?._id,
+        serviceTokenDataId: req.serviceTokenData?._id,
+        workspaceId: new Types.ObjectId(key),
+        actions: [updateAction],
+        channel,
+        ipAddress: req.realIP
+      }));
+
     // (EE) take a secret snapshot
     // IMP(akhilmhdh): commented out due to unknown where the environment is
     // await EESecretService.takeSecretSnapshot({
@@ -1269,6 +1387,26 @@ export const deleteSecrets = async (req: Request, res: Response) => {
     //     workspaceId: new Types.ObjectId(key)
     //   })
     // });
+    const deleteAction = await EELogService.createAction({
+      name: ACTION_DELETE_SECRETS,
+      userId: req.user?._id,
+      serviceAccountId: req.serviceAccount?._id,
+      serviceTokenDataId: req.serviceTokenData?._id,
+      workspaceId: new Types.ObjectId(key),
+      secretIds: workspaceSecretObj[key].map((secret: ISecret) => secret._id)
+    });
+
+    // (EE) create (audit) log
+    deleteAction &&
+      (await EELogService.createLog({
+        userId: req.user?._id,
+        serviceAccountId: req.serviceAccount?._id,
+        serviceTokenDataId: req.serviceTokenData?._id,
+        workspaceId: new Types.ObjectId(key),
+        actions: [deleteAction],
+        channel,
+        ipAddress: req.realIP
+      }));
 
     // (EE) take a secret snapshot
     // IMP(akhilmhdh): Not sure how to take secretSnapshot

backend/src/controllers/v2/serviceAccountsController.ts

@@ -0,0 +1,306 @@
+import { Request, Response } from "express";
+import { Types } from "mongoose";
+import crypto from "crypto";
+import bcrypt from "bcrypt";
+import {
+    ServiceAccount,
+    ServiceAccountKey,
+    ServiceAccountOrganizationPermission,
+    ServiceAccountWorkspacePermission,
+} from "../../models";
+import {
+    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
+ * @param req
+ * @param res
+ */
+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" });
+    }
+
+    return res.status(200).send({
+        serviceAccount,
+    });
+}
+
+/**
+ * Return service account with id [serviceAccountId]
+ * @param req 
+ * @param res 
+ */
+export const getServiceAccountById = async (req: Request, res: Response) => {
+    const { serviceAccountId } = req.params;
+
+    const serviceAccount = await ServiceAccount.findById(serviceAccountId);
+
+    if (!serviceAccount) {
+        throw ServiceAccountNotFoundError({ message: "Failed to find service account" });
+    }
+
+    return res.status(200).send({
+        serviceAccount,
+    });
+}
+
+/**
+ * Create a new service account under organization with id [organizationId]
+ * that has access to workspaces [workspaces]
+ * @param req 
+ * @param res 
+ * @returns
+ */
+export const createServiceAccount = async (req: Request, res: Response) => {
+    const {
+        name,
+        organizationId,
+        publicKey,
+        expiresIn,
+    }: CreateServiceAccountDto = req.body;
+
+    let expiresAt;
+    if (expiresIn) {
+        expiresAt = new Date();
+        expiresAt.setSeconds(expiresAt.getSeconds() + expiresIn);
+    }
+
+    const secret = crypto.randomBytes(16).toString("base64");
+    const secretHash = await bcrypt.hash(secret, await getSaltRounds());
+
+    // create service account
+    const serviceAccount = await new ServiceAccount({
+        name,
+        organization: new Types.ObjectId(organizationId),
+        user: req.user,
+        publicKey,
+        lastUsed: new Date(),
+        expiresAt,
+        secretHash,
+    }).save()
+
+    const serviceAccountObj = serviceAccount.toObject();
+
+    delete (serviceAccountObj as any).secretHash;
+
+    // provision default org-level permission for service account
+    await new ServiceAccountOrganizationPermission({
+        serviceAccount: serviceAccount._id,
+    }).save();
+
+    const secretId = Buffer.from(serviceAccount._id.toString(), "hex").toString("base64");
+
+    return res.status(200).send({
+        serviceAccountAccessKey: `sa.${secretId}.${secret}`,
+        serviceAccount: serviceAccountObj,
+    });
+}
+
+/**
+ * Change name of service account with id [serviceAccountId] to [name]
+ * @param req 
+ * @param res 
+ * @returns 
+ */
+export const changeServiceAccountName = async (req: Request, res: Response) => {
+    const { serviceAccountId } = req.params;
+    const { name } = req.body;
+
+    const serviceAccount = await ServiceAccount.findOneAndUpdate(
+        {
+            _id: new Types.ObjectId(serviceAccountId),
+        },
+        {
+            name,
+        },
+        {
+            new: true,
+        }
+    );
+
+    return res.status(200).send({
+        serviceAccount,
+    });
+}
+
+/**
+ * Add a service account key to service account with id [serviceAccountId]
+ * for workspace with id [workspaceId]
+ * @param req 
+ * @param res 
+ * @returns 
+ */
+export const addServiceAccountKey = async (req: Request, res: Response) => {
+    const {
+        workspaceId,
+        encryptedKey,
+        nonce,
+    } = req.body;
+
+    const serviceAccountKey = await new ServiceAccountKey({
+        encryptedKey,
+        nonce,
+        sender: req.user._id,
+        serviceAccount: req.serviceAccount._d,
+        workspace: new Types.ObjectId(workspaceId),
+    }).save();
+
+    return serviceAccountKey;
+}
+
+/**
+ * Return workspace-level permission for service account with id [serviceAccountId]
+ * @param req 
+ * @param res 
+ */
+export const getServiceAccountWorkspacePermissions = async (req: Request, res: Response) => {
+    const serviceAccountWorkspacePermissions = await ServiceAccountWorkspacePermission.find({
+        serviceAccount: req.serviceAccount._id,
+    }).populate("workspace");
+
+    return res.status(200).send({
+        serviceAccountWorkspacePermissions,
+    });
+}
+
+/**
+ * Add a workspace permission to service account with id [serviceAccountId]
+ * @param req 
+ * @param res 
+ */
+export const addServiceAccountWorkspacePermission = async (req: Request, res: Response) => {
+    const { serviceAccountId } = req.params;
+    const {
+        environment,
+        workspaceId,
+        read = false,
+        write = false,
+        encryptedKey,
+        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",
+        });
+    }
+
+    const existingPermission = await ServiceAccountWorkspacePermission.findOne({
+        serviceAccount: new Types.ObjectId(serviceAccountId),
+        workspace: new Types.ObjectId(workspaceId),
+        environment,
+    });
+
+    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,
+    }).save();
+
+    const existingServiceAccountKey = await ServiceAccountKey.findOne({
+        serviceAccount: new Types.ObjectId(serviceAccountId),
+        workspace: new Types.ObjectId(workspaceId),
+    });
+
+    if (!existingServiceAccountKey) {
+        await new ServiceAccountKey({
+            encryptedKey,
+            nonce,
+            sender: req.user._id,
+            serviceAccount: new Types.ObjectId(serviceAccountId),
+            workspace: new Types.ObjectId(workspaceId),
+        }).save();
+    }
+
+    return res.status(200).send({
+        serviceAccountWorkspacePermission,
+    });
+}
+
+/**
+ * Delete workspace permission from service account with id [serviceAccountId]
+ * @param req 
+ * @param res 
+ */
+export const deleteServiceAccountWorkspacePermission = async (req: Request, res: Response) => {
+    const { serviceAccountWorkspacePermissionId } = req.params;
+    const serviceAccountWorkspacePermission = await ServiceAccountWorkspacePermission.findByIdAndDelete(serviceAccountWorkspacePermissionId);
+
+    if (serviceAccountWorkspacePermission) {
+        const { serviceAccount, workspace } = serviceAccountWorkspacePermission;
+        const count = await ServiceAccountWorkspacePermission.countDocuments({
+            serviceAccount,
+            workspace,
+        });
+
+        if (count === 0) {
+            await ServiceAccountKey.findOneAndDelete({
+                serviceAccount,
+                workspace,
+            });
+        }
+    }
+
+    return res.status(200).send({
+        serviceAccountWorkspacePermission,
+    });
+}
+
+/**
+ * Delete service account with id [serviceAccountId]
+ * @param req 
+ * @param res 
+ * @returns 
+ */
+export const deleteServiceAccount = async (req: Request, res: Response) => {
+    const { serviceAccountId } = req.params;
+
+    const serviceAccount = await ServiceAccount.findByIdAndDelete(serviceAccountId);
+
+    if (serviceAccount) {
+        await ServiceAccountKey.deleteMany({
+            serviceAccount: serviceAccount._id,
+        });
+
+        await ServiceAccountOrganizationPermission.deleteMany({
+            serviceAccount: new Types.ObjectId(serviceAccountId),
+        });
+
+        await ServiceAccountWorkspacePermission.deleteMany({
+            serviceAccount: new Types.ObjectId(serviceAccountId),
+        });
+    }
+
+    return res.status(200).send({
+        serviceAccount,
+    });
+}
+
+/**
+ * Return service account keys for service account with id [serviceAccountId]
+ * @param req 
+ * @param res 
+ * @returns 
+ */
+export const getServiceAccountKeys = async (req: Request, res: Response) => {
+    const workspaceId = req.query.workspaceId as string;
+
+    const serviceAccountKeys = await ServiceAccountKey.find({
+        serviceAccount: req.serviceAccount._id,
+        ...(workspaceId ? { workspace: new Types.ObjectId(workspaceId) } : {}),
+    });
+
+    return res.status(200).send({
+        serviceAccountKeys,
+    });
+}

backend/src/controllers/v2/serviceTokenDataController.ts

@@ -11,9 +11,9 @@ import * as reqValidator from "../../validation/serviceTokenData";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
-import { ForbiddenError, subject } from "@casl/ability";
+import { ForbiddenError } from "@casl/ability";
 import { Types } from "mongoose";
 
 /**
@@ -75,25 +75,12 @@ export const createServiceTokenData = async (req: Request, res: Response) => {
   const {
     body: { workspaceId, permissions, tag, encryptedKey, scopes, name, expiresIn, iv }
   } = await validateRequest(reqValidator.CreateServiceTokenV2, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.ServiceTokens
   );
 
-  scopes.forEach(({ environment, secretPath }) => {
-    ForbiddenError.from(permission).throwUnlessCan(
-      ProjectPermissionActions.Create,
-      subject(ProjectPermissionSub.Secrets, { environment, secretPath: secretPath })
-    );
-  })
-
-
   const secret = crypto.randomBytes(16).toString("hex");
   const secretHash = await bcrypt.hash(secret, await getSaltRounds());
 
@@ -164,11 +151,10 @@ export const deleteServiceTokenData = async (req: Request, res: Response) => {
   let serviceTokenData = await ServiceTokenData.findById(serviceTokenDataId);
   if (!serviceTokenData) throw BadRequestError({ message: "Service token not found" });
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: serviceTokenData.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    serviceTokenData.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Delete,
     ProjectPermissionSub.ServiceTokens

backend/src/controllers/v2/tagController.ts

@@ -7,7 +7,7 @@ import { validateRequest } from "../../helpers/validation";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import * as reqValidator from "../../validation/tags";
 
@@ -17,11 +17,7 @@ export const createWorkspaceTag = async (req: Request, res: Response) => {
     params: { workspaceId }
   } = await validateRequest(reqValidator.CreateWorkspaceTagsV2, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.Tags
@@ -49,11 +45,10 @@ export const deleteWorkspaceTag = async (req: Request, res: Response) => {
     throw BadRequestError();
   }
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: tagFromDB.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    tagFromDB.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Delete,
     ProjectPermissionSub.Tags
@@ -71,12 +66,7 @@ export const getWorkspaceTags = async (req: Request, res: Response) => {
   const {
     params: { workspaceId }
   } = await validateRequest(reqValidator.GetWorkspaceTagsV2, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Tags

backend/src/controllers/v2/workspaceController.ts

@@ -1,15 +1,6 @@
 import { Request, Response } from "express";
 import { Types } from "mongoose";
-import {
-  IIdentity,
-  IdentityMembership,
-  IdentityMembershipOrg,
-  Key,
-  Membership,
-  ServiceTokenData,
-  Workspace
-} from "../../models";
-import { IRole, Role } from "../../ee/models";
+import { Key, Membership, ServiceTokenData, Workspace } from "../../models";
 import {
   pullSecrets as pull,
   v2PushSecrets as push,
@@ -25,13 +16,9 @@ import * as reqValidator from "../../validation";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions,
-  getWorkspaceRolePermissions,
-  isAtLeastAsPrivilegedWorkspace
+  getUserProjectPermissions
 } from "../../ee/services/ProjectRoleService";
 import { ForbiddenError } from "@casl/ability";
-import { BadRequestError, ForbiddenRequestError, ResourceNotFoundError } from "../../utils/errors";
-import { ADMIN, CUSTOM, MEMBER, NO_ACCESS, VIEWER } from "../../variables";
 
 interface V2PushSecret {
   type: string; // personal or shared
@@ -182,11 +169,11 @@ export const getWorkspaceKey = async (req: Request, res: Response) => {
         "apiKeyAuth": []
     }]
 
-  #swagger.parameters['workspaceId'] = {
-    "description": "ID of project",
-    "required": true,
-    "type": "string"
-  } 
+	#swagger.parameters['workspaceId'] = {
+		"description": "ID of project",
+		"required": true,
+		"type": "string"
+	} 
 
     #swagger.responses[200] = {
         content: {
@@ -211,7 +198,7 @@ export const getWorkspaceKey = async (req: Request, res: Response) => {
     receiver: req.user._id
   }).populate("sender", "+publicKey");
 
-  if (!key) throw new Error(`getWorkspaceKey: Failed to find workspace key [workspaceId=${workspaceId}] [receiver=${req.user._id}]`);
+  if (!key) throw new Error("Failed to find workspace key");
 
   await EEAuditLogService.createAuditLog(
     req.authData,
@@ -249,34 +236,33 @@ export const getWorkspaceServiceTokenData = async (req: Request, res: Response)
  */
 export const getWorkspaceMemberships = async (req: Request, res: Response) => {
   /* 
-    #swagger.summary = 'Return project user memberships'
-    #swagger.description = 'Return project user memberships'
+    #swagger.summary = 'Return project memberships'
+    #swagger.description = 'Return project memberships'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
-  #swagger.parameters['workspaceId'] = {
-    "description": "ID of project",
-    "required": true,
-    "type": "string"
-  } 
+	#swagger.parameters['workspaceId'] = {
+		"description": "ID of project",
+		"required": true,
+		"type": "string"
+	} 
 
     #swagger.responses[200] = {
         content: {
             "application/json": {
                 "schema": { 
                     "type": "object",
-          "properties": {
-            "memberships": {
-              "type": "array",
-              "items": {
-                $ref: "#/components/schemas/Membership" 
-              },
-              "description": "Memberships of project"
-            }
-          }
+					"properties": {
+						"memberships": {
+							"type": "array",
+							"items": {
+								$ref: "#/components/schemas/Membership" 
+							},
+							"description": "Memberships of project"
+						}
+					}
                 }
             }           
         }
@@ -286,11 +272,7 @@ export const getWorkspaceMemberships = async (req: Request, res: Response) => {
     params: { workspaceId }
   } = await validateRequest(reqValidator.GetWorkspaceMembershipsV2, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.Member
@@ -313,27 +295,26 @@ export const getWorkspaceMemberships = async (req: Request, res: Response) => {
  */
 export const updateWorkspaceMembership = async (req: Request, res: Response) => {
   /* 
-    #swagger.summary = 'Update project user membership'
-    #swagger.description = 'Update project user membership'
+    #swagger.summary = 'Update project membership'
+    #swagger.description = 'Update project membership'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
-  #swagger.parameters['workspaceId'] = {
-    "description": "ID of project",
-    "required": true,
-    "type": "string"
-  } 
+	#swagger.parameters['workspaceId'] = {
+		"description": "ID of project",
+		"required": true,
+		"type": "string"
+	} 
 
-  #swagger.parameters['membershipId'] = {
-    "description": "ID of project membership to update",
-    "required": true,
-    "type": "string"
-  } 
+	#swagger.parameters['membershipId'] = {
+		"description": "ID of project membership to update",
+		"required": true,
+		"type": "string"
+	} 
 
-  #swagger.requestBody = {
+	#swagger.requestBody = {
       "required": true,
       "content": {
         "application/json": {
@@ -342,7 +323,7 @@ export const updateWorkspaceMembership = async (req: Request, res: Response) =>
             "properties": {
                 "role": {
                     "type": "string",
-                    "description": "Role to update to for project membership",
+                    "description": "Role of membership - either admin or member",
                 }
             }
           }
@@ -354,13 +335,13 @@ export const updateWorkspaceMembership = async (req: Request, res: Response) =>
         content: {
             "application/json": {
                 "schema": { 
-          "type": "object",
-          "properties": {
-            "membership": {
-              $ref: "#/components/schemas/Membership",
-              "description": "Updated membership"
-            }
-          }
+					"type": "object",
+					"properties": {
+						"membership": {
+							$ref: "#/components/schemas/Membership",
+							"description": "Updated membership"
+						}
+					}
                 }
             }           
         }
@@ -371,11 +352,7 @@ export const updateWorkspaceMembership = async (req: Request, res: Response) =>
     body: { role }
   } = await validateRequest(reqValidator.UpdateWorkspaceMembershipsV2, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.Member
@@ -404,37 +381,36 @@ export const updateWorkspaceMembership = async (req: Request, res: Response) =>
  */
 export const deleteWorkspaceMembership = async (req: Request, res: Response) => {
   /* 
-    #swagger.summary = 'Delete project user membership'
-    #swagger.description = 'Delete project user membership'
+    #swagger.summary = 'Delete project membership'
+    #swagger.description = 'Delete project membership'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
-  #swagger.parameters['workspaceId'] = {
-    "description": "ID of project",
-    "required": true,
-    "type": "string"
-  } 
+	#swagger.parameters['workspaceId'] = {
+		"description": "ID of project",
+		"required": true,
+		"type": "string"
+	} 
 
-  #swagger.parameters['membershipId'] = {
-    "description": "ID of project membership to delete",
-    "required": true,
-    "type": "string"
-  } 
+	#swagger.parameters['membershipId'] = {
+		"description": "ID of project membership to delete",
+		"required": true,
+		"type": "string"
+	} 
 
     #swagger.responses[200] = {
         content: {
             "application/json": {
                 "schema": { 
-          "type": "object",
-          "properties": {
-            "membership": {
-              $ref: "#/components/schemas/Membership",
-              "description": "Deleted membership"
-            }
-          }
+					"type": "object",
+					"properties": {
+						"membership": {
+							$ref: "#/components/schemas/Membership",
+							"description": "Deleted membership"
+						}
+					}
                 }
             }           
         }
@@ -444,11 +420,7 @@ export const deleteWorkspaceMembership = async (req: Request, res: Response) =>
     params: { workspaceId, membershipId }
   } = await validateRequest(reqValidator.DeleteWorkspaceMembershipsV2, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Delete,
     ProjectPermissionSub.Member
@@ -480,11 +452,7 @@ export const toggleAutoCapitalization = async (req: Request, res: Response) => {
     body: { autoCapitalization }
   } = await validateRequest(reqValidator.ToggleAutoCapitalizationV2, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.Settings
@@ -507,377 +475,3 @@ export const toggleAutoCapitalization = async (req: Request, res: Response) => {
     workspace
   });
 };
-
-/**
- * Add identity with id [identityId] to workspace
- * with id [workspaceId]
- * @param req 
- * @param res 
- */
-export const addIdentityToWorkspace = async (req: Request, res: Response) => {
-  const {
-    params: { workspaceId, identityId },
-    body: {
-      role
-    }
-  } = await validateRequest(reqValidator.AddIdentityToWorkspaceV2, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Create,
-    ProjectPermissionSub.Identity
-  );
-
-  let identityMembership = await IdentityMembership.findOne({
-    identity: new Types.ObjectId(identityId),
-    workspace: new Types.ObjectId(workspaceId)
-  });
-
-  if (identityMembership) throw BadRequestError({
-    message: `Identity with id ${identityId} already exists in project with id ${workspaceId}`
-  });
-
-
-  const workspace = await Workspace.findById(workspaceId);
-  if (!workspace) throw ResourceNotFoundError();
-
-  const identityMembershipOrg = await IdentityMembershipOrg.findOne({
-    identity: new Types.ObjectId(identityId),
-    organization: workspace.organization
-  });
-
-  if (!identityMembershipOrg) throw ResourceNotFoundError({
-    message: `Failed to find identity with id ${identityId}`
-  });
-
-  if (!identityMembershipOrg.organization.equals(workspace.organization)) throw BadRequestError({
-    message: "Failed to add identity to project in another organization"
-  });
-
-  const rolePermission = await getWorkspaceRolePermissions(role, workspaceId);
-  const isAsPrivilegedAsIntendedRole = isAtLeastAsPrivilegedWorkspace(permission, rolePermission);
-
-  if (!isAsPrivilegedAsIntendedRole) throw ForbiddenRequestError({
-    message: "Failed to add identity to project with more privileged role"
-  });
-
-  let customRole;
-  if (role) {
-    const isCustomRole = ![ADMIN, MEMBER, VIEWER, NO_ACCESS].includes(role);
-    if (isCustomRole) {
-      customRole = await Role.findOne({
-        slug: role,
-        isOrgRole: false,
-        workspace: new Types.ObjectId(workspaceId)
-      });
-
-      if (!customRole) throw BadRequestError({ message: "Role not found" });
-    }
-  }
-
-  identityMembership = await new IdentityMembership({
-    identity: identityMembershipOrg.identity,
-    workspace: new Types.ObjectId(workspaceId),
-    role: customRole ? CUSTOM : role,
-    customRole
-  }).save();
-
-  return res.status(200).send({
-    identityMembership
-  });
-}
-
-/**
- * Update role of identity with id [identityId] in workspace
- * with id [workspaceId] to [role]
- * @param req 
- * @param res 
- */
- export const updateIdentityWorkspaceRole = async (req: Request, res: Response) => {
-   /* 
-    #swagger.summary = 'Update project identity membership'
-    #swagger.description = 'Update project identity membership'
-    
-    #swagger.security = [{
-        "bearerAuth": []
-    }]
-
-	#swagger.parameters['workspaceId'] = {
-		"description": "ID of project",
-		"required": true,
-		"type": "string"
-	} 
-
-	#swagger.parameters['identityId'] = {
-		"description": "ID of identity whose membership to update in project",
-		"required": true,
-		"type": "string"
-	} 
-
-	#swagger.requestBody = {
-      "required": true,
-      "content": {
-        "application/json": {
-          "schema": {
-            "type": "object",
-            "properties": {
-                "role": {
-                    "type": "string",
-                    "description": "Role to update to for identity project membership",
-                }
-            }
-          }
-        }
-      }
-    }
-
-    #swagger.responses[200] = {
-        content: {
-          "application/json": {
-            "schema": { 
-              "type": "object",
-              "properties": {
-                "identityMembership": {
-                  $ref: "#/components/schemas/IdentityMembership",
-                  "description": "Updated identity membership"
-                }
-              }
-            }
-          }           
-        }
-    }   
-    */
-  const {
-    params: { workspaceId, identityId },
-    body: {
-      role
-    }
-  } = await validateRequest(reqValidator.UpdateIdentityWorkspaceRoleV2, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Edit,
-    ProjectPermissionSub.Identity
-  );
-
-  let identityMembership = await IdentityMembership
-    .findOne({
-      identity: new Types.ObjectId(identityId),
-      workspace: new Types.ObjectId(workspaceId)
-    })
-    .populate<{
-      identity: IIdentity,
-      customRole: IRole
-    }>("identity customRole");
-
-  if (!identityMembership) throw BadRequestError({
-    message: `Identity with id ${identityId} does not exist in project with id ${workspaceId}`
-  });
-
-  const identityRolePermission = await getWorkspaceRolePermissions(
-    identityMembership?.customRole?.slug ?? identityMembership.role,
-    identityMembership.workspace.toString()
-  );
-  const isAsPrivilegedAsIdentity = isAtLeastAsPrivilegedWorkspace(permission, identityRolePermission);
-  if (!isAsPrivilegedAsIdentity) throw ForbiddenRequestError({
-    message: "Failed to update role of more privileged identity"
-  });
-
-  const rolePermission = await getWorkspaceRolePermissions(role, workspaceId);
-  const isAsPrivilegedAsIntendedRole = isAtLeastAsPrivilegedWorkspace(permission, rolePermission);
-
-  if (!isAsPrivilegedAsIntendedRole) throw ForbiddenRequestError({
-    message: "Failed to update identity to a more privileged role"
-  });
-
-  let customRole;
-  if (role) {
-    const isCustomRole = ![ADMIN, MEMBER, VIEWER, NO_ACCESS].includes(role);
-    if (isCustomRole) {
-      customRole = await Role.findOne({
-        slug: role,
-        isOrgRole: false,
-        workspace: new Types.ObjectId(workspaceId)
-      });
-
-      if (!customRole) throw BadRequestError({ message: "Role not found" });
-    }
-  }
-
-  identityMembership = await IdentityMembership.findOneAndUpdate(
-    {
-      identity: identityMembership.identity._id,
-      workspace: new Types.ObjectId(workspaceId),
-    },
-    {
-      role: customRole ? CUSTOM : role,
-      customRole
-    },
-    {
-      new: true
-    }
-  );
-
-  return res.status(200).send({
-    identityMembership
-  });
-}
-
-/**
- * Delete identity with id [identityId] from workspace
- * with id [workspaceId]
- * @param req 
- * @param res 
- */
- export const deleteIdentityFromWorkspace = async (req: Request, res: Response) => {
-   /* 
-    #swagger.summary = 'Delete project identity membership'
-    #swagger.description = 'Delete project identity membership'
-    
-    #swagger.security = [{
-        "bearerAuth": []
-    }]
-
-	#swagger.parameters['workspaceId'] = {
-		"description": "ID of project",
-		"required": true,
-		"type": "string"
-	} 
-
-	#swagger.parameters['identityId'] = {
-		"description": "ID of identity whose membership to delete in project",
-		"required": true,
-		"type": "string"
-	} 
-
-    #swagger.responses[200] = {
-        content: {
-          "application/json": {
-            "schema": { 
-              "type": "object",
-              "properties": {
-                "identityMembership": {
-                  $ref: "#/components/schemas/IdentityMembership",
-                  "description": "Deleted identity membership"
-                }
-              }
-            }
-          }           
-        }
-    }   
-    */
-  const {
-    params: { workspaceId, identityId }
-  } = await validateRequest(reqValidator.DeleteIdentityFromWorkspaceV2, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Delete,
-    ProjectPermissionSub.Identity
-  );
-
-  const identityMembership = await IdentityMembership
-    .findOne({
-      identity: new Types.ObjectId(identityId),
-      workspace: new Types.ObjectId(workspaceId)
-    })
-    .populate<{
-      identity: IIdentity,
-      customRole: IRole
-    }>("identity customRole");
-
-  if (!identityMembership) throw ResourceNotFoundError({
-    message: `Identity with id ${identityId} does not exist in project with id ${workspaceId}`
-  });
-
-  const identityRolePermission = await getWorkspaceRolePermissions(
-    identityMembership?.customRole?.slug ?? identityMembership.role,
-    identityMembership.workspace.toString()
-  );
-  const isAsPrivilegedAsIdentity = isAtLeastAsPrivilegedWorkspace(permission, identityRolePermission);
-  if (!isAsPrivilegedAsIdentity) throw ForbiddenRequestError({
-    message: "Failed to remove more privileged identity from project"
-  });
-
-  await IdentityMembership.findByIdAndDelete(identityMembership._id);
-
-  return res.status(200).send({
-    identityMembership
-  });
-}
-
-/**
- * Return list of identity memberships for workspace with id [workspaceId]
- * @param req
- * @param res 
- * @returns 
- */
- export const getWorkspaceIdentityMemberships = async (req: Request, res: Response) => {
-   /*
-    #swagger.summary = 'Return project identity memberships'
-    #swagger.description = 'Return project identity memberships'
-
-    #swagger.security = [{
-        "bearerAuth": []
-    }]
-    
-    #swagger.parameters['workspaceId'] = {
-        "description": "ID of project",
-        "required": true,
-        "type": "string",
-        "in": "path"
-    }
-
-    #swagger.responses[200] = {
-        content: {
-            "application/json": {
-              "schema": { 
-                "type": "object",
-                "properties": {
-                  "identityMemberships": {
-                    "type": "array",
-                    "items": {
-                      $ref: "#/components/schemas/IdentityMembership" 
-                    },
-                    "description": "Identity memberships of project"
-                  }
-                }
-              }
-            }           
-        }
-    }
-  */
-  const {
-    params: { workspaceId }
-  } = await validateRequest(reqValidator.GetWorkspaceIdentityMembersV2, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Read,
-    ProjectPermissionSub.Identity
-  );
-
-  const identityMemberships = await IdentityMembership.find({
-    workspace: new Types.ObjectId(workspaceId)
-  }).populate("identity customRole");
-
-  return res.status(200).send({
-    identityMemberships
-  });
-}

backend/src/controllers/v3/authController.ts

@@ -8,8 +8,10 @@ import { createToken, issueAuthTokens, validateProviderAuthToken } from "../../h
 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 { AuthTokenType, TOKEN_EMAIL_MFA } from "../../variables";
+import { ACTION_LOGIN, AuthTokenType, TOKEN_EMAIL_MFA } from "../../variables";
+import { getUserAgentType } from "../../utils/posthog"; // TODO: move this
 import { getAuthSecret, getHttpsEnabled, getJwtMfaLifetime } from "../../config";
 import { AuthMethod } from "../../models/user";
 import { validateRequest } from "../../helpers/validation";
@@ -213,6 +215,19 @@ export const login2 = async (req: Request, res: Response) => {
           response.protectedKeyTag = user.protectedKeyTag;
         }
 
+        const loginAction = await EELogService.createAction({
+          name: ACTION_LOGIN,
+          userId: user._id
+        });
+
+        loginAction &&
+          (await EELogService.createLog({
+            userId: user._id,
+            actions: [loginAction],
+            channel: getUserAgentType(req.headers["user-agent"]),
+            ipAddress: req.realIP
+          }));
+
         return res.status(200).send(response);
       }
 

backend/src/controllers/v3/workspacesController.ts

@@ -1,9 +1,9 @@
 import { Request, Response } from "express";
 import { Types } from "mongoose";
 import { validateRequest } from "../../helpers/validation";
-import { Membership, Secret, User } from "../../models";
+import { Secret, ServiceTokenDataV3 } from "../../models";
 import { SecretService } from "../../services";
-import { getAuthDataProjectPermissions } from "../../ee/services/ProjectRoleService";
+import { getUserProjectPermissions } from "../../ee/services/ProjectRoleService";
 import { UnauthorizedRequestError } from "../../utils/errors";
 import * as reqValidator from "../../validation/workspace";
 
@@ -19,22 +19,9 @@ export const getWorkspaceBlindIndexStatus = async (req: Request, res: Response)
     params: { workspaceId }
   } = await validateRequest(reqValidator.GetWorkspaceBlinkIndexStatusV3, req);
 
-  await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
-  if (req.authData.authPayload instanceof User) {
-    const membership = await Membership.findOne({
-      user: req.authData.authPayload._id,
-      workspace: new Types.ObjectId(workspaceId)
-    });
-    
-    if (!membership) throw UnauthorizedRequestError();
-
-    if (membership.role !== "admin")
-      throw UnauthorizedRequestError({ message: "User must be an admin" });
-  }
+  const { membership } = await getUserProjectPermissions(req.user._id, workspaceId);
+  if (membership.role !== "admin")
+    throw UnauthorizedRequestError({ message: "User must be an admin" });
 
   const secretsWithoutBlindIndex = await Secret.countDocuments({
     workspace: new Types.ObjectId(workspaceId),
@@ -54,22 +41,9 @@ export const getWorkspaceSecrets = async (req: Request, res: Response) => {
     params: { workspaceId }
   } = await validateRequest(reqValidator.GetWorkspaceSecretsV3, req);
 
-  await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
-  if (req.authData.authPayload instanceof User) {
-    const membership = await Membership.findOne({
-      user: req.authData.authPayload._id,
-      workspace: new Types.ObjectId(workspaceId)
-    });
-    
-    if (!membership) throw UnauthorizedRequestError();
-
-    if (membership.role !== "admin")
-      throw UnauthorizedRequestError({ message: "User must be an admin" });
-  }
+  const { membership } = await getUserProjectPermissions(req.user._id, workspaceId);
+  if (membership.role !== "admin")
+    throw UnauthorizedRequestError({ message: "User must be an admin" });
 
   const secrets = await Secret.find({
     workspace: new Types.ObjectId(workspaceId)
@@ -91,22 +65,9 @@ export const nameWorkspaceSecrets = async (req: Request, res: Response) => {
     body: { secretsToUpdate }
   } = await validateRequest(reqValidator.NameWorkspaceSecretsV3, req);
 
-  await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
-  if (req.authData.authPayload instanceof User) {
-    const membership = await Membership.findOne({
-      user: req.authData.authPayload._id,
-      workspace: new Types.ObjectId(workspaceId)
-    });
-    
-    if (!membership) throw UnauthorizedRequestError();
-
-    if (membership.role !== "admin")
-      throw UnauthorizedRequestError({ message: "User must be an admin" });
-  }
+  const { membership } = await getUserProjectPermissions(req.user._id, workspaceId);
+  if (membership.role !== "admin")
+    throw UnauthorizedRequestError({ message: "User must be an admin" });
 
   // get secret blind index salt
   const salt = await SecretService.getSecretBlindIndexSalt({
@@ -140,3 +101,17 @@ export const nameWorkspaceSecrets = async (req: Request, res: Response) => {
     message: "Successfully named workspace secrets"
   });
 };
+
+export const getWorkspaceServiceTokenData = async (req: Request, res: Response) => {
+  const {
+    params: { workspaceId }
+  } = await validateRequest(reqValidator.GetWorkspaceServiceTokenDataV3, req);
+  
+  const serviceTokenData = await ServiceTokenDataV3.find({
+    workspace: new Types.ObjectId(workspaceId)
+  });
+  
+  return res.status(200).send({
+    serviceTokenData
+  });
+}

backend/src/ee/controllers/v1/actionController.ts

@@ -0,0 +1,32 @@
+import { Request, Response } from "express";
+import { Action } from "../../models";
+import { ActionNotFoundError } from "../../../utils/errors";
+import { validateRequest } from "../../../helpers/validation";
+import * as reqValidator from "../../../validation/action";
+
+export const getAction = async (req: Request, res: Response) => {
+  let action;
+  try {
+    const {
+      params: { actionId }
+    } = await validateRequest(reqValidator.GetActionV1, req);
+
+    action = await Action.findById(actionId).populate([
+      "payload.secretVersions.oldSecretVersion",
+      "payload.secretVersions.newSecretVersion"
+    ]);
+
+    if (!action)
+      throw ActionNotFoundError({
+        message: "Failed to find action"
+      });
+  } catch (err) {
+    throw ActionNotFoundError({
+      message: "Failed to find action"
+    });
+  }
+
+  return res.status(200).send({
+    action
+  });
+};

backend/src/ee/controllers/v1/identitiesController.ts

@@ -1,460 +0,0 @@
-import { Request, Response } from "express";
-import { Types } from "mongoose";
-import {
-    IIdentity,
-    Identity,
-    IdentityAccessToken,
-    IdentityMembership,
-    IdentityMembershipOrg,
-    IdentityUniversalAuth,
-    IdentityUniversalAuthClientSecret,
-    Organization
-} from "../../../models";
-import {
-    EventType,
-    IRole,
-    Role
-} from "../../models";
-import { validateRequest } from "../../../helpers/validation";
-import * as reqValidator from "../../../validation/identities";
-import {
-    getAuthDataOrgPermissions,
-    getOrgRolePermissions,
-    isAtLeastAsPrivilegedOrg
-} from "../../services/RoleService";
-import {
-    BadRequestError,
-    ForbiddenRequestError,
-    ResourceNotFoundError,
-} from "../../../utils/errors";
-import { ADMIN, CUSTOM, MEMBER, NO_ACCESS } from "../../../variables";
-import {
-    OrgPermissionActions,
-    OrgPermissionSubjects
-} from "../../services/RoleService";
-import { EEAuditLogService } from "../../services";
-import { ForbiddenError } from "@casl/ability";
-
-/**
- * Create identity
- * @param req 
- * @param res 
- * @returns 
- */
-export const createIdentity = async (req: Request, res: Response) => {
-    /*
-        #swagger.summary = 'Create identity'
-        #swagger.description = 'Create identity'
-
-        #swagger.security = [{
-            "bearerAuth": []
-        }]
-        
-        #swagger.requestBody = {
-            content: {
-                "application/json": {
-                    "schema": {
-                        "type": "object",
-                        "properties": {
-                            "name": {
-                                "type": "string",
-                                "description": "Name of entity to create",
-                                "example": "development"
-                            },
-                            "organizationId": {
-                                "type": "string",
-                                "description": "ID of organization where to create identity",
-                                "example": "dev-environment"
-                            },
-                            "role": {
-                                "type": "string",
-                                "description": "Role to assume for organization membership",
-                                "example": "no-access"
-                            }
-                        },
-                        "required": ["name", "organizationId", "role"]
-                    }
-                }
-            }
-        }
-
-        #swagger.responses[200] = {
-            content: {
-                "application/json": {
-                    "schema": {
-                        "type": "object",
-                        "properties": {
-                            "identity": {
-                                $ref: '#/definitions/Identity'
-                            }
-                        },
-                        "description": "Details of the created identity"
-                    }
-                }
-            }
-        }
-    */
-    const {
-        body: {
-            name,
-            organizationId,
-            role
-        }
-    } = await validateRequest(reqValidator.CreateIdentityV1, req);
-
-    const { permission } = await getAuthDataOrgPermissions({
-        authData: req.authData,
-        organizationId: new Types.ObjectId(organizationId)
-    });
-
-    ForbiddenError.from(permission).throwUnlessCan(
-        OrgPermissionActions.Create,
-        OrgPermissionSubjects.Identity
-    );
-
-    const rolePermission = await getOrgRolePermissions(role, organizationId);
-    const hasRequiredPrivileges = isAtLeastAsPrivilegedOrg(permission, rolePermission);
-
-    if (!hasRequiredPrivileges) throw ForbiddenRequestError({
-        message: "Failed to create a more privileged identity"
-    });
-
-    const organization = await Organization.findById(organizationId);
-    if (!organization) throw BadRequestError({ message: `Organization with id ${organizationId} not found` });
-
-    const isCustomRole = ![ADMIN, MEMBER, NO_ACCESS].includes(role);
-
-    let customRole;
-    if (isCustomRole) {
-        customRole = await Role.findOne({
-            slug: role,
-            isOrgRole: true,
-            organization: new Types.ObjectId(organizationId)
-        });
-
-        if (!customRole) throw BadRequestError({ message: "Role not found" });
-    }
-    
-    const identity = await new Identity({
-        name
-    }).save();
-
-    await new IdentityMembershipOrg({
-        identity: identity._id,
-        organization: new Types.ObjectId(organizationId),
-        role: isCustomRole ? CUSTOM : role,
-        customRole
-    }).save();
-
-    await EEAuditLogService.createAuditLog(
-        req.authData,
-        {
-            type: EventType.CREATE_IDENTITY,
-            metadata: {
-                identityId: identity._id.toString(),
-                name
-            }
-        },
-        {
-            organizationId: new Types.ObjectId(organizationId)
-        }
-    );
-
-    return res.status(200).send({
-        identity
-    });
-}
-
-/**
- * Update identity with id [identityId]
- * @param req 
- * @param res 
- * @returns 
- */
- export const updateIdentity = async (req: Request, res: Response) => {
-    /*
-        #swagger.summary = 'Update identity'
-        #swagger.description = 'Update identity'
-
-        #swagger.security = [{
-            "bearerAuth": []
-        }]
-
-        #swagger.parameters['identityId'] = {
-            "description": "ID of identity to update",
-            "required": true,
-            "type": "string",
-            "in": "path"
-        }
-        
-        #swagger.requestBody = {
-            content: {
-                "application/json": {
-                    "schema": {
-                        "type": "object",
-                        "properties": {
-                            "name": {
-                                "type": "string",
-                                "description": "Name of entity to update to",
-                                "example": "development"
-                            },
-                            "role": {
-                                "type": "string",
-                                "description": "Role to update to for organization membership",
-                                "example": "no-access"
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        #swagger.responses[200] = {
-            content: {
-                "application/json": {
-                    "schema": {
-                        "type": "object",
-                        "properties": {
-                            "identity": {
-                                $ref: '#/definitions/Identity'
-                            }
-                        },
-                        "description": "Details of the updated identity"
-                    }
-                }
-            }
-        }
-    */
-    const {
-        params: { identityId  },
-        body: {
-            name,
-            role
-        }
-    } = await validateRequest(reqValidator.UpdateIdentityV1, req);
-
-    const identityMembershipOrg = await IdentityMembershipOrg
-        .findOne({
-            identity: new Types.ObjectId(identityId)
-        })
-        .populate<{
-            identity: IIdentity,
-            customRole: IRole
-        }>("identity customRole");
-
-    if (!identityMembershipOrg) throw ResourceNotFoundError({
-        message: `Failed to find identity with id ${identityId}`
-    });
-
-    const { permission } = await getAuthDataOrgPermissions({
-        authData: req.authData,
-        organizationId: identityMembershipOrg.organization
-    });
-    ForbiddenError.from(permission).throwUnlessCan(
-        OrgPermissionActions.Edit,
-        OrgPermissionSubjects.Identity
-    );
-
-    const identityRolePermission = await getOrgRolePermissions(
-        identityMembershipOrg?.customRole?.slug ?? identityMembershipOrg.role,
-        identityMembershipOrg.organization.toString()
-    );
-    const hasRequiredPrivileges = isAtLeastAsPrivilegedOrg(permission, identityRolePermission);
-    if (!hasRequiredPrivileges) throw ForbiddenRequestError({
-        message: "Failed to update more privileged identity"
-    });
-
-    if (role) {
-        const rolePermission = await getOrgRolePermissions(role, identityMembershipOrg.organization.toString());
-        const hasRequiredPrivileges = isAtLeastAsPrivilegedOrg(permission, rolePermission);
-
-        if (!hasRequiredPrivileges) throw ForbiddenRequestError({
-            message: "Failed to update identity to a more privileged role"
-        });
-    }
-
-    let customRole;
-    if (role) {
-        const isCustomRole = ![ADMIN, MEMBER, NO_ACCESS].includes(role);
-        if (isCustomRole) {
-            customRole = await Role.findOne({
-                slug: role,
-                isOrgRole: true,
-                organization: identityMembershipOrg.organization
-            });
-
-            if (!customRole) throw BadRequestError({ message: "Role not found" });
-        }
-    }
-
-    const identity = await Identity.findByIdAndUpdate(
-        identityId,
-        {
-            name,
-        },
-        {
-            new: true
-        }
-    );
-
-    if (!identity) throw BadRequestError({
-        message: `Failed to update identity with id ${identityId}`
-    });
-
-    await IdentityMembershipOrg.findOneAndUpdate(
-        {
-            identity: identity._id
-        },
-        {
-            role: customRole ? CUSTOM : role,
-            ...(customRole ? {
-                customRole
-            } : {}),
-            ...(role && !customRole ? { // non-custom role
-                $unset: {
-                    customRole: 1
-                }
-            } : {})
-        },
-        {
-            new: true
-        }
-    );
-
-    await EEAuditLogService.createAuditLog(
-        req.authData,
-        {
-            type: EventType.UPDATE_IDENTITY,
-            metadata: {
-                identityId: identity._id.toString(),
-                name: identity.name,
-            }
-        },
-        {
-            organizationId: identityMembershipOrg.organization
-        }
-    );
-
-    return res.status(200).send({
-        identity
-    });
-}
-
-/**
- * Delete identity with id [identityId]
- * @param req 
- * @param res 
- * @returns 
- */
- export const deleteIdentity = async (req: Request, res: Response) => {
-     /*
-        #swagger.summary = 'Delete identity'
-        #swagger.description = 'Delete identity'
-
-        #swagger.security = [{
-            "bearerAuth": []
-        }]
-
-        #swagger.parameters['identityId'] = {
-            "description": "ID of identity",
-            "required": true,
-            "type": "string",
-            "in": "path"
-        }
-
-        #swagger.responses[200] = {
-            content: {
-                "application/json": {
-                    "schema": {
-                        "type": "object",
-                        "properties": {
-                            "identity": {
-                                $ref: '#/definitions/Identity'
-                            }
-                        },
-                        "description": "Details of the deleted identity"
-                    }
-                }
-            }
-        }
-    */
-    const {
-        params: { identityId }
-    } = await validateRequest(reqValidator.DeleteIdentityV1, req);
-    
-    const identityMembershipOrg = await IdentityMembershipOrg
-        .findOne({
-            identity: new Types.ObjectId(identityId)
-        })
-        .populate<{
-            identity: IIdentity,
-            customRole: IRole
-        }>("identity customRole");
-
-    if (!identityMembershipOrg) throw ResourceNotFoundError({
-        message: `Failed to find identity with id ${identityId}`
-    });
-
-    const { permission } = await getAuthDataOrgPermissions({
-        authData: req.authData,
-        organizationId: identityMembershipOrg.organization
-    });
-    ForbiddenError.from(permission).throwUnlessCan(
-        OrgPermissionActions.Delete,
-        OrgPermissionSubjects.Identity
-    );
-
-    const identityRolePermission = await getOrgRolePermissions(
-        identityMembershipOrg?.customRole?.slug ?? identityMembershipOrg.role,
-        identityMembershipOrg.organization.toString()
-    );
-    const hasRequiredPrivileges = isAtLeastAsPrivilegedOrg(permission, identityRolePermission);
-    if (!hasRequiredPrivileges) throw ForbiddenRequestError({
-        message: "Failed to delete more privileged identity"
-    });
-
-    const identity = await Identity.findByIdAndDelete(identityMembershipOrg.identity);
-    if (!identity) throw ResourceNotFoundError({
-        message: `Identity with id ${identityId} not found`
-    });
-
-    await IdentityMembershipOrg.findByIdAndDelete(identityMembershipOrg._id);
-
-    await IdentityMembership.deleteMany({
-        identity: identityMembershipOrg.identity
-    });
-    
-    await IdentityUniversalAuth.deleteMany({
-        identity: identityMembershipOrg.identity
-    });
-    
-    await IdentityUniversalAuthClientSecret.deleteMany({
-        identity: identityMembershipOrg.identity
-    });
-    
-    await IdentityAccessToken.deleteMany({
-        identity: identityMembershipOrg.identity
-    });
-
-    await EEAuditLogService.createAuditLog(
-        req.authData,
-        {
-            type: EventType.DELETE_IDENTITY,
-            metadata: {
-                identityId: identity._id.toString()
-            }
-        },
-        {
-            organizationId: identityMembershipOrg.organization
-        }
-    );
-
-    return res.status(200).send({
-        identity
-    });
-}
-
-
-
-
-

backend/src/ee/controllers/v1/index.ts

@@ -1,31 +1,27 @@
-import * as identitiesController from "./identitiesController";
 import * as secretController from "./secretController";
 import * as secretSnapshotController from "./secretSnapshotController";
 import * as organizationsController from "./organizationsController";
 import * as ssoController from "./ssoController";
 import * as usersController from "./usersController";
 import * as workspaceController from "./workspaceController";
+import * as actionController from "./actionController";
 import * as membershipController from "./membershipController";
 import * as cloudProductsController from "./cloudProductsController";
 import * as roleController from "./roleController";
 import * as secretApprovalPolicyController from "./secretApprovalPolicyController";
 import * as secretApprovalRequestController from "./secretApprovalRequestsController";
-import * as secretRotationProviderController from "./secretRotationProviderController";
-import * as secretRotationController from "./secretRotationController";
 
 export {
-  identitiesController,
   secretController,
   secretSnapshotController,
   organizationsController,
   ssoController,
   usersController,
   workspaceController,
+  actionController,
   membershipController,
   cloudProductsController,
   roleController,
   secretApprovalPolicyController,
-  secretApprovalRequestController,
-  secretRotationProviderController,
-  secretRotationController
+  secretApprovalRequestController
 };

backend/src/ee/controllers/v1/organizationsController.ts

@@ -8,7 +8,7 @@ import * as reqValidator from "../../../validation/organization";
 import {
   OrgPermissionActions,
   OrgPermissionSubjects,
-  getAuthDataOrgPermissions,
+  getUserOrgPermissions
 } from "../../services/RoleService";
 import { ForbiddenError } from "@casl/ability";
 import { Organization } from "../../../models";
@@ -20,10 +20,7 @@ export const getOrganizationPlansTable = async (req: Request, res: Response) =>
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgPlansTablev1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Billing
@@ -45,10 +42,7 @@ export const getOrganizationPlan = async (req: Request, res: Response) => {
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgPlanv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Billing
@@ -76,10 +70,7 @@ export const startOrganizationTrial = async (req: Request, res: Response) => {
     body: { success_url }
   } = await validateRequest(reqValidator.StartOrgTrailv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Create,
     OrgPermissionSubjects.Billing
@@ -125,10 +116,7 @@ export const getOrganizationPlanBillingInfo = async (req: Request, res: Response
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgPlanBillingInfov1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Billing
@@ -161,10 +149,7 @@ export const getOrganizationPlanTable = async (req: Request, res: Response) => {
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgPlanTablev1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Billing
@@ -191,10 +176,7 @@ export const getOrganizationBillingDetails = async (req: Request, res: Response)
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgBillingDetailsv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Billing
@@ -222,10 +204,7 @@ export const updateOrganizationBillingDetails = async (req: Request, res: Respon
     body: { name, email }
   } = await validateRequest(reqValidator.UpdateOrgBillingDetailsv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Edit,
     OrgPermissionSubjects.Billing
@@ -259,10 +238,7 @@ export const getOrganizationPmtMethods = async (req: Request, res: Response) =>
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgPmtMethodsv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Billing
@@ -295,10 +271,7 @@ export const addOrganizationPmtMethod = async (req: Request, res: Response) => {
     body: { success_url, cancel_url }
   } = await validateRequest(reqValidator.CreateOrgPmtMethodv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Create,
     OrgPermissionSubjects.Billing
@@ -339,10 +312,7 @@ export const deleteOrganizationPmtMethod = async (req: Request, res: Response) =
     params: { organizationId, pmtMethodId }
   } = await validateRequest(reqValidator.DelOrgPmtMethodv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Delete,
     OrgPermissionSubjects.Billing
@@ -372,10 +342,7 @@ export const getOrganizationTaxIds = async (req: Request, res: Response) => {
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgTaxIdsv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Billing
@@ -408,10 +375,7 @@ export const addOrganizationTaxId = async (req: Request, res: Response) => {
     body: { type, value }
   } = await validateRequest(reqValidator.CreateOrgTaxId, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Create,
     OrgPermissionSubjects.Billing
@@ -448,10 +412,7 @@ export const deleteOrganizationTaxId = async (req: Request, res: Response) => {
     params: { organizationId, taxId }
   } = await validateRequest(reqValidator.DelOrgTaxIdv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Delete,
     OrgPermissionSubjects.Billing
@@ -484,10 +445,7 @@ export const getOrganizationInvoices = async (req: Request, res: Response) => {
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgInvoicesv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Billing
@@ -522,10 +480,7 @@ export const getOrganizationLicenses = async (req: Request, res: Response) => {
     params: { organizationId }
   } = await validateRequest(reqValidator.GetOrgLicencesv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Billing

backend/src/ee/controllers/v1/roleController.ts

@@ -1,6 +1,4 @@
 import { Request, Response } from "express";
-import { Types } from "mongoose";
-import { Membership, User } from "../../../models";
 import {
   CreateRoleSchema,
   DeleteRoleSchema,
@@ -13,19 +11,16 @@ import {
   ProjectPermissionActions,
   ProjectPermissionSub,
   adminProjectPermissions,
-  getAuthDataProjectPermissions,
+  getUserProjectPermissions,
   memberProjectPermissions,
-  noAccessProjectPermissions,
   viewerProjectPermission
 } from "../../services/ProjectRoleService";
 import {
   OrgPermissionActions,
   OrgPermissionSubjects,
   adminPermissions,
-  getAuthDataOrgPermissions,
   getUserOrgPermissions,
-  memberPermissions,
-  noAccessPermissions
+  memberPermissions
 } from "../../services/RoleService";
 import { BadRequestError } from "../../../utils/errors";
 import { Role } from "../../models";
@@ -39,19 +34,12 @@ export const createRole = async (req: Request, res: Response) => {
 
   const isOrgRole = !workspaceId; // if workspaceid is provided then its a workspace rule
   if (isOrgRole) {
-    const { permission } = await getAuthDataOrgPermissions({
-      authData: req.authData,
-      organizationId: new Types.ObjectId(orgId)
-    });
-    
+    const { permission } = await getUserOrgPermissions(req.user.id, orgId);
     if (permission.cannot(OrgPermissionActions.Create, OrgPermissionSubjects.Role)) {
       throw BadRequestError({ message: "user doesn't have the permission." });
     }
   } else {
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: new Types.ObjectId(workspaceId)
-    });
+    const { permission } = await getUserProjectPermissions(req.user.id, workspaceId);
     if (permission.cannot(ProjectPermissionActions.Create, ProjectPermissionSub.Role)) {
       throw BadRequestError({ message: "User doesn't have the permission." });
     }
@@ -87,21 +75,14 @@ export const updateRole = async (req: Request, res: Response) => {
     body: { name, description, slug, permissions, workspaceId, orgId }
   } = await validateRequest(UpdateRoleSchema, req);
   const isOrgRole = !workspaceId; // if workspaceid is provided then its a workspace rule
-  
+
   if (isOrgRole) {
-    const { permission } = await getAuthDataOrgPermissions({
-      authData: req.authData,
-      organizationId: new Types.ObjectId(orgId)
-    });
+    const { permission } = await getUserOrgPermissions(req.user.id, orgId);
     if (permission.cannot(OrgPermissionActions.Edit, OrgPermissionSubjects.Role)) {
       throw BadRequestError({ message: "User doesn't have the org permission." });
     }
   } else {
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: new Types.ObjectId(workspaceId)
-    });
-
+    const { permission } = await getUserProjectPermissions(req.user.id, workspaceId);
     if (permission.cannot(ProjectPermissionActions.Edit, ProjectPermissionSub.Role)) {
       throw BadRequestError({ message: "User doesn't have the workspace permission." });
     }
@@ -148,19 +129,12 @@ export const deleteRole = async (req: Request, res: Response) => {
 
   const isOrgRole = !role.workspace;
   if (isOrgRole) {
-    const { permission } = await getAuthDataOrgPermissions({
-      authData: req.authData,
-      organizationId: role.organization
-    });
+    const { permission } = await getUserOrgPermissions(req.user.id, role.organization.toString());
     if (permission.cannot(OrgPermissionActions.Delete, OrgPermissionSubjects.Role)) {
       throw BadRequestError({ message: "User doesn't have the org permission." });
     }
   } else {
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: role.workspace
-    });
-
+    const { permission } = await getUserProjectPermissions(req.user.id, role.workspace.toString());
     if (permission.cannot(ProjectPermissionActions.Delete, ProjectPermissionSub.Role)) {
       throw BadRequestError({ message: "User doesn't have the workspace permission." });
     }
@@ -183,19 +157,12 @@ export const getRoles = async (req: Request, res: Response) => {
 
   const isOrgRole = !workspaceId;
   if (isOrgRole) {
-    const { permission } = await getAuthDataOrgPermissions({
-      authData: req.authData,
-      organizationId: new Types.ObjectId(orgId)
-    });
+    const { permission } = await getUserOrgPermissions(req.user.id, orgId);
     if (permission.cannot(OrgPermissionActions.Read, OrgPermissionSubjects.Role)) {
       throw BadRequestError({ message: "User doesn't have the org permission." });
     }
   } else {
-    const { permission } = await getAuthDataProjectPermissions({
-      authData: req.authData,
-      workspaceId: new Types.ObjectId(workspaceId)
-    });
-
+    const { permission } = await getUserProjectPermissions(req.user.id, workspaceId);
     if (permission.cannot(ProjectPermissionActions.Read, ProjectPermissionSub.Role)) {
       throw BadRequestError({ message: "User doesn't have the workspace permission." });
     }
@@ -211,13 +178,6 @@ export const getRoles = async (req: Request, res: Response) => {
       description: "Complete administration access over the organization",
       permissions: isOrgRole ? adminPermissions.rules : adminProjectPermissions.rules
     },
-    {
-      _id: "no-access",
-      name: "No Access",
-      slug: "no-access",
-      description: "No access to any resources in the organization",
-      permissions: isOrgRole ? noAccessPermissions.rules : noAccessProjectPermissions.rules
-    },
     {
       _id: "member",
       name: isOrgRole ? "Member" : "Developer",
@@ -253,12 +213,11 @@ export const getUserPermissions = async (req: Request, res: Response) => {
     params: { orgId }
   } = await validateRequest(GetUserPermission, req);
   
-  const { permission, membership } = await getUserOrgPermissions(req.user._id, orgId);
+  const { permission } = await getUserOrgPermissions(req.user._id, orgId);
 
   res.status(200).json({
     data: {
-      permissions: packRules(permission.rules),
-      membership
+      permissions: packRules(permission.rules)
     }
   });
 };
@@ -267,24 +226,11 @@ export const getUserWorkspacePermissions = async (req: Request, res: Response) =
   const {
     params: { workspaceId }
   } = await validateRequest(GetUserProjectPermission, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-  
-  let membership;
-  if (req.authData.authPayload instanceof User) {
-    membership = await Membership.findOne({
-      user: req.authData.authPayload._id,
-      workspace: new Types.ObjectId(workspaceId)
-    })
-  }
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
 
   res.status(200).json({
     data: {
-      permissions: packRules(permission.rules),
-      membership
+      permissions: packRules(permission.rules)
     }
   });
 };

backend/src/ee/controllers/v1/secretApprovalPolicyController.ts

@@ -1,11 +1,10 @@
-import { Types } from "mongoose";
 import { ForbiddenError, subject } from "@casl/ability";
 import { Request, Response } from "express";
 import { nanoid } from "nanoid";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../services/ProjectRoleService";
 import { validateRequest } from "../../../helpers/validation";
 import { SecretApprovalPolicy } from "../../models/secretApprovalPolicy";
@@ -20,11 +19,7 @@ export const createSecretApprovalPolicy = async (req: Request, res: Response) =>
     body: { approvals, secretPath, approvers, environment, workspaceId, name }
   } = await validateRequest(reqValidator.CreateSecretApprovalRule, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.SecretApproval
@@ -54,11 +49,10 @@ export const updateSecretApprovalPolicy = async (req: Request, res: Response) =>
   const secretApproval = await SecretApprovalPolicy.findById(id);
   if (!secretApproval) throw ERR_SECRET_APPROVAL_NOT_FOUND;
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: secretApproval.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    secretApproval.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.SecretApproval
@@ -84,11 +78,10 @@ export const deleteSecretApprovalPolicy = async (req: Request, res: Response) =>
   const secretApproval = await SecretApprovalPolicy.findById(id);
   if (!secretApproval) throw ERR_SECRET_APPROVAL_NOT_FOUND;
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: secretApproval.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    secretApproval.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Delete,
     ProjectPermissionSub.SecretApproval
@@ -106,11 +99,7 @@ export const getSecretApprovalPolicy = async (req: Request, res: Response) => {
     query: { workspaceId }
   } = await validateRequest(reqValidator.GetSecretApprovalRuleList, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.SecretApproval
@@ -128,11 +117,7 @@ export const getSecretApprovalPolicyOfBoard = async (req: Request, res: Response
     query: { workspaceId, environment, secretPath }
   } = await validateRequest(reqValidator.GetSecretApprovalPolicyOfABoard, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     subject(ProjectPermissionSub.Secrets, { secretPath, environment })

backend/src/ee/controllers/v1/secretApprovalRequestsController.ts

@@ -1,6 +1,7 @@
 import { Request, Response } from "express";
+import { getUserProjectPermissions } from "../../services/ProjectRoleService";
 import { validateRequest } from "../../../helpers/validation";
-import { Folder, Membership, User } from "../../../models";
+import { Folder } from "../../../models";
 import { ApprovalStatus, SecretApprovalRequest } from "../../models/secretApprovalRequest";
 import * as reqValidator from "../../validation/secretApprovalRequest";
 import { getFolderWithPathFromId } from "../../../services/FolderService";
@@ -16,15 +17,7 @@ export const getSecretApprovalRequestCount = async (req: Request, res: Response)
     query: { workspaceId }
   } = await validateRequest(reqValidator.getSecretApprovalRequestCount, req);
 
-  if (!(req.authData.authPayload instanceof User)) return;
-
-  const membership = await Membership.findOne({
-    user: req.authData.authPayload._id,
-    workspace: new Types.ObjectId(workspaceId)
-  });
-
-  if (!membership) throw UnauthorizedRequestError();
-
+  const { membership } = await getUserProjectPermissions(req.user._id, workspaceId);
   const approvalRequestCount = await SecretApprovalRequest.aggregate([
     {
       $match: {
@@ -72,14 +65,7 @@ export const getSecretApprovalRequests = async (req: Request, res: Response) =>
     query: { status, committer, workspaceId, environment, limit, offset }
   } = await validateRequest(reqValidator.getSecretApprovalRequests, req);
 
-  if (!(req.authData.authPayload instanceof User)) return;
-
-  const membership = await Membership.findOne({
-    user: req.authData.authPayload._id,
-    workspace: new Types.ObjectId(workspaceId)
-  });
-
-  if (!membership) throw UnauthorizedRequestError();
+  const { membership } = await getUserProjectPermissions(req.user._id, workspaceId);
 
   const query = {
     workspace: new Types.ObjectId(workspaceId),
@@ -162,19 +148,14 @@ export const getSecretApprovalRequestDetails = async (req: Request, res: Respons
   if (!secretApprovalRequest)
     throw BadRequestError({ message: "Secret approval request not found" });
 
-  if (!(req.authData.authPayload instanceof User)) return;
-
-  const membership = await Membership.findOne({
-    user: req.authData.authPayload._id,
-    workspace: secretApprovalRequest.workspace
-  });
-
-  if (!membership) throw UnauthorizedRequestError();
-
+  const { membership } = await getUserProjectPermissions(
+    req.user._id,
+    secretApprovalRequest.workspace.toString()
+  );
   // allow to fetch only if its admin or is the committer or approver
   if (
     membership.role !== "admin" &&
-    !secretApprovalRequest.committer.equals(membership.id) &&
+    secretApprovalRequest.committer !== membership.id &&
     !secretApprovalRequest.policy.approvers.find(
       (approverId) => approverId.toString() === membership._id.toString()
     )
@@ -209,15 +190,10 @@ export const updateSecretApprovalReviewStatus = async (req: Request, res: Respon
   if (!secretApprovalRequest)
     throw BadRequestError({ message: "Secret approval request not found" });
 
-  if (!(req.authData.authPayload instanceof User)) return;
-
-  const membership = await Membership.findOne({
-    user: req.authData.authPayload._id,
-    workspace: secretApprovalRequest.workspace
-  });
-
-  if (!membership) throw UnauthorizedRequestError();
-
+  const { membership } = await getUserProjectPermissions(
+    req.user._id,
+    secretApprovalRequest.workspace.toString()
+  );
   if (
     membership.role !== "admin" &&
     secretApprovalRequest.committer !== membership.id &&
@@ -251,15 +227,10 @@ export const mergeSecretApprovalRequest = async (req: Request, res: Response) =>
   if (!secretApprovalRequest)
     throw BadRequestError({ message: "Secret approval request not found" });
 
-  if (!(req.authData.authPayload instanceof User)) return;
-
-  const membership = await Membership.findOne({
-    user: req.authData.authPayload._id,
-    workspace: secretApprovalRequest.workspace
-  });
-
-  if (!membership) throw UnauthorizedRequestError();
-
+  const { membership } = await getUserProjectPermissions(
+    req.user._id,
+    secretApprovalRequest.workspace.toString()
+  );
   if (
     membership.role !== "admin" &&
     secretApprovalRequest.committer !== membership.id &&
@@ -301,14 +272,10 @@ export const updateSecretApprovalRequestStatus = async (req: Request, res: Respo
   if (!secretApprovalRequest)
     throw BadRequestError({ message: "Secret approval request not found" });
 
-  if (!(req.authData.authPayload instanceof User)) return;
-
-  const membership = await Membership.findOne({
-    user: req.authData.authPayload._id,
-    workspace: secretApprovalRequest.workspace
-  });
-
-  if (!membership) throw UnauthorizedRequestError();
+  const { membership } = await getUserProjectPermissions(
+    req.user._id,
+    secretApprovalRequest.workspace.toString()
+  );
 
   if (
     membership.role !== "admin" &&

backend/src/ee/controllers/v1/secretController.ts

@@ -5,7 +5,7 @@ import { Folder, Secret } from "../../../models";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../services/ProjectRoleService";
 import { BadRequestError } from "../../../utils/errors";
 import * as reqValidator from "../../../validation";
@@ -74,11 +74,7 @@ export const getSecretVersions = async (req: Request, res: Response) => {
     throw BadRequestError({ message: "Failed to find secret" });
   }
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: secret.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, secret.workspace.toString());
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.SecretRollback
@@ -161,12 +157,10 @@ export const rollbackSecretVersion = async (req: Request, res: Response) => {
   if (!toBeUpdatedSec) {
     throw BadRequestError({ message: "Failed to find secret" });
   }
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: toBeUpdatedSec.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    toBeUpdatedSec.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.SecretRollback

backend/src/ee/controllers/v1/secretRotationController.ts

@@ -1,110 +0,0 @@
-import { Request, Response } from "express";
-import { Types } from "mongoose";
-import { validateRequest } from "../../../helpers/validation";
-import * as reqValidator from "../../validation/secretRotation";
-import * as secretRotationService from "../../secretRotation/service";
-import {
-  ProjectPermissionActions,
-  ProjectPermissionSub,
-  getAuthDataProjectPermissions
-} from "../../services/ProjectRoleService";
-import { ForbiddenError } from "@casl/ability";
-
-export const createSecretRotation = async (req: Request, res: Response) => {
-  const {
-    body: {
-      provider,
-      customProvider,
-      interval,
-      outputs,
-      secretPath,
-      environment,
-      workspaceId,
-      inputs
-    }
-  } = await validateRequest(reqValidator.createSecretRotationV1, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Create,
-    ProjectPermissionSub.SecretRotation
-  );
-
-  const secretRotation = await secretRotationService.createSecretRotation({
-    workspaceId,
-    inputs,
-    environment,
-    secretPath,
-    outputs,
-    interval,
-    customProvider,
-    provider
-  });
-
-  return res.send({ secretRotation });
-};
-
-export const restartSecretRotations = async (req: Request, res: Response) => {
-  const {
-    body: { id }
-  } = await validateRequest(reqValidator.restartSecretRotationV1, req);
-
-  const doc = await secretRotationService.getSecretRotationById({ id });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: doc.workspace
-  });
-
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Edit,
-    ProjectPermissionSub.SecretRotation
-  );
-
-  const secretRotation = await secretRotationService.restartSecretRotation({ id });
-  return res.send({ secretRotation });
-};
-
-export const deleteSecretRotations = async (req: Request, res: Response) => {
-  const {
-    params: { id }
-  } = await validateRequest(reqValidator.removeSecretRotationV1, req);
-
-  const doc = await secretRotationService.getSecretRotationById({ id });
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: doc.workspace
-  });
-
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Delete,
-    ProjectPermissionSub.SecretRotation
-  );
-
-  const secretRotations = await secretRotationService.deleteSecretRotation({ id });
-  return res.send({ secretRotations });
-};
-
-export const getSecretRotations = async (req: Request, res: Response) => {
-  const {
-    query: { workspaceId }
-  } = await validateRequest(reqValidator.getSecretRotationV1, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Read,
-    ProjectPermissionSub.SecretRotation
-  );
-
-  const secretRotations = await secretRotationService.getSecretRotationOfWorkspace(workspaceId);
-  return res.send({ secretRotations });
-};

backend/src/ee/controllers/v1/secretRotationProviderController.ts

@@ -1,33 +0,0 @@
-import { Request, Response } from "express";
-import { Types } from "mongoose";
-import { validateRequest } from "../../../helpers/validation";
-import * as reqValidator from "../../validation/secretRotationProvider";
-import * as secretRotationProviderService from "../../secretRotation/service";
-import {
-  ProjectPermissionActions,
-  ProjectPermissionSub,
-  getAuthDataProjectPermissions
-} from "../../services/ProjectRoleService";
-import { ForbiddenError } from "@casl/ability";
-
-export const getProviderTemplates = async (req: Request, res: Response) => {
-  const {
-    params: { workspaceId }
-  } = await validateRequest(reqValidator.getSecretRotationProvidersV1, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
-  ForbiddenError.from(permission).throwUnlessCan(
-    ProjectPermissionActions.Read,
-    ProjectPermissionSub.SecretRotation
-  );
-
-  const rotationProviderList = await secretRotationProviderService.getProviderTemplate({
-    workspaceId
-  });
-
-  return res.send(rotationProviderList);
-};

backend/src/ee/controllers/v1/secretSnapshotController.ts

@@ -4,7 +4,7 @@ import { validateRequest } from "../../../helpers/validation";
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../services/ProjectRoleService";
 import * as reqValidator from "../../../validation/secretSnapshot";
 import { ISecretVersion, SecretSnapshot, TFolderRootVersionSchema } from "../../models";
@@ -33,11 +33,10 @@ export const getSecretSnapshot = async (req: Request, res: Response) => {
 
   if (!secretSnapshot) throw new Error("Failed to find secret snapshot");
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: secretSnapshot.workspace
-  });
-
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    secretSnapshot.workspace.toString()
+  );
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.SecretRollback

backend/src/ee/controllers/v1/ssoController.ts

@@ -13,7 +13,7 @@ import { validateRequest } from "../../../helpers/validation";
 import {
   OrgPermissionActions,
   OrgPermissionSubjects,
-  getAuthDataOrgPermissions
+  getUserOrgPermissions
 } from "../../services/RoleService";
 import { ForbiddenError } from "@casl/ability";
 
@@ -47,10 +47,7 @@ export const getSSOConfig = async (req: Request, res: Response) => {
     query: { organizationId }
   } = await validateRequest(reqValidator.GetSsoConfigv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Read,
     OrgPermissionSubjects.Sso
@@ -74,10 +71,7 @@ export const updateSSOConfig = async (req: Request, res: Response) => {
     body: { organizationId, authProvider, isActive, entryPoint, issuer, cert }
   } = await validateRequest(reqValidator.UpdateSsoConfigv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Edit,
     OrgPermissionSubjects.Sso
@@ -212,10 +206,7 @@ export const createSSOConfig = async (req: Request, res: Response) => {
     body: { organizationId, authProvider, isActive, entryPoint, issuer, cert }
   } = await validateRequest(reqValidator.CreateSsoConfigv1, req);
 
-  const { permission } = await getAuthDataOrgPermissions({
-    authData: req.authData,
-    organizationId: new Types.ObjectId(organizationId)
-  });
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
   ForbiddenError.from(permission).throwUnlessCan(
     OrgPermissionActions.Create,
     OrgPermissionSubjects.Sso

backend/src/ee/controllers/v1/workspaceController.ts

@@ -2,11 +2,10 @@ import { Request, Response } from "express";
 import { PipelineStage, Types } from "mongoose";
 import {
   Folder,
-  Identity,
-  IdentityMembership,
   Membership,
   Secret,
   ServiceTokenData,
+  ServiceTokenDataV3,
   TFolderSchema,
   User,
   Workspace
@@ -18,16 +17,18 @@ import {
   FolderVersion,
   IPType,
   ISecretVersion,
-  IdentityActor,
+  Log,
   SecretSnapshot,
   SecretVersion,
   ServiceActor,
+  ServiceActorV3,
   TFolderRootVersionSchema,
   TrustedIP,
   UserActor
 } from "../../models";
 import { EESecretService } from "../../services";
 import { getLatestSecretVersionIds } from "../../helpers/secretVersion";
+// import Folder, { TFolderSchema } from "../../../models/folder";
 import { getFolderByPath, searchByFolderId } from "../../../services/FolderService";
 import { EEAuditLogService, EELicenseService } from "../../services";
 import { extractIPDetails, isValidIpOrCidr } from "../../../utils/ip";
@@ -37,6 +38,7 @@ import {
   DeleteWorkspaceTrustedIpV1,
   GetWorkspaceAuditLogActorFilterOptsV1,
   GetWorkspaceAuditLogsV1,
+  GetWorkspaceLogsV1,
   GetWorkspaceSecretSnapshotsCountV1,
   GetWorkspaceSecretSnapshotsV1,
   GetWorkspaceTrustedIpsV1,
@@ -46,7 +48,7 @@ import {
 import {
   ProjectPermissionActions,
   ProjectPermissionSub,
-  getAuthDataProjectPermissions
+  getUserProjectPermissions
 } from "../../services/ProjectRoleService";
 import { ForbiddenError } from "@casl/ability";
 import { BadRequestError } from "../../../utils/errors";
@@ -62,30 +64,15 @@ export const getWorkspaceSecretSnapshots = async (req: Request, res: Response) =
     #swagger.description = 'Return project secret snapshots ids'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
 	#swagger.parameters['workspaceId'] = {
-		"description": "ID of project where to get secret snapshots for",
+		"description": "ID of project",
 		"required": true,
 		"type": "string"
 	} 
 
-	#swagger.parameters['environment'] = {
-      "description": "Slug of environment where to get secret snapshots for",
-      "required": true,
-      "type": "string",
-      "in": "query"
-  }
-
-  #swagger.parameters['directory'] = {
-      "description": "Path where to get secret snapshots for like / or /foo/bar. Default is /",
-      "required": false,
-      "type": "string",
-      "in": "query"
-  }
-
 	#swagger.parameters['offset'] = {
 		"description": "Number of secret snapshots to skip",
 		"required": false,
@@ -122,11 +109,7 @@ export const getWorkspaceSecretSnapshots = async (req: Request, res: Response) =
     query: { environment, directory, offset, limit }
   } = await validateRequest(GetWorkspaceSecretSnapshotsV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.SecretRollback
@@ -167,11 +150,7 @@ export const getWorkspaceSecretSnapshotsCount = async (req: Request, res: Respon
     query: { environment, directory }
   } = await validateRequest(GetWorkspaceSecretSnapshotsCountV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.SecretRollback
@@ -210,12 +189,11 @@ export const rollbackWorkspaceSecretSnapshot = async (req: Request, res: Respons
     #swagger.description = 'Roll back project secrets to those captured in a secret snapshot version.'
     
     #swagger.security = [{
-        "apiKeyAuth": [],
-        "bearerAuth": []
+        "apiKeyAuth": []
     }]
 
 	#swagger.parameters['workspaceId'] = {
-		"description": "ID of project where to roll back",
+		"description": "ID of project",
 		"required": true,
 		"type": "string"
 	} 
@@ -227,14 +205,6 @@ export const rollbackWorkspaceSecretSnapshot = async (req: Request, res: Respons
           "schema": {
             "type": "object",
             "properties": {
-                "environment": {
-                  "type": "string",
-                  "description": "Slug of environment where to roll back"
-                },
-                "directory": {
-                  "type": "string",
-                  "description": "Path where to roll back for like / or /foo/bar. Default is /"
-                },
                 "version": {
                     "type": "integer",
                     "description": "Version of secret snapshot to roll back to",
@@ -270,11 +240,7 @@ export const rollbackWorkspaceSecretSnapshot = async (req: Request, res: Respons
     body: { directory, environment, version }
   } = await validateRequest(RollbackWorkspaceSecretSnapshotV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.SecretRollback
@@ -598,117 +564,128 @@ export const rollbackWorkspaceSecretSnapshot = async (req: Request, res: Respons
 };
 
 /**
- * Return audit logs for workspace with id [workspaceId]
+ * Return (audit) logs for workspace with id [workspaceId]
  * @param req
  * @param res
+ * @returns
  */
-export const getWorkspaceAuditLogs = async (req: Request, res: Response) => {
+export const getWorkspaceLogs = async (req: Request, res: Response) => {
   /* 
-    #swagger.summary = 'Return audit logs'
-    #swagger.description = 'Return audit logs'
+    #swagger.summary = 'Return project (audit) logs'
+    #swagger.description = 'Return project (audit) logs'
     
     #swagger.security = [{
-      "apiKeyAuth": []
+        "apiKeyAuth": []
     }]
 
-    #swagger.parameters['workspaceId'] = {
-      "description": "ID of the workspace where to get folders from",
-      "required": true,
-      "type": "string",
-      "in": "path"
-    }
+	#swagger.parameters['workspaceId'] = {
+		"description": "ID of project",
+		"required": true,
+		"type": "string"
+	} 
 
-    #swagger.parameters['offset'] = {
-      "description": "Number of logs to skip before starting to return logs for pagination",
-      "required": false,
-      "type": "string"
-    }
+	#swagger.parameters['userId'] = {
+		"description": "ID of project member",
+		"required": false,
+		"type": "string"
+	} 
 
-    #swagger.parameters['limit'] = {
-      "description": "Maximum number of logs to return for pagination",
-      "required": false,
-      "type": "string"
-    }
+	#swagger.parameters['offset'] = {
+		"description": "Number of logs to skip",
+		"required": false,
+		"type": "string"
+	}
 
-   #swagger.parameters['startDate'] = {
-      "description": "Filter logs from this date in ISO-8601 format",
-      "required": false,
-      "type": "string"
-    }
+	#swagger.parameters['limit'] = {
+		"description": "Maximum number of logs to return",
+		"required": false,
+		"type": "string"
+	}
 
-   #swagger.parameters['endDate'] = {
-      "description": "Filter logs till this date in ISO-8601 format",
-      "required": false,
-      "type": "string"
-    }
+	#swagger.parameters['sortBy'] = {
+		"description": "Order to sort the logs by",
+		"schema": {
+			"type": "string",
+			"@enum": ["oldest", "recent"]
+		},
+		"required": false
+	}
 
-    #swagger.parameters['eventType'] = {
-      "description": "Filter by type of event such as get-secrets, get-secret, create-secret, update-secret, delete-secret, etc.",
-      "required": false,
-      "type": "string",
-    }
-
-    #swagger.parameters['userAgentType'] = {
-      "description": "Filter by type of user agent such as web, cli, k8-operator, or other",
-      "required": false,
-      "type": "string",
-    }
-
-    #swagger.parameters['actor'] = {
-      "description": "Filter by actor such as user or service",
-      "required": false,
-      "type": "string"
-    }
+	#swagger.parameters['actionNames'] = {
+		"description": "Names of log actions (comma-separated)",
+		"required": false,
+		"type": "string"
+	}
 
     #swagger.responses[200] = {
         content: {
             "application/json": {
                 schema: { 
-                  "type": "object",
-                  "properties": {
-                        "auditLogs": {
-                            "type": "array",
-                            "items": {
-			      $ref: "#/components/schemas/AuditLog",
-                            },
-                            "description": "List of audit log"                        
-                          },
-                  }
+					"type": "object",
+					"properties": {
+						"logs": {
+							"type": "array",
+							"items": {
+								$ref: "#/components/schemas/Log" 
+							},
+							"description": "Project logs"
+						}
+					}
                 }
             }           
         }
     }   
     */
   const {
-    query: { limit, offset, endDate, eventType, startDate, userAgentType, actor },
+    query: { limit, offset, userId, sortBy, actionNames },
     params: { workspaceId }
-  } = await validateRequest(GetWorkspaceAuditLogsV1, req);
-
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
+  } = await validateRequest(GetWorkspaceLogsV1, req);
 
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.AuditLogs
   );
 
-  let actorMetadataQuery = "";
-  if (actor) {
-    switch (actor?.split("-", 2)[0]) {
-      case ActorType.USER:
-        actorMetadataQuery = "actor.metadata.userId";
-        break;
-      case ActorType.SERVICE:
-        actorMetadataQuery = "actor.metadata.serviceId";
-        break;
-      case ActorType.IDENTITY:
-        actorMetadataQuery = "actor.metadata.identityId";
-        break;
-    }
-  }
+  const logs = await Log.find({
+    workspace: workspaceId,
+    ...(userId ? { user: userId } : {}),
+    ...(actionNames
+      ? {
+          actionNames: {
+            $in: actionNames.split(",")
+          }
+        }
+      : {})
+  })
+    .sort({ createdAt: sortBy === "recent" ? -1 : 1 })
+    .skip(offset)
+    .limit(limit)
+    .populate("actions")
+    .populate("user serviceAccount serviceTokenData");
 
+  return res.status(200).send({
+    logs
+  });
+};
+
+/**
+ * Return audit logs for workspace with id [workspaceId]
+ * @param req
+ * @param res
+ */
+export const getWorkspaceAuditLogs = async (req: Request, res: Response) => {
+  const {
+    query: { limit, offset, endDate, eventType, startDate, userAgentType, actor },
+    params: { workspaceId }
+  } = await validateRequest(GetWorkspaceAuditLogsV1, req);
+
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Read,
+    ProjectPermissionSub.AuditLogs
+  );
+  
   const query = {
     workspace: new Types.ObjectId(workspaceId),
     ...(eventType
@@ -724,9 +701,13 @@ export const getWorkspaceAuditLogs = async (req: Request, res: Response) => {
     ...(actor
       ? {
           "actor.type": actor.substring(0, actor.lastIndexOf("-")),
-          ...({
-            [actorMetadataQuery]: actor.substring(actor.lastIndexOf("-") + 1)
-          })
+          ...(actor.split("-", 2)[0] === ActorType.USER
+            ? {
+                "actor.metadata.userId": actor.substring(actor.lastIndexOf("-") + 1)
+              }
+            : {
+                "actor.metadata.serviceId": actor.substring(actor.lastIndexOf("-") + 1)
+              })
         }
       : {}),
     ...(startDate || endDate
@@ -738,11 +719,14 @@ export const getWorkspaceAuditLogs = async (req: Request, res: Response) => {
         }
       : {})
   };
-  
+
   const auditLogs = await AuditLog.find(query).sort({ createdAt: -1 }).skip(offset).limit(limit);
-  
+
+  const totalCount = await AuditLog.countDocuments(query);
+
   return res.status(200).send({
-    auditLogs
+    auditLogs,
+    totalCount
   });
 };
 
@@ -756,11 +740,7 @@ export const getWorkspaceAuditLogActorFilterOpts = async (req: Request, res: Res
     params: { workspaceId }
   } = await validateRequest(GetWorkspaceAuditLogActorFilterOptsV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.AuditLogs
@@ -769,7 +749,6 @@ export const getWorkspaceAuditLogActorFilterOpts = async (req: Request, res: Res
   const userIds = await Membership.distinct("user", {
     workspace: new Types.ObjectId(workspaceId)
   });
-  
   const userActors: UserActor[] = (
     await User.find({
       _id: {
@@ -795,26 +774,24 @@ export const getWorkspaceAuditLogActorFilterOpts = async (req: Request, res: Res
       name: serviceTokenData.name
     }
   }));
-
-  const identityIds = await IdentityMembership.distinct("identity", {
-    workspace: new Types.ObjectId(workspaceId)
-  });
   
-  const identityActors: IdentityActor[] = (
-    await Identity.find({
-      _id: {
-        $in: identityIds
-      }
+  const serviceV3Actors: ServiceActorV3[] = (
+    await ServiceTokenDataV3.find({
+      workspace: new Types.ObjectId(workspaceId)
     })
-  ).map((identity) => ({
-    type: ActorType.IDENTITY,
+  ).map((serviceTokenData) => ({
+    type: ActorType.SERVICE_V3,
     metadata: {
-      identityId: identity._id.toString(),
-      name: identity.name
+      serviceId: serviceTokenData._id.toString(),
+      name: serviceTokenData.name
     }
   }));
-
-  const actors = [...userActors, ...serviceActors, ...identityActors];
+  
+  const actors = [
+    ...userActors, 
+    ...serviceActors,
+    ...serviceV3Actors
+  ];
 
   return res.status(200).send({
     actors
@@ -831,11 +808,7 @@ export const getWorkspaceTrustedIps = async (req: Request, res: Response) => {
     params: { workspaceId }
   } = await validateRequest(GetWorkspaceTrustedIpsV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Read,
     ProjectPermissionSub.IpAllowList
@@ -861,11 +834,7 @@ export const addWorkspaceTrustedIp = async (req: Request, res: Response) => {
     body: { comment, isActive, ipAddress: ip }
   } = await validateRequest(AddWorkspaceTrustedIpV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Create,
     ProjectPermissionSub.IpAllowList
@@ -931,11 +900,7 @@ export const updateWorkspaceTrustedIp = async (req: Request, res: Response) => {
     body: { ipAddress: ip, comment }
   } = await validateRequest(UpdateWorkspaceTrustedIpV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Edit,
     ProjectPermissionSub.IpAllowList
@@ -1027,11 +992,7 @@ export const deleteWorkspaceTrustedIp = async (req: Request, res: Response) => {
     params: { workspaceId, trustedIpId }
   } = await validateRequest(DeleteWorkspaceTrustedIpV1, req);
 
-  const { permission } = await getAuthDataProjectPermissions({
-    authData: req.authData,
-    workspaceId: new Types.ObjectId(workspaceId)
-  });
-
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
   ForbiddenError.from(permission).throwUnlessCan(
     ProjectPermissionActions.Delete,
     ProjectPermissionSub.IpAllowList

backend/src/ee/controllers/v3/index.ts

@@ -1,5 +1,7 @@
+import * as serviceTokenDataController from "./serviceTokenDataController";
 import * as apiKeyDataController from "./apiKeyDataController";
 
 export {
+    serviceTokenDataController,
     apiKeyDataController
 }

backend/src/ee/controllers/v3/serviceTokenDataController.ts

@@ -0,0 +1,325 @@
+import { Request, Response } from "express";
+import { Types } from "mongoose";
+import { 
+    IServiceTokenDataV3,
+    IUser,
+    ServiceTokenDataV3,
+    ServiceTokenDataV3Key,
+    Workspace
+} from "../../../models";
+import {
+    IServiceTokenV3Scope, 
+    IServiceTokenV3TrustedIp 
+} from "../../../models/serviceTokenDataV3";
+import {
+    ActorType,
+    EventType
+} from "../../models";
+import { validateRequest } from "../../../helpers/validation";
+import * as reqValidator from "../../../validation/serviceTokenDataV3";
+import { createToken } from "../../../helpers/auth";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  getUserProjectPermissions
+} from "../../services/ProjectRoleService";
+import { ForbiddenError } from "@casl/ability"; 
+import { BadRequestError, ResourceNotFoundError } from "../../../utils/errors";
+import { extractIPDetails, isValidIpOrCidr } from "../../../utils/ip";
+import { EEAuditLogService, EELicenseService } from "../../services";
+import { getJwtServiceTokenSecret } from "../../../config";
+
+/**
+ * Return project key for service token V3
+ * @param req 
+ * @param res 
+ */
+export const getServiceTokenDataKey = async (req: Request, res: Response) => {
+    const key = await ServiceTokenDataV3Key.findOne({
+        serviceTokenData: (req.authData.authPayload as IServiceTokenDataV3)._id
+    }).populate<{ sender: IUser }>("sender", "publicKey");
+    
+    if (!key) throw ResourceNotFoundError({
+        message: "Failed to find project key for service token"
+    });
+    
+    const { _id, workspace, encryptedKey, nonce, sender: { publicKey } } = key;
+    
+    return res.status(200).send({
+        key: {
+            _id,
+            workspace,
+            encryptedKey,
+            publicKey,
+            nonce
+        }
+    });
+}
+
+/**
+ * Create service token data V3
+ * @param req 
+ * @param res 
+ * @returns 
+ */
+export const createServiceTokenData = async (req: Request, res: Response) => {
+    const {
+        body: { 
+            name, 
+            workspaceId, 
+            publicKey, 
+            scopes,
+            trustedIps,
+            expiresIn, 
+            encryptedKey, // for ServiceTokenDataV3Key
+            nonce // for ServiceTokenDataV3Key
+        }
+    } = await validateRequest(reqValidator.CreateServiceTokenV3, req);
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    ForbiddenError.from(permission).throwUnlessCan(
+        ProjectPermissionActions.Create,
+        ProjectPermissionSub.ServiceTokens
+    );
+    
+    const workspace = await Workspace.findById(workspaceId);
+    if (!workspace) throw BadRequestError({ message: "Workspace not found" });
+
+    const plan = await EELicenseService.getPlan(workspace.organization);
+    
+    // validate trusted ips
+    const reformattedTrustedIps = trustedIps.map((trustedIp) => {
+        if (!plan.ipAllowlisting && trustedIp.ipAddress !== "0.0.0.0/0") return res.status(400).send({
+            message: "Failed to add IP access range to service token due to plan restriction. Upgrade plan to add IP access range."
+        });
+
+        const isValidIPOrCidr = isValidIpOrCidr(trustedIp.ipAddress);
+        
+        if (!isValidIPOrCidr) return res.status(400).send({
+            message: "The IP is not a valid IPv4, IPv6, or CIDR block"
+        });
+        
+        return extractIPDetails(trustedIp.ipAddress);
+    });
+    
+    let expiresAt;
+    if (expiresIn) {
+        expiresAt = new Date();
+        expiresAt.setSeconds(expiresAt.getSeconds() + expiresIn);
+    }
+    
+    let user;
+    if (req.authData.actor.type === ActorType.USER) {
+        user = req.authData.authPayload._id;
+    }
+    
+    const isActive = true;
+    const serviceTokenData = await new ServiceTokenDataV3({
+        name,
+        user,
+        workspace: new Types.ObjectId(workspaceId),
+        publicKey,
+        usageCount: 0,
+        trustedIps: reformattedTrustedIps,
+        scopes,
+        isActive,
+        expiresAt
+    }).save();
+    
+    await new ServiceTokenDataV3Key({
+        encryptedKey,
+        nonce,
+        sender: req.user._id,
+        serviceTokenData: serviceTokenData._id,
+        workspace: new Types.ObjectId(workspaceId)
+    }).save();
+    
+    const token = createToken({
+        payload: {
+            _id: serviceTokenData._id.toString()
+        },
+        expiresIn,
+        secret: await getJwtServiceTokenSecret()
+    });
+    
+    await EEAuditLogService.createAuditLog(
+        req.authData,
+        {
+            type: EventType.CREATE_SERVICE_TOKEN_V3,
+            metadata: {
+                name,
+                isActive,
+                scopes: scopes as Array<IServiceTokenV3Scope>,
+                trustedIps: reformattedTrustedIps as Array<IServiceTokenV3TrustedIp>,
+                expiresAt
+            }
+        },
+        {
+            workspaceId: new Types.ObjectId(workspaceId)
+        }
+    );
+    
+    return res.status(200).send({
+        serviceTokenData,
+        serviceToken: `stv3.${token}`
+    });
+}
+
+/**
+ * Update service token V3 data with id [serviceTokenDataId]
+ * @param req 
+ * @param res 
+ * @returns 
+ */
+export const updateServiceTokenData = async (req: Request, res: Response) => {
+    const {
+        params: { serviceTokenDataId },
+        body: { 
+            name, 
+            isActive,
+            scopes,
+            trustedIps,
+            expiresIn
+        }
+    } = await validateRequest(reqValidator.UpdateServiceTokenV3, req);
+
+    let serviceTokenData = await ServiceTokenDataV3.findById(serviceTokenDataId);
+    if (!serviceTokenData) throw ResourceNotFoundError({ 
+        message: "Service token not found" 
+    });
+    
+    const { permission } = await getUserProjectPermissions(
+        req.user._id,
+        serviceTokenData.workspace.toString()
+    );
+    
+    ForbiddenError.from(permission).throwUnlessCan(
+        ProjectPermissionActions.Edit,
+        ProjectPermissionSub.ServiceTokens
+    );
+
+    const workspace = await Workspace.findById(serviceTokenData.workspace);
+    if (!workspace) throw BadRequestError({ message: "Workspace not found" });
+
+    const plan = await EELicenseService.getPlan(workspace.organization);
+
+    // validate trusted ips
+    let reformattedTrustedIps;
+    if (trustedIps) {
+        reformattedTrustedIps = trustedIps.map((trustedIp) => {
+            if (!plan.ipAllowlisting && trustedIp.ipAddress !== "0.0.0.0/0") return res.status(400).send({
+                message: "Failed to update IP access range to service token due to plan restriction. Upgrade plan to update IP access range."
+            });
+
+            const isValidIPOrCidr = isValidIpOrCidr(trustedIp.ipAddress);
+            
+            if (!isValidIPOrCidr) return res.status(400).send({
+                message: "The IP is not a valid IPv4, IPv6, or CIDR block"
+            });
+            
+            return extractIPDetails(trustedIp.ipAddress);
+        });
+    }
+
+    let expiresAt;
+    if (expiresIn) {
+        expiresAt = new Date();
+        expiresAt.setSeconds(expiresAt.getSeconds() + expiresIn);
+    }
+    
+    serviceTokenData = await ServiceTokenDataV3.findByIdAndUpdate(
+        serviceTokenDataId,
+        {
+            name,
+            isActive,
+            scopes,
+            trustedIps: reformattedTrustedIps,
+            expiresAt
+        },
+        {
+            new: true
+        }
+    );
+    
+    if (!serviceTokenData) throw BadRequestError({
+        message: "Failed to update service token"
+    });
+
+    await EEAuditLogService.createAuditLog(
+        req.authData,
+        {
+            type: EventType.UPDATE_SERVICE_TOKEN_V3,
+            metadata: {
+                name: serviceTokenData.name,
+                isActive,
+                scopes: scopes as Array<IServiceTokenV3Scope>,
+                trustedIps: reformattedTrustedIps as Array<IServiceTokenV3TrustedIp>,
+                expiresAt
+            }
+        },
+        {
+            workspaceId: serviceTokenData.workspace
+        }
+    );
+
+    return res.status(200).send({
+        serviceTokenData
+    }); 
+}
+
+/**
+ * Delete service token data with id [serviceTokenDataId]
+ * @param req 
+ * @param res 
+ * @returns 
+ */
+export const deleteServiceTokenData = async (req: Request, res: Response) => {
+    const {
+        params: { serviceTokenDataId }
+    } = await validateRequest(reqValidator.DeleteServiceTokenV3, req);
+    
+    let serviceTokenData = await ServiceTokenDataV3.findById(serviceTokenDataId);
+    if (!serviceTokenData) throw ResourceNotFoundError({ 
+        message: "Service token not found" 
+    });
+    
+    const { permission } = await getUserProjectPermissions(
+        req.user._id,
+        serviceTokenData.workspace.toString()
+    );
+    
+    ForbiddenError.from(permission).throwUnlessCan(
+        ProjectPermissionActions.Delete,
+        ProjectPermissionSub.ServiceTokens
+    );
+    
+    serviceTokenData = await ServiceTokenDataV3.findByIdAndDelete(serviceTokenDataId);
+    
+    if (!serviceTokenData) throw BadRequestError({
+        message: "Failed to delete service token"
+    });
+    
+    await ServiceTokenDataV3Key.findOneAndDelete({
+        serviceTokenData: serviceTokenData._id
+    });
+    
+    await EEAuditLogService.createAuditLog(
+        req.authData,
+        {
+            type: EventType.DELETE_SERVICE_TOKEN_V3,
+            metadata: {
+                name: serviceTokenData.name,
+                isActive: serviceTokenData.isActive,
+                scopes: serviceTokenData.scopes as Array<IServiceTokenV3Scope>,
+                trustedIps: serviceTokenData.trustedIps as Array<IServiceTokenV3TrustedIp>,
+                expiresAt: serviceTokenData.expiresAt
+            }
+        },
+        {
+            workspaceId: serviceTokenData.workspace
+        }
+    );
+
+    return res.status(200).send({
+        serviceTokenData
+    }); 
+}

backend/src/ee/helpers/action.ts

@@ -0,0 +1,195 @@
+import { Types } from "mongoose";
+import { Action } from "../models";
+import { 
+    getLatestNSecretSecretVersionIds,
+    getLatestSecretVersionIds,
+} from "../helpers/secretVersion";
+import { 
+    ACTION_ADD_SECRETS,
+    ACTION_DELETE_SECRETS,
+    ACTION_LOGIN,
+    ACTION_LOGOUT,
+    ACTION_READ_SECRETS,
+    ACTION_UPDATE_SECRETS,
+} from "../../variables";
+
+/**
+ * Create an (audit) action for updating secrets
+ * @param {Object} obj
+ * @param {String} obj.name - name of action
+ * @param {Types.ObjectId} obj.secretIds - ids of relevant secrets
+ * @returns {Action} action - new action
+ */
+const createActionUpdateSecret = async ({
+    name,
+    userId,
+    serviceAccountId,
+    serviceTokenDataId,
+    workspaceId,
+    secretIds,
+}: {
+    name: string;
+    userId?: Types.ObjectId;
+    serviceAccountId?: Types.ObjectId;
+    serviceTokenDataId?: Types.ObjectId;
+    workspaceId: Types.ObjectId;
+    secretIds: Types.ObjectId[];
+}) => {
+    const latestSecretVersions = (await getLatestNSecretSecretVersionIds({
+            secretIds,
+            n: 2,
+        }))
+        .map((s) => ({
+            oldSecretVersion: s.versions[0]._id,
+            newSecretVersion: s.versions[1]._id,
+        }));
+    
+    const action = await new Action({
+        name,
+        user: userId,
+        serviceAccount: serviceAccountId,
+        serviceTokenData: serviceTokenDataId,
+        workspace: workspaceId,
+        payload: {
+            secretVersions: latestSecretVersions,
+        },
+    }).save();
+    
+    return action;
+}
+
+/**
+ * Create an (audit) action for creating, reading, and deleting
+ * secrets
+ * @param {Object} obj
+ * @param {String} obj.name - name of action
+ * @param {Types.ObjectId} obj.secretIds - ids of relevant secrets
+ * @returns {Action} action - new action
+ */
+const createActionSecret = async ({
+    name,
+    userId,
+    serviceAccountId,
+    serviceTokenDataId,
+    workspaceId,
+    secretIds,
+}: {
+    name: string;
+    userId?: Types.ObjectId;
+    serviceAccountId?: Types.ObjectId;
+    serviceTokenDataId?: Types.ObjectId;
+    workspaceId: Types.ObjectId;
+    secretIds: Types.ObjectId[];
+}) => {
+    // case: action is adding, deleting, or reading secrets
+    // -> add new secret versions
+    const latestSecretVersions = (await getLatestSecretVersionIds({
+        secretIds,
+    }))
+    .map((s) => ({
+        newSecretVersion: s.versionId,
+    }));
+    
+   const action = await new Action({
+        name,
+        user: userId,
+        serviceAccount: serviceAccountId,
+        serviceTokenData: serviceTokenDataId,
+        workspace: workspaceId,
+        payload: {
+            secretVersions: latestSecretVersions,
+        },
+    }).save(); 
+    
+    return action;
+}
+
+/**
+ * Create an (audit) action for client with id [userId],
+ * [serviceAccountId], or [serviceTokenDataId]
+ * @param {Object} obj 
+ * @param {String} obj.name - name of action
+ * @param {String} obj.userId - id of user associated with action
+ * @returns 
+ */
+const createActionClient = ({
+    name,
+    userId,
+    serviceAccountId,
+    serviceTokenDataId,
+}: {
+    name: string;
+    userId?: Types.ObjectId;
+    serviceAccountId?: Types.ObjectId;
+    serviceTokenDataId?: Types.ObjectId;
+}) => {
+    const action = new Action({
+        name,
+        user: userId,
+        serviceAccount: serviceAccountId,
+        serviceTokenData: serviceTokenDataId,
+    }).save();
+
+    return action; 
+}
+
+/**
+ * Create an (audit) action. 
+ * @param {Object} obj
+ * @param {Object} obj.name - name of action
+ * @param {Types.ObjectId} obj.userId - id of user associated with action
+ * @param {Types.ObjectId} obj.workspaceId - id of workspace associated with action
+ * @param {Types.ObjectId[]} obj.secretIds - ids of secrets associated with action
+*/
+const createActionHelper = async ({
+    name,
+    userId,
+    serviceAccountId,
+    serviceTokenDataId,
+    workspaceId,
+    secretIds,
+}: {
+    name: string;
+    userId?: Types.ObjectId;
+    serviceAccountId?: Types.ObjectId;
+    serviceTokenDataId?: Types.ObjectId;
+    workspaceId?: Types.ObjectId;
+    secretIds?: Types.ObjectId[];
+}) => {
+    let action;
+    switch (name) {
+        case ACTION_LOGIN:
+        case ACTION_LOGOUT:
+            action = await createActionClient({
+                name,
+                userId,
+            });
+            break;
+        case ACTION_ADD_SECRETS:
+        case ACTION_READ_SECRETS:
+        case ACTION_DELETE_SECRETS:
+            if (!workspaceId || !secretIds) throw new Error("Missing required params workspace id or secret ids to create action secret");
+            action = await createActionSecret({
+                name,
+                userId,
+                workspaceId,
+                secretIds,
+            });
+            break;
+        case ACTION_UPDATE_SECRETS:
+            if (!workspaceId || !secretIds) throw new Error("Missing required params workspace id or secret ids to create action secret");
+            action = await createActionUpdateSecret({
+                name,
+                userId,
+                workspaceId,
+                secretIds,
+            });
+            break;
+    }
+    
+    return action;
+}
+
+export { 
+    createActionHelper,
+};

backend/src/ee/helpers/log.ts

@@ -0,0 +1,50 @@
+import { Types } from "mongoose";
+import { 
+    IAction,
+    Log,
+} from "../models";
+
+/**
+ * Create an (audit) log
+ * @param {Object} obj
+ * @param {Types.ObjectId} obj.userId - id of user associated with the log
+ * @param {Types.ObjectId} obj.workspaceId - id of workspace associated with the log
+ * @param {IAction[]} obj.actions - actions to include in log
+ * @param {String} obj.channel - channel (web/cli/auto) associated with the log
+ * @param {String} obj.ipAddress - ip address associated with the log
+ * @returns {Log} log - new audit log
+ */
+const createLogHelper = async ({
+    userId,
+    serviceAccountId,
+    serviceTokenDataId,
+    workspaceId,
+    actions,
+    channel,
+    ipAddress,
+}: {
+    userId?: Types.ObjectId;
+    serviceAccountId?: Types.ObjectId;
+    serviceTokenDataId?: Types.ObjectId;
+    workspaceId?: Types.ObjectId;
+    actions: IAction[];
+    channel: string;
+    ipAddress: string;
+}) => {
+    const log = await new Log({
+        user: userId,
+        serviceAccount: serviceAccountId,
+        serviceTokenData: serviceTokenDataId,
+        workspace: workspaceId ?? undefined,
+        actionNames: actions.map((a) => a.name),
+        actions,
+        channel,
+        ipAddress,
+    }).save();
+
+    return log;
+}
+
+export {
+    createLogHelper,
+}

backend/src/ee/middleware/index.ts

@@ -0,0 +1,5 @@
+import requireSecretSnapshotAuth from "./requireSecretSnapshotAuth";
+
+export {
+    requireSecretSnapshotAuth,
+}

backend/src/ee/middleware/requireSecretSnapshotAuth.ts

@@ -0,0 +1,43 @@
+import { NextFunction, Request, Response } from "express";
+import { SecretSnapshotNotFoundError } from "../../utils/errors";
+import { SecretSnapshot } from "../models";
+import {
+    validateMembership,
+} from "../../helpers/membership";
+
+/**
+ * Validate if user on request has proper membership for secret snapshot
+ * @param {Object} obj
+ * @param {String[]} obj.acceptedRoles - accepted workspace roles
+ * @param {String[]} obj.acceptedStatuses - accepted workspace statuses
+ * @param {String[]} obj.location - location of [workspaceId] on request (e.g. params, body) for parsing
+ */
+const requireSecretSnapshotAuth = ({
+    acceptedRoles,
+}: {
+    acceptedRoles: Array<"admin" | "member">;
+}) => {
+    return async (req: Request, res: Response, next: NextFunction) => {
+        const { secretSnapshotId } = req.params;
+        
+        const secretSnapshot = await SecretSnapshot.findById(secretSnapshotId);
+        
+        if (!secretSnapshot) {
+            return next(SecretSnapshotNotFoundError({
+                message: "Failed to find secret snapshot",
+            }));
+        }
+        
+        await validateMembership({
+            userId: req.user._id,
+            workspaceId: secretSnapshot.workspace,
+            acceptedRoles,
+        });
+        
+        req.secretSnapshot = secretSnapshot as any;
+
+        next();
+    }
+}
+
+export default requireSecretSnapshotAuth;

backend/src/ee/models/action.ts

@@ -0,0 +1,69 @@
+import { Schema, Types, model } from "mongoose";
+import {
+    ACTION_ADD_SECRETS,
+    ACTION_DELETE_SECRETS,
+    ACTION_LOGIN,
+    ACTION_LOGOUT,
+    ACTION_READ_SECRETS,
+    ACTION_UPDATE_SECRETS,
+} from "../../variables";
+
+export interface IAction {
+    name: string;
+    user?: Types.ObjectId,
+    serviceAccount?: Types.ObjectId,
+    serviceTokenData?: Types.ObjectId,
+    workspace?: Types.ObjectId,
+    payload?: {
+        secretVersions?: Types.ObjectId[]
+    }
+}
+
+const actionSchema = new Schema<IAction>(
+    {
+        name: {
+            type: String,
+            required: true,
+            enum: [
+                ACTION_LOGIN,
+                ACTION_LOGOUT,
+                ACTION_ADD_SECRETS,
+                ACTION_UPDATE_SECRETS,
+                ACTION_READ_SECRETS,
+                ACTION_DELETE_SECRETS,
+            ],
+        },
+        user: {
+            type: Schema.Types.ObjectId,
+            ref: "User",
+        },
+        serviceAccount: {
+            type: Schema.Types.ObjectId,
+            ref: "ServiceAccount",
+        },
+        serviceTokenData: {
+            type: Schema.Types.ObjectId,
+            ref: "ServiceTokenData",
+        },
+        workspace: {
+            type: Schema.Types.ObjectId,
+            ref: "Workspace",
+        },
+        payload: {
+            secretVersions: [{
+                oldSecretVersion: {
+                    type: Schema.Types.ObjectId,
+                    ref: "SecretVersion",
+                },
+                newSecretVersion: {
+                    type: Schema.Types.ObjectId,
+                    ref: "SecretVersion",
+                },
+            }],
+        },
+    }, {
+        timestamps: true,
+    }
+);
+
+export const Action = model<IAction>("Action", actionSchema);

backend/src/ee/models/auditLog/auditLog.ts

@@ -1,70 +1,76 @@
 import { Schema, Types, model } from "mongoose";
-import { ActorType, EventType, UserAgentType } from "./enums";
-import { Actor, Event } from "./types";
+import {
+    ActorType,
+    EventType,
+    UserAgentType
+} from "./enums";
+import {
+    Actor,
+    Event
+} from "./types";
 
 export interface IAuditLog {
-  actor: Actor;
-  organization: Types.ObjectId;
-  workspace: Types.ObjectId;
-  ipAddress: string;
-  event: Event;
-  userAgent: string;
-  userAgentType: UserAgentType;
-  expiresAt?: Date;
+    actor: Actor;
+    organization: Types.ObjectId;
+    workspace: Types.ObjectId;
+    ipAddress: string;
+    event: Event;
+    userAgent: string;
+    userAgentType: UserAgentType;
+    expiresAt: Date;
 }
 
 const auditLogSchema = new Schema<IAuditLog>(
-  {
-    actor: {
-      type: {
-        type: String,
-        enum: ActorType,
-        required: true
-      },
-      metadata: {
-        type: Schema.Types.Mixed
-      }
+    {
+        actor: {
+            type: {
+                type: String,
+                enum: ActorType,
+                required: true
+            },
+            metadata: {
+                type: Schema.Types.Mixed
+            }
+        },
+        organization: {
+            type: Schema.Types.ObjectId,
+            required: false
+        },
+        workspace: {
+            type: Schema.Types.ObjectId,
+            required: false
+        },
+        ipAddress: {
+            type: String,
+            required: true
+        },
+        event: {
+            type: {
+                type: String,
+                enum: EventType,
+                required: true
+            },
+            metadata: {
+                type: Schema.Types.Mixed
+            }
+        },
+        userAgent: {
+            type: String,
+            required: true
+        },
+        userAgentType: {
+            type: String,
+            enum: UserAgentType,
+            required: true
+        },
+        expiresAt: {
+            type: Date,
+            expires: 0
+        }
     },
-    organization: {
-      type: Schema.Types.ObjectId,
-      required: false
-    },
-    workspace: {
-      type: Schema.Types.ObjectId,
-      required: false,
-      index: true
-    },
-    ipAddress: {
-      type: String,
-      required: true
-    },
-    event: {
-      type: {
-        type: String,
-        enum: EventType,
-        required: true
-      },
-      metadata: {
-        type: Schema.Types.Mixed
-      }
-    },
-    userAgent: {
-      type: String,
-      required: true
-    },
-    userAgentType: {
-      type: String,
-      enum: UserAgentType,
-      required: true
-    },
-    expiresAt: {
-      type: Date,
-      expires: 0
+    {
+        timestamps: true
     }
-  },
-  {
-    timestamps: true
-  }
 );
 
-export const AuditLog = model<IAuditLog>("AuditLog", auditLogSchema);
+export const AuditLog = model<IAuditLog>("AuditLog", auditLogSchema); 

backend/src/ee/models/auditLog/enums.ts

@@ -1,17 +1,14 @@
-export enum ActorType { // would extend to AWS, Azure, ...
-    USER = "user", // userIdentity
+export enum ActorType {
+    USER = "user",
     SERVICE = "service",
-    IDENTITY = "identity"
+    SERVICE_V3 = "service-v3"
 }
 
 export enum UserAgentType {
   WEB = "web",
   CLI = "cli",
   K8_OPERATOR = "k8-operator",
-  TERRAFORM = "terraform",
-  OTHER = "other",
-  PYTHON_SDK = "InfisicalPythonSDK",
-  NODE_SDK = "InfisicalNodeSDK"
+  OTHER = "other"
 }
 
 export enum EventType {
@@ -34,21 +31,13 @@ export enum EventType {
   DELETE_TRUSTED_IP = "delete-trusted-ip",
   CREATE_SERVICE_TOKEN = "create-service-token", // v2
   DELETE_SERVICE_TOKEN = "delete-service-token", // v2
-  CREATE_IDENTITY = "create-identity",
-  UPDATE_IDENTITY = "update-identity",
-  DELETE_IDENTITY = "delete-identity",
-  LOGIN_IDENTITY_UNIVERSAL_AUTH = "login-identity-universal-auth",
-  ADD_IDENTITY_UNIVERSAL_AUTH = "add-identity-universal-auth",
-  UPDATE_IDENTITY_UNIVERSAL_AUTH = "update-identity-universal-auth",
-  GET_IDENTITY_UNIVERSAL_AUTH = "get-identity-universal-auth",
-  CREATE_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRET = "create-identity-universal-auth-client-secret",
-  REVOKE_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRET =  "revoke-identity-universal-auth-client-secret",
-  GET_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRETS = "get-identity-universal-auth-client-secret",
+  CREATE_SERVICE_TOKEN_V3 = "create-service-token-v3", // v3
+  UPDATE_SERVICE_TOKEN_V3 = "update-service-token-v3", // v3
+  DELETE_SERVICE_TOKEN_V3 = "delete-service-token-v3", // v3
   CREATE_ENVIRONMENT = "create-environment",
   UPDATE_ENVIRONMENT = "update-environment",
   DELETE_ENVIRONMENT = "delete-environment",
   ADD_WORKSPACE_MEMBER = "add-workspace-member",
-  ADD_BATCH_WORKSPACE_MEMBER = "add-workspace-members",
   REMOVE_WORKSPACE_MEMBER = "remove-workspace-member",
   CREATE_FOLDER = "create-folder",
   UPDATE_FOLDER = "update-folder",

backend/src/ee/models/auditLog/types.ts

@@ -1,5 +1,11 @@
-import { ActorType, EventType } from "./enums";
-import { IIdentityTrustedIp } from "../../../models";
+import {
+    ActorType,
+    EventType
+} from "./enums";
+import {
+  IServiceTokenV3Scope,
+  IServiceTokenV3TrustedIp
+} from "../../../models/serviceTokenDataV3";
 
 interface UserActorMetadata {
   userId: string;
@@ -11,11 +17,6 @@ interface ServiceActorMetadata {
   name: string;
 }
 
-interface IdentityActorMetadata {
-  identityId: string;
-  name: string;
-}
-
 export interface UserActor {
   type: ActorType.USER;
   metadata: UserActorMetadata;
@@ -26,12 +27,15 @@ export interface ServiceActor {
   metadata: ServiceActorMetadata;
 }
 
-export interface IdentityActor {
-  type: ActorType.IDENTITY;
-  metadata: IdentityActorMetadata;
+export interface ServiceActorV3 {
+    type: ActorType.SERVICE_V3;
+    metadata: ServiceActorMetadata;
 }
 
-export type Actor = UserActor | ServiceActor | IdentityActor;
+export type Actor = 
+    | UserActor
+    | ServiceActor
+    | ServiceActorV3;
 
 interface GetSecretsEvent {
   type: EventType.GET_SECRETS;
@@ -221,92 +225,37 @@ interface DeleteServiceTokenEvent {
   };
 }
 
-interface CreateIdentityEvent { // note: currently not logging org-role
-  type: EventType.CREATE_IDENTITY;
-  metadata: {
-    identityId: string;
-    name: string;
-  };
+interface CreateServiceTokenV3Event {
+    type: EventType.CREATE_SERVICE_TOKEN_V3;
+    metadata: {
+        name: string;
+        isActive: boolean;
+        scopes: Array<IServiceTokenV3Scope>;
+        trustedIps: Array<IServiceTokenV3TrustedIp>;
+        expiresAt?: Date;
+    }
 }
 
-interface UpdateIdentityEvent {
-  type: EventType.UPDATE_IDENTITY;
-  metadata: {
-    identityId: string;
-    name?: string;
-  };
+interface UpdateServiceTokenV3Event {
+    type: EventType.UPDATE_SERVICE_TOKEN_V3;
+    metadata: {
+        name?: string;
+        isActive?: boolean;
+        scopes?: Array<IServiceTokenV3Scope>;
+        trustedIps?: Array<IServiceTokenV3TrustedIp>;
+        expiresAt?: Date;
+    }
 }
 
-interface DeleteIdentityEvent {
-  type: EventType.DELETE_IDENTITY;
-  metadata: {
-    identityId: string;
-  };
-}
-
-interface LoginIdentityUniversalAuthEvent {
-  type: EventType.LOGIN_IDENTITY_UNIVERSAL_AUTH ;
-  metadata: {
-    identityId: string;
-    identityUniversalAuthId: string;
-    clientSecretId: string;
-    identityAccessTokenId: string;
-  };
-}
-
-interface AddIdentityUniversalAuthEvent {
-  type: EventType.ADD_IDENTITY_UNIVERSAL_AUTH;
-  metadata: {
-    identityId: string;
-    clientSecretTrustedIps: Array<IIdentityTrustedIp>;
-    accessTokenTTL: number;
-    accessTokenMaxTTL: number;
-    accessTokenNumUsesLimit: number;
-    accessTokenTrustedIps: Array<IIdentityTrustedIp>;
-  };
-}
-
-interface UpdateIdentityUniversalAuthEvent {
-  type: EventType.UPDATE_IDENTITY_UNIVERSAL_AUTH;
-  metadata: {
-    identityId: string;
-    clientSecretTrustedIps?: Array<IIdentityTrustedIp>;
-    accessTokenTTL?: number;
-    accessTokenMaxTTL?: number;
-    accessTokenNumUsesLimit?: number;
-    accessTokenTrustedIps?: Array<IIdentityTrustedIp>;
-  };
-}
-
-interface GetIdentityUniversalAuthEvent {
-  type: EventType.GET_IDENTITY_UNIVERSAL_AUTH;
-  metadata: {
-    identityId: string;
-  };
-}
-
-interface CreateIdentityUniversalAuthClientSecretEvent {
-  type: EventType.CREATE_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRET ;
-  metadata: {
-    identityId: string;
-    clientSecretId: string;
-  };
-}
-
-interface GetIdentityUniversalAuthClientSecretsEvent {
-  type: EventType.GET_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRETS;
-  metadata: {
-    identityId: string;
-  };
-}
-
-
-interface RevokeIdentityUniversalAuthClientSecretEvent {
-  type: EventType.REVOKE_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRET ;
-  metadata: {
-    identityId: string;
-    clientSecretId: string;
-  };
+interface DeleteServiceTokenV3Event {
+    type: EventType.DELETE_SERVICE_TOKEN_V3;
+    metadata: {
+        name: string;
+        isActive: boolean;
+        scopes: Array<IServiceTokenV3Scope>;
+        expiresAt?: Date;
+        trustedIps: Array<IServiceTokenV3TrustedIp>;
+    }
 }
 
 interface CreateEnvironmentEvent {
@@ -343,14 +292,6 @@ interface AddWorkspaceMemberEvent {
   };
 }
 
-interface AddBatchWorkspaceMemberEvent {
-  type: EventType.ADD_BATCH_WORKSPACE_MEMBER;
-  metadata: Array<{
-    userId: string;
-    email: string;
-  }>;
-}
-
 interface RemoveWorkspaceMemberEvent {
   type: EventType.REMOVE_WORKSPACE_MEMBER;
   metadata: {
@@ -486,15 +427,15 @@ interface UpdateUserRole {
 }
 
 interface UpdateUserDeniedPermissions {
-  type: EventType.UPDATE_USER_WORKSPACE_DENIED_PERMISSIONS;
-  metadata: {
-    userId: string;
-    email: string;
-    deniedPermissions: {
-      environmentSlug: string;
-      ability: string;
-    }[];
-  };
+    type: EventType.UPDATE_USER_WORKSPACE_DENIED_PERMISSIONS,
+    metadata: {
+        userId: string;
+        email: string;
+        deniedPermissions: {
+            environmentSlug: string;
+            ability: string;
+        }[]
+    }
 }
 interface SecretApprovalMerge {
   type: EventType.SECRET_APPROVAL_MERGED;
@@ -551,21 +492,13 @@ export type Event =
   | DeleteTrustedIPEvent
   | CreateServiceTokenEvent
   | DeleteServiceTokenEvent
-  | CreateIdentityEvent
-  | UpdateIdentityEvent
-  | DeleteIdentityEvent
-  | LoginIdentityUniversalAuthEvent
-  | AddIdentityUniversalAuthEvent
-  | UpdateIdentityUniversalAuthEvent
-  | GetIdentityUniversalAuthEvent
-  | CreateIdentityUniversalAuthClientSecretEvent
-  | GetIdentityUniversalAuthClientSecretsEvent
-  | RevokeIdentityUniversalAuthClientSecretEvent
+  | CreateServiceTokenV3Event
+  | UpdateServiceTokenV3Event
+  | DeleteServiceTokenV3Event
   | CreateEnvironmentEvent
   | UpdateEnvironmentEvent
   | DeleteEnvironmentEvent
   | AddWorkspaceMemberEvent
-  | AddBatchWorkspaceMemberEvent
   | RemoveWorkspaceMemberEvent
   | CreateFolderEvent
   | UpdateFolderEvent

backend/src/ee/models/index.ts

@@ -1,7 +1,9 @@
 export * from "./secretSnapshot";
 export * from "./secretVersion";
 export * from "./folderVersion";
+export * from "./log";
 export * from "./role";
+export * from "./action";
 export * from "./ssoConfig";
 export * from "./trustedIp";
 export * from "./auditLog";

backend/src/ee/models/log.ts

@@ -0,0 +1,72 @@
+import { Schema, Types, model } from "mongoose";
+import {
+    ACTION_ADD_SECRETS,
+    ACTION_DELETE_SECRETS,
+    ACTION_LOGIN,
+    ACTION_LOGOUT,
+    ACTION_READ_SECRETS,
+    ACTION_UPDATE_SECRETS,
+} from "../../variables";
+
+export interface ILog {
+    _id: Types.ObjectId;
+    user?: Types.ObjectId;
+    serviceAccount?: Types.ObjectId;
+    serviceTokenData?: Types.ObjectId;
+    workspace?: Types.ObjectId;
+    actionNames: string[];
+    actions: Types.ObjectId[];
+    channel: string;
+    ipAddress?: string;
+}
+
+const logSchema = new Schema<ILog>(
+    {
+        user: {
+            type: Schema.Types.ObjectId,
+            ref: "User",
+        },
+        serviceAccount: {
+            type: Schema.Types.ObjectId,
+            ref: "ServiceAccount",
+        },
+        serviceTokenData: {
+            type: Schema.Types.ObjectId,
+            ref: "ServiceTokenData",
+        },
+        workspace: {
+            type: Schema.Types.ObjectId,
+            ref: "Workspace",
+        },
+        actionNames: {
+            type: [String],
+            enum: [
+                ACTION_LOGIN,
+                ACTION_LOGOUT,
+                ACTION_ADD_SECRETS,
+                ACTION_UPDATE_SECRETS,
+                ACTION_READ_SECRETS,
+                ACTION_DELETE_SECRETS,
+            ],
+            required: true,
+        },
+        actions: [{
+            type: Schema.Types.ObjectId,
+            ref: "Action",
+            required: true,
+        }],
+        channel: {
+            type: String,
+            enum: ["web", "cli", "auto", "k8-operator", "other"],
+            required: true,
+        },
+        ipAddress: {
+            type: String,
+        },
+    }, 
+    {
+        timestamps: true,
+    }
+);
+
+export const Log = model<ILog>("Log", logSchema);

backend/src/ee/routes/v1/action.ts

@@ -0,0 +1,8 @@
+import express from "express";
+const router = express.Router();
+import { actionController } from "../../controllers/v1";
+
+// TODO: put into action controller
+router.get("/:actionId", actionController.getAction);
+
+export default router;

backend/src/ee/routes/v1/identities.ts

@@ -1,31 +0,0 @@
-import express from "express";
-const router = express.Router();
-import { requireAuth } from "../../../middleware";
-import { AuthMode } from "../../../variables";
-import { identitiesController } from "../../controllers/v1";
-
-router.post(
-  "/",
-  requireAuth({
-    acceptedAuthModes: [AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]
-  }),
-  identitiesController.createIdentity
-);
-
-router.patch(
-  "/:identityId",
-  requireAuth({
-    acceptedAuthModes: [AuthMode.JWT]
-  }),
-  identitiesController.updateIdentity
-);
-
-router.delete(
-  "/:identityId",
-  requireAuth({
-    acceptedAuthModes: [AuthMode.JWT]
-  }),
-  identitiesController.deleteIdentity
-);
-
-export default router;

backend/src/ee/routes/v1/index.ts

@@ -1,31 +1,27 @@
-import identities from "./identities";
 import secret from "./secret";
 import secretSnapshot from "./secretSnapshot";
 import organizations from "./organizations";
 import sso from "./sso";
 import users from "./users";
 import workspace from "./workspace";
+import action from "./action";
 import cloudProducts from "./cloudProducts";
 import secretScanning from "./secretScanning";
 import roles from "./role";
 import secretApprovalPolicy from "./secretApprovalPolicy";
 import secretApprovalRequest from "./secretApprovalRequest";
-import secretRotationProvider from "./secretRotationProvider";
-import secretRotation from "./secretRotation";
 
 export {
-  identities,
   secret,
   secretSnapshot,
   organizations,
   sso,
   users,
   workspace,
+  action,
   cloudProducts,
   secretScanning,
   roles,
   secretApprovalPolicy,
-  secretApprovalRequest,
-  secretRotationProvider,
-  secretRotation
+  secretApprovalRequest
 };

backend/src/ee/routes/v1/secretRotation.ts

@@ -1,41 +0,0 @@
-import express from "express";
-
-import { AuthMode } from "../../../variables";
-import { requireAuth } from "../../../middleware";
-import { secretRotationController } from "../../controllers/v1";
-
-const router = express.Router();
-
-router.post(
-  "/",
-  requireAuth({
-    acceptedAuthModes: [AuthMode.JWT]
-  }),
-  secretRotationController.createSecretRotation
-);
-
-router.post(
-  "/restart",
-  requireAuth({
-    acceptedAuthModes: [AuthMode.JWT]
-  }),
-  secretRotationController.restartSecretRotations
-);
-
-router.get(
-  "/",
-  requireAuth({
-    acceptedAuthModes: [AuthMode.JWT]
-  }),
-  secretRotationController.getSecretRotations
-);
-
-router.delete(
-  "/:id",
-  requireAuth({
-    acceptedAuthModes: [AuthMode.JWT]
-  }),
-  secretRotationController.deleteSecretRotations
-);
-
-export default router;

backend/src/ee/routes/v1/secretRotationProvider.ts

@@ -1,17 +0,0 @@
-import express from "express";
-
-import { AuthMode } from "../../../variables";
-import { requireAuth } from "../../../middleware";
-import { secretRotationProviderController } from "../../controllers/v1";
-
-const router = express.Router();
-
-router.get(
-  "/:workspaceId",
-  requireAuth({
-    acceptedAuthModes: [AuthMode.JWT]
-  }),
-  secretRotationProviderController.getProviderTemplates
-);
-
-export default router;

backend/src/ee/routes/v1/workspace.ts

@@ -7,7 +7,7 @@ import { workspaceController } from "../../controllers/v1";
 router.get(
   "/:workspaceId/secret-snapshots",
   requireAuth({
-    acceptedAuthModes: [AuthMode.JWT, AuthMode.API_KEY, AuthMode.IDENTITY_ACCESS_TOKEN]
+    acceptedAuthModes: [AuthMode.JWT, AuthMode.API_KEY]
   }),
   workspaceController.getWorkspaceSecretSnapshots
 );
@@ -23,15 +23,23 @@ router.get(
 router.post(
   "/:workspaceId/secret-snapshots/rollback",
   requireAuth({
-    acceptedAuthModes: [AuthMode.JWT, AuthMode.API_KEY, AuthMode.IDENTITY_ACCESS_TOKEN]
+    acceptedAuthModes: [AuthMode.JWT, AuthMode.API_KEY]
   }),
   workspaceController.rollbackWorkspaceSecretSnapshot
 );
 
+router.get(
+  "/:workspaceId/logs",
+  requireAuth({
+    acceptedAuthModes: [AuthMode.JWT, AuthMode.API_KEY]
+  }),
+  workspaceController.getWorkspaceLogs
+);
+
 router.get(
   "/:workspaceId/audit-logs",
   requireAuth({
-    acceptedAuthModes: [AuthMode.JWT, AuthMode.API_KEY, AuthMode.IDENTITY_ACCESS_TOKEN]
+    acceptedAuthModes: [AuthMode.JWT, AuthMode.API_KEY]
   }),
   workspaceController.getWorkspaceAuditLogs
 );

backend/src/ee/routes/v3/index.ts

@@ -1,5 +1,7 @@
+import serviceTokenData from "./serviceTokenData";
 import apiKeyData from "./apiKeyData";
 
 export {
+    serviceTokenData,
     apiKeyData
 }

backend/src/ee/routes/v3/serviceTokenData.ts

@@ -0,0 +1,39 @@
+import express from "express";
+const router = express.Router();
+import { requireAuth } from "../../../middleware";
+import { AuthMode } from "../../../variables";
+import { serviceTokenDataController } from "../../controllers/v3";
+
+router.get(
+  "/me/key",
+  requireAuth({
+    acceptedAuthModes: [AuthMode.SERVICE_TOKEN_V3]
+  }),
+  serviceTokenDataController.getServiceTokenDataKey
+);
+
+router.post(
+    "/",
+    requireAuth({
+      acceptedAuthModes: [AuthMode.JWT]
+    }),
+    serviceTokenDataController.createServiceTokenData
+);
+
+router.patch(
+    "/:serviceTokenDataId",
+    requireAuth({
+      acceptedAuthModes: [AuthMode.JWT]
+    }),
+    serviceTokenDataController.updateServiceTokenData
+);
+
+router.delete(
+  "/:serviceTokenDataId",
+  requireAuth({
+    acceptedAuthModes: [AuthMode.JWT]
+  }),
+  serviceTokenDataController.deleteServiceTokenData
+);
+
+export default router;

backend/src/ee/secretRotation/models.ts

@@ -1,91 +0,0 @@
-import { Schema, model } from "mongoose";
-import {
-  ALGORITHM_AES_256_GCM,
-  ENCODING_SCHEME_BASE64,
-  ENCODING_SCHEME_UTF8
-} from "../../variables";
-import { ISecretRotation } from "./types";
-
-const secretRotationSchema = new Schema(
-  {
-    workspace: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace"
-    },
-    provider: {
-      type: String,
-      required: true
-    },
-    customProvider: {
-      type: Schema.Types.ObjectId,
-      ref: "SecretRotationProvider"
-    },
-    environment: {
-      type: String,
-      required: true
-    },
-    secretPath: {
-      type: String,
-      required: true
-    },
-    interval: {
-      type: Number,
-      required: true
-    },
-    lastRotatedAt: {
-      type: String
-    },
-    status: {
-      type: String,
-      enum: ["success", "failed"]
-    },
-    statusMessage: {
-      type: String
-    },
-    // encrypted data on input keys and secrets got
-    encryptedData: {
-      type: String,
-      select: false
-    },
-    encryptedDataIV: {
-      type: String,
-      select: false
-    },
-    encryptedDataTag: {
-      type: String,
-      select: false
-    },
-    algorithm: {
-      // the encryption algorithm used
-      type: String,
-      enum: [ALGORITHM_AES_256_GCM],
-      required: true,
-      select: false,
-      default: ALGORITHM_AES_256_GCM
-    },
-    keyEncoding: {
-      type: String,
-      enum: [ENCODING_SCHEME_UTF8, ENCODING_SCHEME_BASE64],
-      required: true,
-      select: false,
-      default: ENCODING_SCHEME_UTF8
-    },
-    outputs: [
-      {
-        key: {
-          type: String,
-          required: true
-        },
-        secret: {
-          type: Schema.Types.ObjectId,
-          ref: "Secret"
-        }
-      }
-    ]
-  },
-  {
-    timestamps: true
-  }
-);
-
-export const SecretRotation = model<ISecretRotation>("SecretRotation", secretRotationSchema);

backend/src/ee/secretRotation/queue/queue.ts

@@ -1,288 +0,0 @@
-import Queue, { Job } from "bull";
-import { client, getEncryptionKey, getRootEncryptionKey } from "../../../config";
-import { BotService, EventService, TelemetryService } from "../../../services";
-import { SecretRotation } from "../models";
-import { rotationTemplates } from "../templates";
-import {
-  ISecretRotationData,
-  ISecretRotationEncData,
-  ISecretRotationProviderTemplate,
-  TProviderFunctionTypes
-} from "../types";
-import {
-  decryptSymmetric128BitHexKeyUTF8,
-  encryptSymmetric128BitHexKeyUTF8
-} from "../../../utils/crypto";
-import { ISecret, Secret } from "../../../models";
-import { ENCODING_SCHEME_BASE64, ENCODING_SCHEME_UTF8, SECRET_SHARED } from "../../../variables";
-import { EESecretService } from "../../services";
-import { SecretVersion } from "../../models";
-import { eventPushSecrets } from "../../../events";
-import { logger } from "../../../utils/logging";
-
-import {
-  secretRotationPreSetFn,
-  secretRotationRemoveFn,
-  secretRotationSetFn,
-  secretRotationTestFn
-} from "./queue.utils";
-
-const secretRotationQueue = new Queue("secret-rotation-service", process.env.REDIS_URL as string);
-
-secretRotationQueue.process(async (job: Job) => {
-  logger.info(`secretRotationQueue.process: [rotationDocument=${job.data.rotationDocId}]`);
-  const rotationStratDocId = job.data.rotationDocId;
-  const secretRotation = await SecretRotation.findById(rotationStratDocId)
-    .select("+encryptedData +encryptedDataTag +encryptedDataIV +keyEncoding")
-    .populate<{
-      outputs: [
-        {
-          key: string;
-          secret: ISecret;
-        }
-      ];
-    }>("outputs.secret");
-
-  const infisicalRotationProvider = rotationTemplates.find(
-    ({ name }) => name === secretRotation?.provider
-  );
-
-  try {
-    if (!infisicalRotationProvider || !secretRotation)
-      throw new Error("Failed to find rotation strategy");
-
-    if (secretRotation.outputs.some(({ secret }) => !secret))
-      throw new Error("Secrets not found in dashboard");
-
-    const workspaceId = secretRotation.workspace;
-
-    // deep copy
-    const provider = JSON.parse(
-      JSON.stringify(infisicalRotationProvider)
-    ) as ISecretRotationProviderTemplate;
-
-    // decrypt user  provided inputs for secret rotation
-    const encryptionKey = await getEncryptionKey();
-    const rootEncryptionKey = await getRootEncryptionKey();
-    let decryptedData = "";
-    if (rootEncryptionKey && secretRotation.keyEncoding === ENCODING_SCHEME_BASE64) {
-      // case: encoding scheme is base64
-      decryptedData = client.decryptSymmetric(
-        secretRotation.encryptedData,
-        rootEncryptionKey,
-        secretRotation.encryptedDataIV,
-        secretRotation.encryptedDataTag
-      );
-    } else if (encryptionKey && secretRotation.keyEncoding === ENCODING_SCHEME_UTF8) {
-      // case: encoding scheme is utf8
-      decryptedData = decryptSymmetric128BitHexKeyUTF8({
-        ciphertext: secretRotation.encryptedData,
-        iv: secretRotation.encryptedDataIV,
-        tag: secretRotation.encryptedDataTag,
-        key: encryptionKey
-      });
-    }
-
-    const variables = JSON.parse(decryptedData) as ISecretRotationEncData;
-
-    // rotation set cycle
-    const newCredential: ISecretRotationData = {
-      inputs: variables.inputs,
-      outputs: {},
-      internal: {}
-    };
-    // special glue code for database
-    if (provider.template.functions.set.type === TProviderFunctionTypes.DB) {
-      const lastCred = variables.creds.at(-1);
-      if (lastCred && variables.creds.length === 1) {
-        newCredential.internal.username =
-          lastCred.internal.username === variables.inputs.username1
-            ? variables.inputs.username2
-            : variables.inputs.username1;
-      } else {
-        newCredential.internal.username = lastCred
-          ? lastCred.internal.username
-          : variables.inputs.username1;
-      }
-    }
-    if (provider.template.functions.set?.pre) {
-      secretRotationPreSetFn(provider.template.functions.set.pre, newCredential);
-    }
-    await secretRotationSetFn(provider.template.functions.set, newCredential);
-    await secretRotationTestFn(provider.template.functions.test, newCredential);
-
-    if (variables.creds.length === 2) {
-      const deleteCycleCred = variables.creds.pop();
-      if (deleteCycleCred && provider.template.functions.remove) {
-        const deleteCycleVar = { inputs: variables.inputs, ...deleteCycleCred };
-        await secretRotationRemoveFn(provider.template.functions.remove, deleteCycleVar);
-      }
-    }
-    variables.creds.unshift({ outputs: newCredential.outputs, internal: newCredential.internal });
-    const { ciphertext, iv, tag } = client.encryptSymmetric(
-      JSON.stringify(variables),
-      rootEncryptionKey
-    );
-
-    // save the rotation state
-    await SecretRotation.findByIdAndUpdate(rotationStratDocId, {
-      encryptedData: ciphertext,
-      encryptedDataIV: iv,
-      encryptedDataTag: tag,
-      status: "success",
-      statusMessage: "Rotated successfully",
-      lastRotatedAt: new Date().toUTCString()
-    });
-
-    const key = await BotService.getWorkspaceKeyWithBot({
-      workspaceId: secretRotation.workspace
-    });
-
-    const encryptedSecrets = secretRotation.outputs.map(({ key: outputKey, secret }) => ({
-      secret,
-      value: encryptSymmetric128BitHexKeyUTF8({
-        plaintext:
-          typeof newCredential.outputs[outputKey] === "object"
-            ? JSON.stringify(newCredential.outputs[outputKey])
-            : String(newCredential.outputs[outputKey]),
-        key
-      })
-    }));
-
-    // now save the secret do a bulk update
-    // can't use the updateSecret function due to various parameter required issue
-    // REFACTOR(akhilmhdh): secret module should be lot more flexible. Ability to update bulk or individually by blindIndex, by id etc
-    await Secret.bulkWrite(
-      encryptedSecrets.map(({ secret, value }) => ({
-        updateOne: {
-          filter: {
-            workspace: workspaceId,
-            environment: secretRotation.environment,
-            _id: secret._id,
-            type: SECRET_SHARED
-          },
-          update: {
-            $inc: {
-              version: 1
-            },
-            secretValueCiphertext: value.ciphertext,
-            secretValueIV: value.iv,
-            secretValueTag: value.tag
-          }
-        }
-      }))
-    );
-
-    await EESecretService.addSecretVersions({
-      secretVersions: encryptedSecrets.map(({ secret, value }) => {
-        const {
-          _id,
-          version,
-          workspace,
-          type,
-          folder,
-          secretBlindIndex,
-          secretKeyIV,
-          secretKeyTag,
-          secretKeyCiphertext,
-          skipMultilineEncoding,
-          environment,
-          algorithm,
-          keyEncoding
-        } = secret;
-
-        return new SecretVersion({
-          secret: _id,
-          version: version + 1,
-          workspace: workspace,
-          type,
-          folder,
-          environment,
-          isDeleted: false,
-          secretBlindIndex: secretBlindIndex,
-          secretKeyCiphertext: secretKeyCiphertext,
-          secretKeyIV: secretKeyIV,
-          secretKeyTag: secretKeyTag,
-          secretValueCiphertext: value.ciphertext,
-          secretValueIV: value.iv,
-          secretValueTag: value.tag,
-          algorithm,
-          keyEncoding,
-          skipMultilineEncoding
-        });
-      })
-    });
-
-    // akhilmhdh: @tony need to do something about this as its depend on authData which is not possibile in here
-    // await EEAuditLogService.createAuditLog(
-    //   {actor:ActorType.Machine},
-    //   {
-    //     type: EventType.UPDATE_SECRETS,
-    //     metadata: {
-    //       environment,
-    //       secretPath,
-    //       secrets: secretsToBeUpdated.map(({ _id, version, secretBlindIndex }) => ({
-    //         secretId: _id.toString(),
-    //         secretKey: secretBlindIndexToKey[secretBlindIndex || ""],
-    //         secretVersion: version + 1
-    //       }))
-    //     }
-    //   },
-    //   {
-    //     workspaceId
-    //   }
-    // );
-
-    const folderId = encryptedSecrets?.[0]?.secret?.folder;
-    // (EE) take a secret snapshot
-    await EESecretService.takeSecretSnapshot({
-      workspaceId,
-      environment: secretRotation.environment,
-      folderId
-    });
-
-    await EventService.handleEvent({
-      event: eventPushSecrets({
-        workspaceId: secretRotation.workspace,
-        environment: secretRotation.environment,
-        secretPath: secretRotation.secretPath
-      })
-    });
-
-    const postHogClient = await TelemetryService.getPostHogClient();
-    if (postHogClient) {
-      postHogClient.capture({
-        event: "secrets rotated",
-        properties: {
-          numberOfSecrets: encryptedSecrets.length,
-          environment: secretRotation.environment,
-          workspaceId,
-          folderId
-        }
-      });
-    }
-  } catch (err) {
-    logger.error(err);
-    await SecretRotation.findByIdAndUpdate(rotationStratDocId, {
-      status: "failed",
-      statusMessage: (err as Error).message,
-      lastRotatedAt: new Date().toUTCString()
-    });
-  }
-
-  return Promise.resolve();
-});
-
-const daysToMillisecond = (days: number) => days * 24 * 60 * 60 * 1000;
-export const startSecretRotationQueue = async (rotationDocId: string, interval: number) => {
-  // when migration to bull mq just use the option immedite to trigger repeatable immediately
-  secretRotationQueue.add({ rotationDocId }, { jobId: rotationDocId, removeOnComplete: true });
-  return secretRotationQueue.add(
-    { rotationDocId },
-    { repeat: { every: daysToMillisecond(interval) }, jobId: rotationDocId }
-  );
-};
-
-export const removeSecretRotationQueue = async (rotationDocId: string, interval: number) => {
-  return secretRotationQueue.removeRepeatable({ every: interval * 1000, jobId: rotationDocId });
-};

backend/src/ee/secretRotation/queue/queue.utils.ts

@@ -1,179 +0,0 @@
-import axios from "axios";
-import jmespath from "jmespath";
-import { customAlphabet } from "nanoid";
-import { Client as PgClient } from "pg";
-import mysql from "mysql2";
-import {
-  ISecretRotationData,
-  TAssignOp,
-  TDbProviderClients,
-  TDbProviderFunction,
-  TDirectAssignOp,
-  THttpProviderFunction,
-  TProviderFunction,
-  TProviderFunctionTypes
-} from "../types";
-const REGEX = /\${([^}]+)}/g;
-const SLUG_ALPHABETS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-const nanoId = customAlphabet(SLUG_ALPHABETS, 10);
-
-export const interpolate = (data: any, getValue: (key: string) => unknown) => {
-  if (!data) return;
-
-  if (typeof data === "number") return data;
-
-  if (typeof data === "string") {
-    return data.replace(REGEX, (_a, b) => getValue(b) as string);
-  }
-
-  if (typeof data === "object" && Array.isArray(data)) {
-    data.forEach((el, index) => {
-      data[index] = interpolate(el, getValue);
-    });
-  }
-
-  if (typeof data === "object") {
-    if ((data as { ref: string })?.ref) return getValue((data as { ref: string }).ref);
-    const temp = data as Record<string, unknown>; // for converting ts object to record type
-    Object.keys(temp).forEach((key) => {
-      temp[key as keyof typeof temp] = interpolate(data[key as keyof typeof temp], getValue);
-    });
-  }
-  return data;
-};
-
-const getInterpolationValue = (variables: ISecretRotationData) => (key: string) => {
-  if (key.includes("|")) {
-    const [keyword, ...arg] = key.split("|").map((el) => el.trim());
-    switch (keyword) {
-      case "random": {
-        return nanoId(parseInt(arg[0], 10));
-      }
-      default: {
-        throw Error(`Interpolation key not found - ${key}`);
-      }
-    }
-  }
-  const [type, keyName] = key.split(".").map((el) => el.trim());
-  return variables[type as keyof ISecretRotationData][keyName];
-};
-
-export const secretRotationHttpFn = async (
-  func: THttpProviderFunction,
-  variables: ISecretRotationData
-) => {
-  // string interpolation
-  const headers = interpolate(func.header, getInterpolationValue(variables));
-  const url = interpolate(func.url, getInterpolationValue(variables));
-  const body = interpolate(func.body, getInterpolationValue(variables));
-  // axios will automatically throw error if req status is not between 2xx range
-  return axios({ method: func.method, url, headers, data: body });
-};
-
-export const secretRotationDbFn = async (
-  func: TDbProviderFunction,
-  variables: ISecretRotationData
-) => {
-  const { type, client, pre, ...dbConnection } = func;
-  const { username, password, host, database, port, query, ca } = interpolate(
-    dbConnection,
-    getInterpolationValue(variables)
-  );
-  const ssl = ca ? { rejectUnauthorized: false, ca } : undefined;
-  if (host === "localhost" || host === "127.0.0.1") throw new Error("Invalid db host");
-  if (client === TDbProviderClients.Pg) {
-    const pgClient = new PgClient({ user: username, password, host, database, port, ssl });
-    await pgClient.connect();
-    const res = await pgClient.query(query);
-    await pgClient.end();
-    return res.rows[0];
-  } else if (client === TDbProviderClients.Sql) {
-    const sqlClient = mysql.createPool({
-      user: username,
-      password,
-      host,
-      database,
-      port,
-      connectionLimit: 1,
-      ssl
-    });
-    const res = await new Promise((resolve, reject) => {
-      sqlClient.query(query, (err, data) => {
-        if (err) return reject(err);
-        resolve(data);
-      });
-    });
-    await new Promise((resolve, reject) => {
-      sqlClient.end(function (err) {
-        if (err) return reject(err);
-        return resolve({});
-      });
-    });
-    return (res as any)?.[0];
-  }
-};
-
-export const secretRotationPreSetFn = (
-  op: Record<string, TDirectAssignOp>,
-  variables: ISecretRotationData
-) => {
-  const getValFn = getInterpolationValue(variables);
-  Object.entries(op || {}).forEach(([key, assignFn]) => {
-    const [type, keyName] = key.split(".") as [keyof ISecretRotationData, string];
-    variables[type][keyName] = interpolate(assignFn.value, getValFn);
-  });
-};
-
-export const secretRotationSetFn = async (
-  func: TProviderFunction,
-  variables: ISecretRotationData
-) => {
-  const getValFn = getInterpolationValue(variables);
-  // http setter
-  if (func.type === TProviderFunctionTypes.HTTP) {
-    const res = await secretRotationHttpFn(func, variables);
-    Object.entries(func.setter || {}).forEach(([key, assignFn]) => {
-      const [type, keyName] = key.split(".") as [keyof ISecretRotationData, string];
-      if (assignFn.assign === TAssignOp.JmesPath) {
-        variables[type][keyName] = jmespath.search(res.data, assignFn.path);
-      } else if (assignFn.value) {
-        variables[type][keyName] = interpolate(assignFn.value, getValFn);
-      }
-    });
-    // db setter
-  } else if (func.type === TProviderFunctionTypes.DB) {
-    const data = await secretRotationDbFn(func, variables);
-    Object.entries(func.setter || {}).forEach(([key, assignFn]) => {
-      const [type, keyName] = key.split(".") as [keyof ISecretRotationData, string];
-      if (assignFn.assign === TAssignOp.JmesPath) {
-        if (typeof data === "object") {
-          variables[type][keyName] = jmespath.search(data, assignFn.path);
-        }
-      } else if (assignFn.value) {
-        variables[type][keyName] = interpolate(assignFn.value, getValFn);
-      }
-    });
-  }
-};
-
-export const secretRotationTestFn = async (
-  func: TProviderFunction,
-  variables: ISecretRotationData
-) => {
-  if (func.type === TProviderFunctionTypes.HTTP) {
-    await secretRotationHttpFn(func, variables);
-  } else if (func.type === TProviderFunctionTypes.DB) {
-    await secretRotationDbFn(func, variables);
-  }
-};
-
-export const secretRotationRemoveFn = async (
-  func: TProviderFunction,
-  variables: ISecretRotationData
-) => {
-  if (!func) return;
-  if (func.type === TProviderFunctionTypes.HTTP) {
-    // string interpolation
-    return await secretRotationHttpFn(func, variables);
-  }
-};

backend/src/ee/secretRotation/service.ts

@@ -1,130 +0,0 @@
-import { ISecretRotationEncData, TCreateSecretRotation, TGetProviderTemplates } from "./types";
-import { rotationTemplates } from "./templates";
-import { SecretRotation } from "./models";
-import { client, getEncryptionKey, getRootEncryptionKey } from "../../config";
-import { BadRequestError } from "../../utils/errors";
-import Ajv from "ajv";
-import { removeSecretRotationQueue, startSecretRotationQueue } from "./queue/queue";
-import {
-  ALGORITHM_AES_256_GCM,
-  ENCODING_SCHEME_BASE64,
-  ENCODING_SCHEME_UTF8
-} from "../../variables";
-import { encryptSymmetric128BitHexKeyUTF8 } from "../../utils/crypto";
-
-const ajv = new Ajv({ strict: false });
-
-export const getProviderTemplate = async ({ workspaceId }: TGetProviderTemplates) => {
-  return {
-    custom: [],
-    providers: rotationTemplates
-  };
-};
-
-export const createSecretRotation = async ({
-  workspaceId,
-  secretPath,
-  environment,
-  provider,
-  interval,
-  inputs,
-  outputs
-}: TCreateSecretRotation) => {
-  const rotationTemplate = rotationTemplates.find(({ name }) => name === provider);
-  if (!rotationTemplate) throw BadRequestError({ message: "Provider not found" });
-
-  const formattedInputs: Record<string, unknown> = {};
-  Object.entries(inputs).forEach(([key, value]) => {
-    const type = rotationTemplate.template.inputs.properties[key].type;
-    if (type === "string") {
-      formattedInputs[key] = value;
-      return;
-    }
-    if (type === "integer") {
-      formattedInputs[key] = parseInt(value as string, 10);
-      return;
-    }
-    formattedInputs[key] = JSON.parse(value as string);
-  });
-  // ensure input one follows the correct schema
-  const valid = ajv.validate(rotationTemplate.template.inputs, formattedInputs);
-  if (!valid) {
-    throw BadRequestError({ message: ajv.errors?.[0].message });
-  }
-
-  const encData: Partial<ISecretRotationEncData> = {
-    inputs: formattedInputs,
-    creds: []
-  };
-
-  const secretRotation = new SecretRotation({
-    workspace: workspaceId,
-    provider,
-    environment,
-    secretPath,
-    interval,
-    outputs: Object.entries(outputs).map(([key, secret]) => ({ key, secret }))
-  });
-
-  const encryptionKey = await getEncryptionKey();
-  const rootEncryptionKey = await getRootEncryptionKey();
-
-  if (rootEncryptionKey) {
-    const { ciphertext, iv, tag } = client.encryptSymmetric(
-      JSON.stringify(encData),
-      rootEncryptionKey
-    );
-    secretRotation.encryptedDataIV = iv;
-    secretRotation.encryptedDataTag = tag;
-    secretRotation.encryptedData = ciphertext;
-    secretRotation.algorithm = ALGORITHM_AES_256_GCM;
-    secretRotation.keyEncoding = ENCODING_SCHEME_BASE64;
-  } else if (encryptionKey) {
-    const { ciphertext, iv, tag } = encryptSymmetric128BitHexKeyUTF8({
-      plaintext: JSON.stringify(encData),
-      key: encryptionKey
-    });
-    secretRotation.encryptedDataIV = iv;
-    secretRotation.encryptedDataTag = tag;
-    secretRotation.encryptedData = ciphertext;
-    secretRotation.algorithm = ALGORITHM_AES_256_GCM;
-    secretRotation.keyEncoding = ENCODING_SCHEME_UTF8;
-  }
-
-  await secretRotation.save();
-  await startSecretRotationQueue(secretRotation._id.toString(), interval);
-
-  return secretRotation;
-};
-
-export const deleteSecretRotation = async ({ id }: { id: string }) => {
-  const doc = await SecretRotation.findByIdAndRemove(id);
-  if (!doc) throw BadRequestError({ message: "Rotation not found" });
-
-  await removeSecretRotationQueue(doc._id.toString(), doc.interval);
-  return doc;
-};
-
-export const restartSecretRotation = async ({ id }: { id: string }) => {
-  const secretRotation = await SecretRotation.findById(id);
-  if (!secretRotation) throw BadRequestError({ message: "Rotation not found" });
-
-  await removeSecretRotationQueue(secretRotation._id.toString(), secretRotation.interval);
-  await startSecretRotationQueue(secretRotation._id.toString(), secretRotation.interval);
-
-  return secretRotation;
-};
-
-export const getSecretRotationById = async ({ id }: { id: string }) => {
-  const doc = await SecretRotation.findById(id);
-  if (!doc) throw BadRequestError({ message: "Rotation not found" });
-  return doc;
-};
-
-export const getSecretRotationOfWorkspace = async (workspaceId: string) => {
-  const secretRotations = await SecretRotation.find({
-    workspace: workspaceId
-  }).populate("outputs.secret");
-
-  return secretRotations;
-};

backend/src/ee/secretRotation/templates/index.ts

@@ -1,28 +0,0 @@
-import { ISecretRotationProviderTemplate } from "../types";
-import { MYSQL_TEMPLATE } from "./mysql";
-import { POSTGRES_TEMPLATE } from "./postgres";
-import { SENDGRID_TEMPLATE } from "./sendgrid";
-
-export const rotationTemplates: ISecretRotationProviderTemplate[] = [
-  {
-    name: "sendgrid",
-    title: "Twilio Sendgrid",
-    image: "sendgrid.png",
-    description: "Rotate Twilio Sendgrid API keys",
-    template: SENDGRID_TEMPLATE
-  },
-  {
-    name: "postgres",
-    title: "PostgreSQL",
-    image: "postgres.png",
-    description: "Rotate PostgreSQL/CockroachDB user credentials",
-    template: POSTGRES_TEMPLATE
-  },
-  {
-    name: "mysql",
-    title: "MySQL",
-    image: "mysql.png",
-    description: "Rotate MySQL@7/MariaDB user credentials",
-    template: MYSQL_TEMPLATE
-  }
-];

backend/src/ee/secretRotation/templates/mysql.ts

@@ -1,83 +0,0 @@
-import { TAssignOp, TDbProviderClients, TProviderFunctionTypes } from "../types";
-
-export const MYSQL_TEMPLATE = {
-  inputs: {
-    type: "object" as const,
-    properties: {
-      admin_username: { type: "string" as const },
-      admin_password: { type: "string" as const },
-      host: { type: "string" as const },
-      database: { type: "string" as const },
-      port: { type: "integer" as const, default: "3306" },
-      username1: {
-        type: "string",
-        default: "infisical-sql-user1",
-        desc: "This user must be created in your database"
-      },
-      username2: {
-        type: "string",
-        default: "infisical-sql-user2",
-        desc: "This user must be created in your database"
-      },
-      ca: { type: "string", desc: "SSL certificate for db auth(string)" }
-    },
-    required: [
-      "admin_username",
-      "admin_password",
-      "host",
-      "database",
-      "username1",
-      "username2",
-      "port"
-    ],
-    additionalProperties: false
-  },
-  outputs: {
-    db_username: { type: "string" },
-    db_password: { type: "string" }
-  },
-  internal: {
-    rotated_password: { type: "string" },
-    username: { type: "string" }
-  },
-  functions: {
-    set: {
-      type: TProviderFunctionTypes.DB as const,
-      client: TDbProviderClients.Sql,
-      username: "${inputs.admin_username}",
-      password: "${inputs.admin_password}",
-      host: "${inputs.host}",
-      database: "${inputs.database}",
-      port: "${inputs.port}",
-      ca: "${inputs.ca}",
-      query: "ALTER USER ${internal.username} IDENTIFIED BY '${internal.rotated_password}'",
-      setter: {
-        "outputs.db_username": {
-          assign: TAssignOp.Direct as const,
-          value: "${internal.username}"
-        },
-        "outputs.db_password": {
-          assign: TAssignOp.Direct as const,
-          value: "${internal.rotated_password}"
-        }
-      },
-      pre: {
-        "internal.rotated_password": {
-          assign: TAssignOp.Direct as const,
-          value: "${random | 32}"
-        }
-      }
-    },
-    test: {
-      type: TProviderFunctionTypes.DB as const,
-      client: TDbProviderClients.Sql,
-      username: "${internal.username}",
-      password: "${internal.rotated_password}",
-      host: "${inputs.host}",
-      database: "${inputs.database}",
-      port: "${inputs.port}",
-      ca: "${inputs.ca}",
-      query: "SELECT NOW()"
-    }
-  }
-};

backend/src/ee/secretRotation/templates/postgres.ts

@@ -1,83 +0,0 @@
-import { TAssignOp, TDbProviderClients, TProviderFunctionTypes } from "../types";
-
-export const POSTGRES_TEMPLATE = {
-  inputs: {
-    type: "object" as const,
-    properties: {
-      admin_username: { type: "string" as const },
-      admin_password: { type: "string" as const },
-      host: { type: "string" as const },
-      database: { type: "string" as const },
-      port: { type: "integer" as const, default: "5432" },
-      username1: {
-        type: "string",
-        default: "infisical-pg-user1",
-        desc: "This user must be created in your database"
-      },
-      username2: {
-        type: "string",
-        default: "infisical-pg-user2",
-        desc: "This user must be created in your database"
-      },
-      ca: { type: "string", desc: "SSL certificate for db auth(string)" }
-    },
-    required: [
-      "admin_username",
-      "admin_password",
-      "host",
-      "database",
-      "username1",
-      "username2",
-      "port"
-    ],
-    additionalProperties: false
-  },
-  outputs: {
-    db_username: { type: "string" },
-    db_password: { type: "string" }
-  },
-  internal: {
-    rotated_password: { type: "string" },
-    username: { type: "string" }
-  },
-  functions: {
-    set: {
-      type: TProviderFunctionTypes.DB as const,
-      client: TDbProviderClients.Pg,
-      username: "${inputs.admin_username}",
-      password: "${inputs.admin_password}",
-      host: "${inputs.host}",
-      database: "${inputs.database}",
-      port: "${inputs.port}",
-      ca: "${inputs.ca}",
-      query: "ALTER USER ${internal.username} WITH PASSWORD '${internal.rotated_password}'",
-      setter: {
-        "outputs.db_username": {
-          assign: TAssignOp.Direct as const,
-          value: "${internal.username}"
-        },
-        "outputs.db_password": {
-          assign: TAssignOp.Direct as const,
-          value: "${internal.rotated_password}"
-        }
-      },
-      pre: {
-        "internal.rotated_password": {
-          assign: TAssignOp.Direct as const,
-          value: "${random | 32}"
-        }
-      }
-    },
-    test: {
-      type: TProviderFunctionTypes.DB as const,
-      client: TDbProviderClients.Pg,
-      username: "${internal.username}",
-      password: "${internal.rotated_password}",
-      host: "${inputs.host}",
-      database: "${inputs.database}",
-      port: "${inputs.port}",
-      ca: "${inputs.ca}",
-      query: "SELECT NOW()"
-    }
-  }
-};

backend/src/ee/secretRotation/templates/sendgrid.ts

@@ -1,63 +0,0 @@
-import { TAssignOp, TProviderFunctionTypes } from "../types";
-
-export const SENDGRID_TEMPLATE = {
-  inputs: {
-    type: "object" as const,
-    properties: {
-      admin_api_key: { type: "string" as const, desc: "Sendgrid admin api key to create new keys" },
-      api_key_scopes: {
-        type: "array",
-        items: { type: "string" as const },
-        desc: "Scopes for created tokens by rotation(Array)"
-      }
-    },
-    required: ["admin_api_key", "api_key_scopes"],
-    additionalProperties: false
-  },
-  outputs: {
-    api_key: { type: "string" }
-  },
-  internal: {
-    api_key_id: { type: "string" }
-  },
-  functions: {
-    set: {
-      type: TProviderFunctionTypes.HTTP as const,
-      url: "https://api.sendgrid.com/v3/api_keys",
-      method: "POST",
-      header: {
-        Authorization: "Bearer ${inputs.admin_api_key}"
-      },
-      body: {
-        name: "infisical-${random | 16}",
-        scopes: { ref: "inputs.api_key_scopes" }
-      },
-      setter: {
-        "outputs.api_key": {
-          assign: TAssignOp.JmesPath as const,
-          path: "api_key"
-        },
-        "internal.api_key_id": {
-          assign: TAssignOp.JmesPath as const,
-          path: "api_key_id"
-        }
-      }
-    },
-    remove: {
-      type: TProviderFunctionTypes.HTTP as const,
-      url: "https://api.sendgrid.com/v3/api_keys/${internal.api_key_id}",
-      header: {
-        Authorization: "Bearer ${inputs.admin_api_key}"
-      },
-      method: "DELETE"
-    },
-    test: {
-      type: TProviderFunctionTypes.HTTP as const,
-      url: "https://api.sendgrid.com/v3/api_keys/${internal.api_key_id}",
-      header: {
-        Authorization: "Bearer ${inputs.admin_api_key}"
-      },
-      method: "GET"
-    }
-  }
-};

backend/src/ee/secretRotation/types.ts

@@ -1,131 +0,0 @@
-import { Document, Types } from "mongoose";
-
-export interface ISecretRotation extends Document {
-  _id: Types.ObjectId;
-  name: string;
-  interval: number;
-  provider: string;
-  customProvider: Types.ObjectId;
-  workspace: Types.ObjectId;
-  environment: string;
-  secretPath: string;
-  outputs: Array<{
-    key: string;
-    secret: Types.ObjectId;
-  }>;
-  status?: "success" | "failed";
-  lastRotatedAt?: string;
-  statusMessage?: string;
-  encryptedData: string;
-  encryptedDataIV: string;
-  encryptedDataTag: string;
-  algorithm: string;
-  keyEncoding: string;
-}
-
-export type ISecretRotationEncData = {
-  inputs: Record<string, unknown>;
-  creds: Array<{
-    outputs: Record<string, unknown>;
-    internal: Record<string, unknown>;
-  }>;
-};
-
-export type ISecretRotationData = {
-  inputs: Record<string, unknown>;
-  outputs: Record<string, unknown>;
-  internal: Record<string, unknown>;
-};
-
-export type ISecretRotationProviderTemplate = {
-  name: string;
-  title: string;
-  image?: string;
-  description?: string;
-  template: TProviderTemplate;
-};
-
-export enum TProviderFunctionTypes {
-  HTTP = "http",
-  DB = "database"
-}
-
-export enum TDbProviderClients {
-  // postgres, cockroack db, amazon red shift
-  Pg = "pg",
-  // mysql and maria db
-  Sql = "sql"
-}
-
-export enum TAssignOp {
-  Direct = "direct",
-  JmesPath = "jmesopath"
-}
-
-export type TJmesPathAssignOp = {
-  assign: TAssignOp.JmesPath;
-  path: string;
-};
-
-export type TDirectAssignOp = {
-  assign: TAssignOp.Direct;
-  value: string;
-};
-
-export type TAssignFunction = TJmesPathAssignOp | TDirectAssignOp;
-
-export type THttpProviderFunction = {
-  type: TProviderFunctionTypes.HTTP;
-  url: string;
-  method: string;
-  header?: Record<string, string>;
-  query?: Record<string, string>;
-  body?: Record<string, unknown>;
-  setter?: Record<string, TAssignFunction>;
-  pre?: Record<string, TDirectAssignOp>;
-};
-
-export type TDbProviderFunction = {
-  type: TProviderFunctionTypes.DB;
-  client: TDbProviderClients;
-  username: string;
-  password: string;
-  host: string;
-  database: string;
-  port: string;
-  query: string;
-  setter?: Record<string, TAssignFunction>;
-  pre?: Record<string, TDirectAssignOp>;
-};
-
-export type TProviderFunction = THttpProviderFunction | TDbProviderFunction;
-
-export type TProviderTemplate = {
-  inputs: {
-    type: "object";
-    properties: Record<string, { type: string; [x: string]: unknown; desc?: string }>;
-    required?: string[];
-  };
-  outputs: Record<string, unknown>;
-  functions: {
-    set: TProviderFunction;
-    remove?: TProviderFunction;
-    test: TProviderFunction;
-  };
-};
-
-// function type args
-export type TGetProviderTemplates = {
-  workspaceId: string;
-};
-
-export type TCreateSecretRotation = {
-  provider: string;
-  customProvider?: string;
-  workspaceId: string;
-  secretPath: string;
-  environment: string;
-  interval: number;
-  inputs: Record<string, unknown>;
-  outputs: Record<string, string>;
-};

backend/src/ee/services/EEAuditLogService.ts

@@ -3,6 +3,7 @@ import { AuditLog, Event } from "../models";
 import { AuthData } from "../../interfaces/middleware";
 import EELicenseService from "./EELicenseService";
 import { Workspace } from "../../models";
+import { OrganizationNotFoundError } from "../../utils/errors";
 
 interface EventScope {
     workspaceId?: Types.ObjectId;
@@ -13,42 +14,31 @@ type ValidEventScope =
     | Required<Pick<EventScope, "workspaceId">>
     | Required<Pick<EventScope, "organizationId">>
     | Required<EventScope>
-    | Record<string, never>;
 
 export default class EEAuditLogService {
-    static async createAuditLog(authData: AuthData, event: Event, eventScope: ValidEventScope = {}, shouldSave = true) {
+    static async createAuditLog(authData: AuthData, event: Event, eventScope: ValidEventScope, shouldSave = true) {
         
         const MS_IN_DAY = 24 * 60 * 60 * 1000;
         
-        let organizationId;
-        if ("organizationId" in eventScope) {
-            organizationId = eventScope.organizationId;
-        } 
+        const organizationId = ("organizationId" in eventScope)
+            ? eventScope.organizationId
+            : (await Workspace.findById(eventScope.workspaceId).select("organization").lean())?.organization;
         
-        let workspaceId;
-        if ("workspaceId" in eventScope) {
-            workspaceId = eventScope.workspaceId;
-            
-            if (!organizationId) {
-                organizationId = (await Workspace.findById(workspaceId).select("organization").lean())?.organization;
-            }
-        }
-        
-        let expiresAt;
-        if (organizationId) {
-            const ttl = (await EELicenseService.getPlan(organizationId)).auditLogsRetentionDays * MS_IN_DAY;
-            expiresAt = new Date(Date.now() + ttl);
-        }
+        if (!organizationId) throw OrganizationNotFoundError({
+            message: "createAuditLog: Failed to create audit log due to missing organizationId"
+        });
+
+        const ttl = (await EELicenseService.getPlan(organizationId)).auditLogsRetentionDays * MS_IN_DAY;
         
         const auditLog = await new AuditLog({
             actor: authData.actor,
             organization: organizationId,
-            workspace: workspaceId,
+            workspace: ("workspaceId" in eventScope) ? eventScope.workspaceId : undefined,
             ipAddress: authData.ipAddress,
             event,
             userAgent: authData.userAgent,
             userAgentType: authData.userAgentType,
-            expiresAt
+            expiresAt: new Date(Date.now() + ttl)
         });
         
         if (shouldSave) {

backend/src/ee/services/EELicenseService.ts

@@ -38,7 +38,6 @@ interface FeatureSet {
     trial_end: number | null;
     has_used_trial: boolean;
     secretApproval: boolean;
-    secretRotation: boolean;
 }
 
 /**
@@ -75,8 +74,7 @@ class EELicenseService {
         status: null,
         trial_end: null,
         has_used_trial: true,
-        secretApproval: false,
-        secretRotation: true,
+        secretApproval: false
     }
 
     public localFeatureSet: NodeCache;

backend/src/ee/services/EELogService.ts

@@ -0,0 +1,91 @@
+import { Types } from "mongoose";
+import { 
+    IAction,
+} from "../models";
+import {
+    createLogHelper,
+} from "../helpers/log";
+import {
+    createActionHelper,
+} from "../helpers/action";
+import EELicenseService from "./EELicenseService";
+
+/**
+ * Class to handle Enterprise Edition log actions
+ */
+class EELogService {
+    /**
+     * Create an (audit) log
+     * @param {Object} obj
+     * @param {String} obj.userId - id of user associated with the log
+     * @param {String} obj.workspaceId - id of workspace associated with the log
+     * @param {Action} obj.actions - actions to include in log
+     * @param {String} obj.channel - channel (web/cli/auto) associated with the log
+     * @param {String} obj.ipAddress - ip address associated with the log
+     * @returns {Log} log - new audit log
+     */
+    static async createLog({
+        userId,
+        serviceAccountId,
+        serviceTokenDataId,
+        workspaceId,
+        actions,
+        channel,
+        ipAddress,
+    }: {
+        userId?: Types.ObjectId;
+        serviceAccountId?: Types.ObjectId;
+        serviceTokenDataId?: Types.ObjectId;
+        workspaceId?: Types.ObjectId;
+        actions: IAction[];
+        channel: string;
+        ipAddress: string;
+    }) {
+        if (!EELicenseService.isLicenseValid) return null;
+        return await createLogHelper({
+            userId,
+            serviceAccountId,
+            serviceTokenDataId,
+            workspaceId,
+            actions,
+            channel,
+            ipAddress,
+        })
+    }
+    
+    /**
+     * Create an (audit) action
+     * @param {Object} obj
+     * @param {String} obj.name - name of action
+     * @param {Types.ObjectId} obj.userId - id of user associated with the action
+     * @param {Types.ObjectId} obj.workspaceId - id of workspace associated with the action
+     * @param {ObjectId[]} obj.secretIds - ids of secrets associated with the action
+     * @returns {Action} action - new action
+     */
+    static async createAction({
+        name,
+        userId,
+        serviceAccountId,
+        serviceTokenDataId,
+        workspaceId,
+        secretIds,
+    }: {
+        name: string;
+        userId?: Types.ObjectId;
+        serviceAccountId?: Types.ObjectId;
+        serviceTokenDataId?: Types.ObjectId;
+        workspaceId?: Types.ObjectId;
+        secretIds?: Types.ObjectId[];
+    }) {
+        return await createActionHelper({
+            name,
+            userId,
+            serviceAccountId,
+            serviceTokenDataId,
+            workspaceId,
+            secretIds,
+        });
+    }
+}
+
+export default EELogService;

backend/src/ee/services/ProjectRoleService.ts

@@ -1,4 +1,3 @@
-import { Types } from "mongoose";
 import {
   AbilityBuilder,
   ForcedSubject,
@@ -7,19 +6,11 @@ import {
   buildMongoQueryMatcher,
   createMongoAbility
 } from "@casl/ability";
-import { UnauthorizedRequestError } from "../../utils/errors";
+import { Membership } from "../../models";
+import { IRole } from "../models/role";
+import { BadRequestError, UnauthorizedRequestError } from "../../utils/errors";
 import { FieldCondition, FieldInstruction, JsInterpreter } from "@ucast/mongo2js";
 import picomatch from "picomatch";
-import { AuthData } from "../../interfaces/middleware";
-import { ActorType, IRole, Role } from "../models";
-import { 
-  IIdentity,
-  IdentityMembership,
-  Membership,
-  ServiceTokenData
-} from "../../models";
-import { ADMIN, CUSTOM, MEMBER, NO_ACCESS, VIEWER } from "../../variables";
-import { BadRequestError } from "../../utils/errors";
 
 const $glob: FieldInstruction<string> = {
   type: "field",
@@ -59,9 +50,7 @@ export enum ProjectPermissionSub {
   Workspace = "workspace",
   Secrets = "secrets",
   SecretRollback = "secret-rollback",
-  SecretApproval = "secret-approval",
-  SecretRotation = "secret-rotation",
-  Identity = "identity"
+  SecretApproval = "secret-approval"
 }
 
 type SubjectFields = {
@@ -85,8 +74,6 @@ export type ProjectPermissionSet =
   | [ProjectPermissionActions, ProjectPermissionSub.Settings]
   | [ProjectPermissionActions, ProjectPermissionSub.ServiceTokens]
   | [ProjectPermissionActions, ProjectPermissionSub.SecretApproval]
-  | [ProjectPermissionActions, ProjectPermissionSub.SecretRotation]
-  | [ProjectPermissionActions, ProjectPermissionSub.Identity]
   | [ProjectPermissionActions.Delete, ProjectPermissionSub.Workspace]
   | [ProjectPermissionActions.Edit, ProjectPermissionSub.Workspace]
   | [ProjectPermissionActions.Read, ProjectPermissionSub.SecretRollback]
@@ -105,11 +92,6 @@ const buildAdminPermission = () => {
   can(ProjectPermissionActions.Edit, ProjectPermissionSub.SecretApproval);
   can(ProjectPermissionActions.Delete, ProjectPermissionSub.SecretApproval);
 
-  can(ProjectPermissionActions.Read, ProjectPermissionSub.SecretRotation);
-  can(ProjectPermissionActions.Create, ProjectPermissionSub.SecretRotation);
-  can(ProjectPermissionActions.Edit, ProjectPermissionSub.SecretRotation);
-  can(ProjectPermissionActions.Delete, ProjectPermissionSub.SecretRotation);
-
   can(ProjectPermissionActions.Read, ProjectPermissionSub.SecretRollback);
   can(ProjectPermissionActions.Create, ProjectPermissionSub.SecretRollback);
 
@@ -133,11 +115,6 @@ const buildAdminPermission = () => {
   can(ProjectPermissionActions.Edit, ProjectPermissionSub.Webhooks);
   can(ProjectPermissionActions.Delete, ProjectPermissionSub.Webhooks);
 
-  can(ProjectPermissionActions.Read, ProjectPermissionSub.Identity);
-  can(ProjectPermissionActions.Create, ProjectPermissionSub.Identity);
-  can(ProjectPermissionActions.Edit, ProjectPermissionSub.Identity);
-  can(ProjectPermissionActions.Delete, ProjectPermissionSub.Identity);
-
   can(ProjectPermissionActions.Read, ProjectPermissionSub.ServiceTokens);
   can(ProjectPermissionActions.Create, ProjectPermissionSub.ServiceTokens);
   can(ProjectPermissionActions.Edit, ProjectPermissionSub.ServiceTokens);
@@ -185,7 +162,6 @@ const buildMemberPermission = () => {
   can(ProjectPermissionActions.Delete, ProjectPermissionSub.Secrets);
 
   can(ProjectPermissionActions.Read, ProjectPermissionSub.SecretApproval);
-  can(ProjectPermissionActions.Read, ProjectPermissionSub.SecretRotation);
 
   can(ProjectPermissionActions.Read, ProjectPermissionSub.SecretRollback);
   can(ProjectPermissionActions.Create, ProjectPermissionSub.SecretRollback);
@@ -203,11 +179,6 @@ const buildMemberPermission = () => {
   can(ProjectPermissionActions.Edit, ProjectPermissionSub.Webhooks);
   can(ProjectPermissionActions.Delete, ProjectPermissionSub.Webhooks);
 
-  can(ProjectPermissionActions.Read, ProjectPermissionSub.Identity);
-  can(ProjectPermissionActions.Create, ProjectPermissionSub.Identity);
-  can(ProjectPermissionActions.Edit, ProjectPermissionSub.Identity);
-  can(ProjectPermissionActions.Delete, ProjectPermissionSub.Identity);
-
   can(ProjectPermissionActions.Read, ProjectPermissionSub.ServiceTokens);
   can(ProjectPermissionActions.Create, ProjectPermissionSub.ServiceTokens);
   can(ProjectPermissionActions.Edit, ProjectPermissionSub.ServiceTokens);
@@ -243,12 +214,10 @@ const buildViewerPermission = () => {
   can(ProjectPermissionActions.Read, ProjectPermissionSub.Secrets);
   can(ProjectPermissionActions.Read, ProjectPermissionSub.SecretApproval);
   can(ProjectPermissionActions.Read, ProjectPermissionSub.SecretRollback);
-  can(ProjectPermissionActions.Read, ProjectPermissionSub.SecretRotation);
   can(ProjectPermissionActions.Read, ProjectPermissionSub.Member);
   can(ProjectPermissionActions.Read, ProjectPermissionSub.Role);
   can(ProjectPermissionActions.Read, ProjectPermissionSub.Integrations);
   can(ProjectPermissionActions.Read, ProjectPermissionSub.Webhooks);
-  can(ProjectPermissionActions.Read, ProjectPermissionSub.Identity);
   can(ProjectPermissionActions.Read, ProjectPermissionSub.ServiceTokens);
   can(ProjectPermissionActions.Read, ProjectPermissionSub.Settings);
   can(ProjectPermissionActions.Read, ProjectPermissionSub.Environments);
@@ -261,155 +230,31 @@ const buildViewerPermission = () => {
 
 export const viewerProjectPermission = buildViewerPermission();
 
-const buildNoAccessProjectPermission = () => {
-  const { build } = new AbilityBuilder<MongoAbility<ProjectPermissionSet>>(createMongoAbility);
-  return build({ conditionsMatcher });
-}
+export const getUserProjectPermissions = async (userId: string, workspaceId: string) => {
+  // TODO(akhilmhdh): speed this up by pulling from cache later
+  const membership = await Membership.findOne({
+    user: userId,
+    workspace: workspaceId
+  })
+    .populate<{
+      customRole: IRole & { permissions: RawRuleOf<MongoAbility<ProjectPermissionSet>>[] };
+    }>("customRole")
+    .exec();
 
-export const noAccessProjectPermissions = buildNoAccessProjectPermission();
-
-/**
- * Return permissions for user/service pertaining to workspace with id [workspaceId]
- * 
- * Note: should not rely on this function for ST V2 authorization logic
- * b/c ST V2 does not support role-based access control
- */
-export const getAuthDataProjectPermissions = async ({
-  authData,
-  workspaceId
-}: {
-  authData: AuthData;
-  workspaceId: Types.ObjectId;
-}) => {
-  let role: "admin" | "member" | "viewer" | "no-access" | "custom";
-  let customRole;
-  
-  switch (authData.actor.type) {
-    case ActorType.USER: {
-      const membership = await Membership.findOne({
-        user: authData.authPayload._id,
-        workspace: workspaceId
-      })
-      .populate<{
-        customRole: IRole & { permissions: RawRuleOf<MongoAbility<ProjectPermissionSet>>[] };
-      }>("customRole")
-      .exec();
-    
-      if (!membership || (membership.role === "custom" && !membership.customRole)) {
-        throw UnauthorizedRequestError();
-      }
-      
-      role = membership.role;
-      customRole = membership.customRole;
-      break;
-    }
-    case ActorType.SERVICE: {
-      const serviceTokenData = await ServiceTokenData.findById(authData.authPayload._id);
-      if (!serviceTokenData || !serviceTokenData.workspace.equals(workspaceId)) throw UnauthorizedRequestError();
-      role = "viewer";
-      break;
-    }
-    case ActorType.IDENTITY: {
-      const identityMembership = await IdentityMembership.findOne({
-        identity: authData.authPayload._id,
-        workspace: workspaceId
-      })
-      .populate<{
-        customRole: IRole & { permissions: RawRuleOf<MongoAbility<ProjectPermissionSet>>[] };
-        identity: IIdentity
-      }>("customRole identity")
-      .exec();
-      
-      if (!identityMembership || (identityMembership.role === "custom" && !identityMembership.customRole)) {
-        throw UnauthorizedRequestError();
-      }
-    
-      role = identityMembership.role;
-      customRole = identityMembership.customRole;
-
-      break;
-    }
-    default:
-      throw UnauthorizedRequestError();
+  if (!membership || (membership.role === "custom" && !membership.customRole)) {
+    throw UnauthorizedRequestError({ message: "User doesn't belong to organization" });
   }
 
-  switch (role) {
-    case ADMIN:
-      return { permission: adminProjectPermissions };
-    case MEMBER:
-      return { permission: memberProjectPermissions };
-    case VIEWER:
-      return { permission: viewerProjectPermission };
-    case NO_ACCESS:
-      return { permission: noAccessProjectPermissions };
-    case CUSTOM: {
-      if (!customRole) throw UnauthorizedRequestError();
-      return { 
-        permission: createMongoAbility<ProjectPermissionSet>(
-          customRole.permissions, 
-          { conditionsMatcher }
-        )
-      };
-    }
-    default:
-      throw UnauthorizedRequestError();
-  }
-}
+  if (membership.role === "admin") return { permission: adminProjectPermissions, membership };
+  if (membership.role === "member") return { permission: memberProjectPermissions, membership };
+  if (membership.role === "viewer") return { permission: viewerProjectPermission, membership };
 
-export const getWorkspaceRolePermissions = async (role: string, workspaceId: string) => {
-  const isCustomRole = ![ADMIN, MEMBER, VIEWER, NO_ACCESS].includes(role);
-  if (isCustomRole) {
-    const workspaceRole = await Role.findOne({
-      slug: role,
-      isOrgRole: false,
-      workspace: new Types.ObjectId(workspaceId)
-    });
-
-    if (!workspaceRole) throw BadRequestError({ message: "Role not found" });
-    
-    return createMongoAbility<ProjectPermissionSet>(workspaceRole.permissions as RawRuleOf<MongoAbility<ProjectPermissionSet>>[], {
+  if (membership.role === "custom") {
+    const permission = createMongoAbility<ProjectPermissionSet>(membership.customRole.permissions, {
       conditionsMatcher
     });
+    return { permission, membership };
   }
 
-  switch (role) {
-    case ADMIN:
-      return adminProjectPermissions;
-    case MEMBER:
-      return memberProjectPermissions;
-    case VIEWER:
-      return viewerProjectPermission;
-    case NO_ACCESS:
-      return noAccessProjectPermissions;
-    default:
-      throw BadRequestError({ message: "Role not found" });
-  }
-}
-
-/**
- * Extracts and formats permissions from a CASL Ability object or a raw permission set. 
- * @param ability
- * @returns 
- */
- const extractPermissions = (ability: any) => {
-  return ability.A.map((permission: any) => `${permission.action}_${permission.subject}`);
-}
-
-/**
- * Compares two sets of permissions to determine if the first set is at least as privileged as the second set.
- * The function checks if all permissions in the second set are contained within the first set and if the first set has equal or more permissions.
- * 
-*/
-export const isAtLeastAsPrivilegedWorkspace = (permissions1: MongoAbility<ProjectPermissionSet> | ProjectPermissionSet, permissions2: MongoAbility<ProjectPermissionSet> | ProjectPermissionSet) => {
-
-  const set1 = new Set(extractPermissions(permissions1));
-  const set2 = new Set(extractPermissions(permissions2));
-  
-  for (const perm of set2) {
-    if (!set1.has(perm)) {
-      return false;
-    }
-  }
-
-  return set1.size >= set2.size;
-}
+  throw BadRequestError({ message: "User role not found" });
+};

backend/src/ee/services/RoleService.ts

@@ -1,15 +1,9 @@
-import { Types } from "mongoose";
 import { AbilityBuilder, MongoAbility, RawRuleOf, createMongoAbility } from "@casl/ability";
-import { 
-  IIdentity,
-  IdentityMembershipOrg,
-  MembershipOrg
-} from "../../models";
-import { ActorType, IRole, Role } from "../models";
+import { MembershipOrg } from "../../models";
+import { IRole } from "../models/role";
 import { BadRequestError, UnauthorizedRequestError } from "../../utils/errors";
-import { ACCEPTED, ADMIN, CUSTOM, MEMBER, NO_ACCESS} from "../../variables";
+import { ACCEPTED } from "../../variables";
 import { conditionsMatcher } from "./ProjectRoleService";
-import { AuthData } from "../../interfaces/middleware";
 
 export enum OrgPermissionActions {
   Read = "read",
@@ -26,8 +20,7 @@ export enum OrgPermissionSubjects {
   IncidentAccount = "incident-contact",
   Sso = "sso",
   Billing = "billing",
-  SecretScanning = "secret-scanning",
-  Identity = "identity"
+  SecretScanning = "secret-scanning"
 }
 
 export type OrgPermissionSet =
@@ -39,8 +32,7 @@ export type OrgPermissionSet =
   | [OrgPermissionActions, OrgPermissionSubjects.IncidentAccount]
   | [OrgPermissionActions, OrgPermissionSubjects.Sso]
   | [OrgPermissionActions, OrgPermissionSubjects.SecretScanning]
-  | [OrgPermissionActions, OrgPermissionSubjects.Billing]
-  | [OrgPermissionActions, OrgPermissionSubjects.Identity];
+  | [OrgPermissionActions, OrgPermissionSubjects.Billing];
 
 const buildAdminPermission = () => {
   const { can, build } = new AbilityBuilder<MongoAbility<OrgPermissionSet>>(createMongoAbility);
@@ -83,11 +75,6 @@ const buildAdminPermission = () => {
   can(OrgPermissionActions.Edit, OrgPermissionSubjects.Billing);
   can(OrgPermissionActions.Delete, OrgPermissionSubjects.Billing);
 
-  can(OrgPermissionActions.Read, OrgPermissionSubjects.Identity);
-  can(OrgPermissionActions.Create, OrgPermissionSubjects.Identity);
-  can(OrgPermissionActions.Edit, OrgPermissionSubjects.Identity);
-  can(OrgPermissionActions.Delete, OrgPermissionSubjects.Identity);
-
   return build({ conditionsMatcher });
 };
 
@@ -111,26 +98,13 @@ const buildMemberPermission = () => {
   can(OrgPermissionActions.Edit, OrgPermissionSubjects.SecretScanning);
   can(OrgPermissionActions.Delete, OrgPermissionSubjects.SecretScanning);
 
-  can(OrgPermissionActions.Read, OrgPermissionSubjects.Identity);
-  can(OrgPermissionActions.Create, OrgPermissionSubjects.Identity);
-  can(OrgPermissionActions.Edit, OrgPermissionSubjects.Identity);
-  can(OrgPermissionActions.Delete, OrgPermissionSubjects.Identity);
-
   return build({ conditionsMatcher });
 };
 
 export const memberPermissions = buildMemberPermission();
 
-const buildNoAccessPermission = () => {
-  const { build } = new AbilityBuilder<MongoAbility<OrgPermissionSet>>(createMongoAbility);
-  return build({ conditionsMatcher });
-}
-
-export const noAccessPermissions = buildNoAccessPermission();
-
 export const getUserOrgPermissions = async (userId: string, orgId: string) => {
   // TODO(akhilmhdh): speed this up by pulling from cache later
-  
   const membership = await MembershipOrg.findOne({
     user: userId,
     organization: orgId,
@@ -145,13 +119,11 @@ export const getUserOrgPermissions = async (userId: string, orgId: string) => {
     throw UnauthorizedRequestError({ message: "User doesn't belong to organization" });
   }
 
-  if (membership.role === ADMIN) return { permission: adminPermissions, membership };
+  if (membership.role === "admin") return { permission: adminPermissions, membership };
 
-  if (membership.role === MEMBER) return { permission: memberPermissions, membership };
-  
-  if (membership.role === NO_ACCESS) return { permission: noAccessPermissions, membership }
+  if (membership.role === "member") return { permission: memberPermissions, membership };
 
-  if (membership.role === CUSTOM) {
+  if (membership.role === "custom") {
     const permission = createMongoAbility<OrgPermissionSet>(membership.customRole.permissions, {
       conditionsMatcher
     });
@@ -160,142 +132,3 @@ export const getUserOrgPermissions = async (userId: string, orgId: string) => {
 
   throw BadRequestError({ message: "User role not found" });
 };
-
-/**
- * Return permissions for user/service pertaining to organization with id [organizationId]
- * 
- * Note: should not rely on this function for ST V2 authorization logic
- * b/c ST V2 does not support role-based access control but also not organization-level resources
- */
- export const getAuthDataOrgPermissions = async ({
-  authData,
-  organizationId
-}: {
-  authData: AuthData;
-  organizationId: Types.ObjectId;
-}) => {
-  let role: "admin" | "member" | "no-access" | "custom";
-  let customRole;
-  
-  switch (authData.actor.type) {
-    case ActorType.USER: {
-      const membershipOrg = await MembershipOrg.findOne({
-        user: authData.authPayload._id,
-        organization: organizationId,
-        status: ACCEPTED
-      })
-      .populate<{ customRole: IRole & { permissions: RawRuleOf<MongoAbility<OrgPermissionSet>>[] } }>(
-        "customRole"
-      )
-      .exec();
-      
-      if (!membershipOrg || (membershipOrg.role === "custom" && !membershipOrg.customRole)) {
-        throw UnauthorizedRequestError({ message: "User doesn't belong to organization" });
-      }
-      
-      role = membershipOrg.role;
-      customRole = membershipOrg.customRole;
-      break;
-    }
-    case ActorType.SERVICE: {
-      throw UnauthorizedRequestError({
-        message: "Failed to access organization-level resources with service token"
-      });
-    }
-    case ActorType.IDENTITY: {
-      const identityMembershipOrg = await IdentityMembershipOrg.findOne({
-        identity: authData.authPayload._id,
-        organization: organizationId
-      })
-      .populate<{
-        customRole: IRole & { permissions: RawRuleOf<MongoAbility<OrgPermissionSet>>[] };
-        identity: IIdentity
-      }>("customRole identity")
-      .exec();
-      
-      if (!identityMembershipOrg || (identityMembershipOrg.role === "custom" && !identityMembershipOrg.customRole)) {
-        throw UnauthorizedRequestError();
-      }
-      
-      role = identityMembershipOrg.role;
-      customRole = identityMembershipOrg.customRole;
-      break;
-    }
-    default:
-      throw UnauthorizedRequestError();
-  }
-
-  switch (role) {
-    case ADMIN:
-      return { permission: adminPermissions };
-    case MEMBER:
-      return { permission: memberPermissions };
-    case NO_ACCESS:
-      return { permission: noAccessPermissions };
-    case CUSTOM: {
-      if (!customRole) throw UnauthorizedRequestError();
-      return {
-        permission: createMongoAbility<OrgPermissionSet>(
-          customRole.permissions, 
-          { conditionsMatcher }
-        )
-      };
-    }
-  }
-}
-
-export const getOrgRolePermissions = async (role: string, orgId: string) => {
-  const isCustomRole = ![ADMIN, MEMBER, NO_ACCESS].includes(role);
-  if (isCustomRole) {
-    const orgRole = await Role.findOne({
-      slug: role,
-      isOrgRole: true,
-      organization: new Types.ObjectId(orgId)
-    });
-
-    if (!orgRole) throw BadRequestError({ message: "Org Role not found" });
-    
-    return createMongoAbility<OrgPermissionSet>(orgRole.permissions as RawRuleOf<MongoAbility<OrgPermissionSet>>[], {
-      conditionsMatcher
-    });
-  }
-
-  switch (role) {
-    case ADMIN:
-      return adminPermissions;
-    case MEMBER:
-      return memberPermissions;
-    case NO_ACCESS:
-      return noAccessPermissions;
-    default:
-      throw BadRequestError({ message: "User org role not found" });
-  }
-}
-
-/**
- * Extracts and formats permissions from a CASL Ability object or a raw permission set. 
- * @param ability
- * @returns 
- */
-const extractPermissions = (ability: any) => {
-  return ability.A.map((permission: any) => `${permission.action}_${permission.subject}`);
-}
-
-/**
- * Compares two sets of permissions to determine if the first set is at least as privileged as the second set.
- * The function checks if all permissions in the second set are contained within the first set and if the first set has equal or more permissions.
- * 
-*/
-export const isAtLeastAsPrivilegedOrg = (permissions1: MongoAbility<OrgPermissionSet> | OrgPermissionSet, permissions2: MongoAbility<OrgPermissionSet> | OrgPermissionSet) => {
-
-  const set1 = new Set(extractPermissions(permissions1));
-  const set2 = new Set(extractPermissions(permissions2));
-  
-  for (const perm of set2) {
-    if (!set1.has(perm)) {
-      return false;
-    }
-  }
-
-  return set1.size >= set2.size;
-}

backend/src/ee/services/index.ts

@@ -1,11 +1,13 @@
 import EELicenseService from "./EELicenseService";
 import EESecretService from "./EESecretService";
+import EELogService from "./EELogService";
 import EEAuditLogService from "./EEAuditLogService";
 import GithubSecretScanningService from "./GithubSecretScanning/GithubSecretScanningService"
 
 export {
     EELicenseService,
     EESecretService,
+    EELogService,
     EEAuditLogService,
     GithubSecretScanningService
 }

backend/src/ee/validation/secretRotation.ts

@@ -1,32 +0,0 @@
-import { z } from "zod";
-
-export const createSecretRotationV1 = z.object({
-  body: z.object({
-    workspaceId: z.string().trim(),
-    secretPath: z.string().trim(),
-    environment: z.string().trim(),
-    interval: z.number().min(1),
-    provider: z.string().trim(),
-    customProvider: z.string().trim().optional(),
-    inputs: z.record(z.unknown()),
-    outputs: z.record(z.string())
-  })
-});
-
-export const restartSecretRotationV1 = z.object({
-  body: z.object({
-    id: z.string().trim()
-  })
-});
-
-export const getSecretRotationV1 = z.object({
-  query: z.object({
-    workspaceId: z.string().trim()
-  })
-});
-
-export const removeSecretRotationV1 = z.object({
-  params: z.object({
-    id: z.string().trim()
-  })
-});

backend/src/ee/validation/secretRotationProvider.ts

@@ -1,7 +0,0 @@
-import { z } from "zod";
-
-export const getSecretRotationProvidersV1 = z.object({
-  params: z.object({
-    workspaceId: z.string()
-  })
-});

backend/src/helpers/auth.ts

@@ -1,13 +1,381 @@
+import { Request } from "express";
 import { Types } from "mongoose";
 import jwt from "jsonwebtoken";
-import { ITokenVersion, TokenVersion } from "../models";
-import { UnauthorizedRequestError } from "../utils/errors";
+import bcrypt from "bcrypt";
+import {
+	APIKeyData,
+	APIKeyDataV2,
+	ITokenVersion,
+	IUser,
+	ServiceTokenData,
+	ServiceTokenDataV3,
+	TokenVersion,
+	User,
+} from "../models";
+import {
+	APIKeyDataNotFoundError,
+	AccountNotFoundError,
+	BadRequestError,
+	ServiceTokenDataNotFoundError,
+	UnauthorizedRequestError,
+} from "../utils/errors";
 import {
 	getAuthSecret,
 	getJwtAuthLifetime,
-	getJwtRefreshLifetime
+	getJwtRefreshLifetime,
+	getJwtServiceTokenSecret
 } from "../config";
-import { AuthTokenType } from "../variables";
+import {
+	AuthMode,
+	AuthTokenType
+} from "../variables";
+import {
+	ServiceTokenAuthData,
+	ServiceTokenV3AuthData,
+	UserAuthData
+} from "../interfaces/middleware";
+
+import { ActorType } from "../ee/models";
+import { getUserAgentType } from "../utils/posthog";
+
+/**
+ * 
+ * @param {Object} obj
+ * @param {Object} obj.headers - HTTP request headers object
+ */
+export const validateAuthMode = ({
+	headers,
+	acceptedAuthModes,
+}: {
+	headers: { [key: string]: string | string[] | undefined },
+	acceptedAuthModes: AuthMode[]
+}) => {
+	
+	const apiKey = headers["x-api-key"];
+	const authHeader = headers["authorization"];
+
+	let authMode, authTokenValue;
+	if (apiKey === undefined && authHeader === undefined) {
+		// case: no auth or X-API-KEY header present
+		throw BadRequestError({ message: "Missing Authorization or X-API-KEY in request header." });
+	}
+
+	if (typeof apiKey === "string") {
+		// case: treat request authentication type as via X-API-KEY (i.e. API Key)
+		authMode = AuthMode.API_KEY;
+		authTokenValue = apiKey;
+	}
+
+	if (typeof authHeader === "string") {
+		// case: treat request authentication type as via Authorization header (i.e. either JWT or service token)
+		const [tokenType, tokenValue] = <[string, string]>authHeader.split(" ", 2) ?? [null, null]
+
+		if (tokenType === null)
+			throw BadRequestError({ message: "Missing Authorization Header in the request header." });
+		if (tokenType.toLowerCase() !== "bearer")
+			throw BadRequestError({ message: `The provided authentication type '${tokenType}' is not supported.` });
+		if (tokenValue === null)
+			throw BadRequestError({ message: "Missing Authorization Body in the request header." });
+
+		const parts = tokenValue.split(".");
+		
+		switch (parts[0]) {
+			case "st":
+				authMode = AuthMode.SERVICE_TOKEN;
+				authTokenValue = tokenValue;
+				break;
+			case "stv3":
+				authMode = AuthMode.SERVICE_TOKEN_V3;
+				authTokenValue = parts.slice(1).join(".");
+				break;
+			default:
+				authMode = AuthMode.JWT;
+				authTokenValue = tokenValue;
+		}
+	}
+
+	if (!authMode || !authTokenValue) throw BadRequestError({ message: "Missing valid Authorization or X-API-KEY in request header." });
+
+	if (!acceptedAuthModes.includes(authMode)) throw BadRequestError({ message: "The provided authentication type is not supported." });
+
+	return ({
+		authMode,
+		authTokenValue,
+	});
+}
+
+/**
+ * Return user payload corresponding to JWT token [authTokenValue]
+ * that is either for browser / CLI or API Key
+ * @param {Object} obj
+ * @param {String} obj.authTokenValue - JWT token value
+ * @returns {User} user - user corresponding to JWT token
+ */
+export const getAuthUserPayload = async ({
+	req,
+	authTokenValue,
+}: {
+	req: Request,
+	authTokenValue: string;
+}): Promise<UserAuthData> => {
+	const decodedToken = <jwt.UserIDJwtPayload>(
+		jwt.verify(authTokenValue, await getAuthSecret())
+	);
+
+	if (
+		decodedToken.authTokenType !== AuthTokenType.ACCESS_TOKEN &&
+		decodedToken.authTokenType !== AuthTokenType.API_KEY
+	) {
+		throw UnauthorizedRequestError();
+	}
+	
+	if (decodedToken.authTokenType === AuthTokenType.ACCESS_TOKEN) {
+		const tokenVersion = await TokenVersion.findOneAndUpdate({
+			_id: new Types.ObjectId(decodedToken.tokenVersionId),
+			user: decodedToken.userId
+		}, {
+			lastUsed: new Date(),
+		});
+	
+		if (!tokenVersion) throw UnauthorizedRequestError();
+	
+		if (decodedToken.accessVersion !== tokenVersion.accessVersion) throw UnauthorizedRequestError();
+	} else if (decodedToken.authTokenType === AuthTokenType.API_KEY) {
+		const apiKeyData = await APIKeyDataV2.findOneAndUpdate(
+			{
+				_id: new Types.ObjectId(decodedToken.apiKeyDataId),
+				user: new Types.ObjectId(decodedToken.userId)
+			},
+			{
+				lastUsed: new Date(),
+				$inc: { usageCount: 1 }
+			},
+			{
+				new: true
+			}
+		);
+		
+		if (!apiKeyData) throw UnauthorizedRequestError();
+	}
+
+	const user = await User.findOne({
+		_id: new Types.ObjectId(decodedToken.userId),
+	}).select("+publicKey +accessVersion");
+
+	if (!user) throw AccountNotFoundError({ message: "Failed to find user" });
+
+	if (!user?.publicKey) throw UnauthorizedRequestError({ message: "Failed to authenticate user with partially set up account" });
+
+	return {
+		actor: {
+			type: ActorType.USER,
+			metadata: {
+				userId: user._id.toString(),
+				email: user.email
+			}
+		},
+		authPayload: user,
+		ipAddress: req.realIP,
+		userAgent: req.headers["user-agent"] ?? "",
+		userAgentType: getUserAgentType(req.headers["user-agent"])
+	}
+}
+
+/**
+ * Return service token data payload corresponding to service token [authTokenValue]
+ * @param {Object} obj
+ * @param {String} obj.authTokenValue - service token value
+ * @returns {ServiceTokenData} serviceTokenData - service token data
+ */
+export const getAuthSTDPayload = async ({
+	req,
+	authTokenValue,
+}: {
+	req: Request,
+	authTokenValue: string;
+}): Promise<ServiceTokenAuthData> => {
+	const [_, TOKEN_IDENTIFIER, TOKEN_SECRET] = <[string, string, string]>authTokenValue.split(".", 3);
+
+	const serviceTokenData = await ServiceTokenData
+		.findById(TOKEN_IDENTIFIER, "+secretHash +expiresAt")
+
+	if (!serviceTokenData) {
+		throw ServiceTokenDataNotFoundError({ message: "Failed to find service token data" });
+	} else if (serviceTokenData?.expiresAt && new Date(serviceTokenData.expiresAt) < new Date()) {
+		// case: service token expired
+		await ServiceTokenData.findByIdAndDelete(serviceTokenData._id);
+		throw UnauthorizedRequestError({
+			message: "Failed to authenticate expired service token",
+		});
+	}
+
+	const isMatch = await bcrypt.compare(TOKEN_SECRET, serviceTokenData.secretHash);
+	if (!isMatch) throw UnauthorizedRequestError({
+		message: "Failed to authenticate service token",
+	});
+
+	const serviceTokenDataToReturn = await ServiceTokenData
+		.findOneAndUpdate({
+			_id: new Types.ObjectId(TOKEN_IDENTIFIER),
+		}, {
+			lastUsed: new Date(),
+		}, {
+			new: true,
+		})
+		.select("+encryptedKey +iv +tag")
+
+	if (!serviceTokenDataToReturn) throw ServiceTokenDataNotFoundError({ message: "Failed to find service token data" });
+
+	return {
+		actor: {
+			type: ActorType.SERVICE,
+			metadata: {
+				serviceId: serviceTokenDataToReturn._id.toString(),
+				name: serviceTokenDataToReturn.name
+			}
+		},
+		authPayload: serviceTokenDataToReturn,
+		ipAddress: req.realIP,
+		userAgent: req.headers["user-agent"] ?? "",
+		userAgentType: getUserAgentType(req.headers["user-agent"])
+	}
+}
+
+/**
+ * Return service token data V3 payload corresponding to service token [authTokenValue]
+ * @param {Object} obj
+ * @param {String} obj.authTokenValue - service token value
+ * @returns {ServiceTokenData} serviceTokenData - service token data
+ */
+ export const getAuthSTDV3Payload = async ({
+	req,
+	authTokenValue,
+}: {
+	req: Request,
+	authTokenValue: string;
+}): Promise<ServiceTokenV3AuthData> => {
+	const decodedToken = <jwt.UserIDJwtPayload>(
+		jwt.verify(authTokenValue, await getJwtServiceTokenSecret())
+	);
+	
+	const serviceTokenData = await ServiceTokenDataV3.findOneAndUpdate(
+		{
+			_id: new Types.ObjectId(decodedToken._id),
+			isActive: true
+		},
+		{
+			lastUsed: new Date(),
+			$inc: { usageCount: 1 }
+		},
+		{
+			new: true
+		}
+	);
+	
+	if (!serviceTokenData) {
+		throw UnauthorizedRequestError({ 
+			message: "Failed to authenticate"
+		});
+	} else if (serviceTokenData?.expiresAt && new Date(serviceTokenData.expiresAt) < new Date()) {
+		// case: service token expired
+		await ServiceTokenDataV3.findByIdAndUpdate(
+			serviceTokenData._id,
+			{
+				isActive: false
+			},
+			{
+				new: true
+			}
+		);
+		
+		throw UnauthorizedRequestError({
+			message: "Failed to authenticate",
+		});
+	}
+
+	return {
+		actor: {
+			type: ActorType.SERVICE_V3,
+			metadata: {
+				serviceId: serviceTokenData._id.toString(),
+				name: serviceTokenData.name
+			}
+		},
+		authPayload: serviceTokenData,
+		ipAddress: req.realIP,
+		userAgent: req.headers["user-agent"] ?? "",
+		userAgentType: getUserAgentType(req.headers["user-agent"])
+	}
+}
+
+/**
+ * Return API key data payload corresponding to API key [authTokenValue]
+ * @param {Object} obj
+ * @param {String} obj.authTokenValue - API key value
+ * @returns {APIKeyData} apiKeyData - API key data
+ */
+export const getAuthAPIKeyPayload = async ({
+	req,
+	authTokenValue,
+}: {
+	req: Request,
+	authTokenValue: string;
+}): Promise<UserAuthData> => {
+	const [_, TOKEN_IDENTIFIER, TOKEN_SECRET] = <[string, string, string]>authTokenValue.split(".", 3);
+
+	let apiKeyData = await APIKeyData
+		.findById(TOKEN_IDENTIFIER, "+secretHash +expiresAt")
+		.populate<{ user: IUser }>("user", "+publicKey");
+
+	if (!apiKeyData) {
+		throw APIKeyDataNotFoundError({ message: "Failed to find API key data" });
+	} else if (apiKeyData?.expiresAt && new Date(apiKeyData.expiresAt) < new Date()) {
+		// case: API key expired
+		await APIKeyData.findByIdAndDelete(apiKeyData._id);
+		throw UnauthorizedRequestError({
+			message: "Failed to authenticate expired API key",
+		});
+	}
+
+	const isMatch = await bcrypt.compare(TOKEN_SECRET, apiKeyData.secretHash);
+	if (!isMatch) throw UnauthorizedRequestError({
+		message: "Failed to authenticate API key",
+	});
+
+	apiKeyData = await APIKeyData.findOneAndUpdate({
+		_id: new Types.ObjectId(TOKEN_IDENTIFIER),
+	}, {
+		lastUsed: new Date(),
+	}, {
+		new: true,
+	});
+
+	if (!apiKeyData) {
+		throw APIKeyDataNotFoundError({ message: "Failed to find API key data" });
+	}
+
+	const user = await User.findById(apiKeyData.user).select("+publicKey");
+
+	if (!user) {
+		throw AccountNotFoundError({
+			message: "Failed to find user",
+		});
+	}
+
+	return {
+		actor: {
+			type: ActorType.USER,
+			metadata: {
+				userId: user._id.toString(),
+				email: user.email
+			}
+		},
+		authPayload: user,
+		ipAddress: req.realIP,
+		userAgent: req.headers["user-agent"] ?? "",
+		userAgentType: getUserAgentType(req.headers["user-agent"])
+	}
+}
 
 /**
  * Return newly issued (JWT) auth and refresh tokens to user with id [userId]

backend/src/helpers/bot.ts

@@ -13,7 +13,7 @@ import {
   SECRET_SHARED
 } from "../variables";
 import { client, getEncryptionKey, getRootEncryptionKey } from "../config";
-import { BotNotFoundError, InternalServerError } from "../utils/errors";
+import { InternalServerError } from "../utils/errors";
 import { Folder } from "../models";
 import { getFolderByPath } from "../services/FolderService";
 import { getAllImportedSecrets } from "../services/SecretImportService";
@@ -223,7 +223,7 @@ export const getKey = async ({ workspaceId }: { workspaceId: Types.ObjectId }) =
     workspace: workspaceId
   }).populate<{ sender: IUser }>("sender", "publicKey");
 
-  if (!botKey) throw BotNotFoundError({ message: `getKey: Failed to find bot key for [workspaceId=${workspaceId}]` })
+  if (!botKey) throw new Error("Failed to find bot key");
 
   const bot = await Bot.findOne({
     workspace: workspaceId

backend/src/helpers/database.ts

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-import { logger } from "../utils/logging";
+import { getLogger } from "../utils/logger";
 
 /**
  * Initialize database connection
@@ -18,10 +18,10 @@ export const initDatabaseHelper = async ({
         // allow empty strings to pass the required validator
         mongoose.Schema.Types.String.checkRequired(v => typeof v === "string");
 
-        logger.info("Database connection established");
+        (await getLogger("database")).info("Database connection established");
 
     } catch (err) {
-        logger.error(err, "Unable to establish database connection");
+        (await getLogger("database")).error(`Unable to establish Database connection due to the error.\n${err}`);
     }
 
     return mongoose.connection;

backend/src/helpers/membership.ts

@@ -17,7 +17,7 @@ export const validateMembership = async ({
 }: {
   userId: Types.ObjectId | string;
   workspaceId: Types.ObjectId | string;
-  acceptedRoles?: Array<"admin" | "member" | "custom" | "viewer" | "no-access">;
+  acceptedRoles?: Array<"admin" | "member" | "custom" | "viewer">;
 }) => {
   const membership = await Membership.findOne({
     user: userId,

backend/src/helpers/membershipOrg.ts

@@ -18,7 +18,7 @@ export const validateMembershipOrg = async ({
 }: {
   userId: Types.ObjectId;
   organizationId: Types.ObjectId;
-  acceptedRoles?: Array<"owner" | "admin" | "member" | "custom" | "no-access">;
+  acceptedRoles?: Array<"owner" | "admin" | "member" | "custom">;
   acceptedStatuses?: Array<"invited" | "accepted">;
 }) => {
   const membershipOrg = await MembershipOrg.findOne({

backend/src/helpers/organization.ts

@@ -1,14 +1,9 @@
-import { Types } from "mongoose";
+import mongoose, { Types, mongo } from "mongoose";
 import { 
   Bot, 
   BotKey,
   BotOrg,
   Folder,
-  Identity,
-  IdentityMembership,
-  IdentityMembershipOrg,
-  IdentityUniversalAuth,
-  IdentityUniversalAuthClientSecret,
   IncidentContactOrg,
   Integration,
   IntegrationAuth,
@@ -21,16 +16,20 @@ import {
   SecretImport,
   ServiceToken,
   ServiceTokenData,
+  ServiceTokenDataV3,
+  ServiceTokenDataV3Key,
   Tag,
   Webhook,
   Workspace
 } from "../models";
 import {
+  Action,
   AuditLog,
   FolderVersion,
   GitAppInstallationSession,
   GitAppOrganizationInstallation,
   GitRisks,
+  Log,
   Role,
   SSOConfig,
   SecretApprovalPolicy,
@@ -56,7 +55,7 @@ import {
 import {
   createBotOrg
 } from "./botOrg";
-import { ResourceNotFoundError } from "../utils/errors";
+import { InternalServerError, ResourceNotFoundError } from "../utils/errors";
 
 /**
  * Create an organization with name [name]
@@ -112,223 +111,311 @@ export const createOrganization = async ({
  * @returns 
  */
 export const deleteOrganization = async ({
-  organizationId
+  organizationId,
+  existingSession
 }: {
   organizationId: Types.ObjectId;
+  existingSession?: mongo.ClientSession;
 }) => {
 
-  const organization = await Organization.findByIdAndDelete(
-    organizationId
-  );
-
-  if (!organization) throw ResourceNotFoundError();
+  let session;
   
-  await MembershipOrg.deleteMany({
-    organization: organization._id
-  });
-
-  const identityIds = await IdentityMembershipOrg.distinct("identity", {
-    organization: organization._id
-  });
-  
-  await IdentityMembershipOrg.deleteMany({
-    organization: organization._id
-  });
-  
-  await Identity.deleteMany({
-    _id: {
-      $in: identityIds
-    }
-  });
-  
-  await IdentityUniversalAuth.deleteMany({
-    identity: {
-      $in: identityIds
-    }
-  });
-
-  await IdentityUniversalAuthClientSecret.deleteMany({
-    identity: {
-      $in: identityIds
-    }
-  });
-  
-  await BotOrg.deleteMany({
-    organization: organization._id
-  });
-  
-  await SSOConfig.deleteMany({
-    organization: organization._id
-  });
-  
-  await Role.deleteMany({
-    organization: organization._id
-  });
-
-  await IncidentContactOrg.deleteMany({
-    organization: organization._id
-  });
-  
-  await GitRisks.deleteMany({
-    organization: organization._id
-  });
-  
-  await GitAppInstallationSession.deleteMany({
-    organization: organization._id
-  });
-  
-  await GitAppOrganizationInstallation.deleteMany({
-    organization: organization._id
-  });
-
-  const workspaceIds = await Workspace.distinct("_id", {
-    organization: organization._id
-  });
-  
-  await Workspace.deleteMany({
-    organization: organization._id
-  });
-  
-  await Membership.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await Key.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-  
-  await Bot.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-  
-  await BotKey.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await SecretBlindIndexData.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-  
-  await Secret.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-  
-  await SecretVersion.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await SecretSnapshot.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-  
-  await SecretImport.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await Folder.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await FolderVersion.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await Webhook.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await TrustedIP.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-  
-  await Tag.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await IntegrationAuth.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await Integration.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await ServiceToken.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await ServiceTokenData.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await IdentityMembership.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await AuditLog.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await SecretApprovalPolicy.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-
-  await SecretApprovalRequest.deleteMany({
-    workspace: {
-      $in: workspaceIds
-    }
-  });
-  
-  if (organization.customerId) {
-    // delete from stripe here
-    await licenseServerKeyRequest.delete(
-      `${await getLicenseServerUrl()}/api/license-server/v1/customers/${organization.customerId}`
-    );
+  if (existingSession) {
+    session = existingSession;
+  } else {
+    session = await mongoose.startSession(); 
+    session.startTransaction();
   }
+
+  try {
+    const organization = await Organization.findByIdAndDelete(
+      organizationId,
+      {
+        session
+      }
+    );
+  
+    if (!organization) throw ResourceNotFoundError();
     
-  return organization;
+    await MembershipOrg.deleteMany({
+      organization: organization._id
+    }, {
+      session
+    });
+    
+    await BotOrg.deleteMany({
+      organization: organization._id
+    }, {
+      session
+    });
+    
+    await SSOConfig.deleteMany({
+      organization: organization._id
+    }, {
+      session
+    });
+    
+    await Role.deleteMany({
+      organization: organization._id
+    }, {
+      session
+    });
+
+    await IncidentContactOrg.deleteMany({
+      organization: organization._id
+    }, {
+      session
+    });
+    
+    await GitRisks.deleteMany({
+      organization: organization._id
+    }, {
+      session
+    });
+    
+    await GitAppInstallationSession.deleteMany({
+      organization: organization._id
+    }, {
+      session
+    });
+    
+    await GitAppOrganizationInstallation.deleteMany({
+      organization: organization._id
+    }, {
+      session
+    });
+
+    const workspaceIds = await Workspace.distinct("_id", {
+      organization: organization._id
+    });
+    
+    await Workspace.deleteMany({
+      organization: organization._id
+    }, {
+      session
+    });
+    
+    await Membership.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await Key.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+    
+    await Bot.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+    
+    await BotKey.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await SecretBlindIndexData.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+    
+    await Secret.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+    
+    await SecretVersion.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await SecretSnapshot.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+    
+    await SecretImport.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await Folder.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await FolderVersion.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await Webhook.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await TrustedIP.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+    
+    await Tag.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await IntegrationAuth.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await Integration.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await ServiceToken.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await ServiceTokenData.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await ServiceTokenDataV3.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+    
+    await ServiceTokenDataV3Key.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await AuditLog.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await Log.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await Action.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await SecretApprovalPolicy.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+
+    await SecretApprovalRequest.deleteMany({
+      workspace: {
+        $in: workspaceIds
+      }
+    }, {
+      session
+    });
+    
+    if (organization.customerId) {
+      // delete from stripe here
+      await licenseServerKeyRequest.delete(
+        `${await getLicenseServerUrl()}/api/license-server/v1/customers/${organization.customerId}`
+      );
+    }
+    
+    return organization;
+  } catch (err) {
+    if (!existingSession) {
+      await session.abortTransaction();
+    }
+    throw InternalServerError({
+      message: "Failed to delete organization"
+    });
+  } finally {
+    if (!existingSession) {
+      await session.commitTransaction();
+      session.endSession();
+    }
+  }
 }
 
 /**

backend/src/helpers/rateLimiter.ts

@@ -10,7 +10,7 @@ export const apiLimiter = rateLimit({
   //   errorHandler: console.error.bind(null, 'rate-limit-mongo')
   // }),
   windowMs: 60 * 1000,
-  max: 480,
+  max: 350,
   standardHeaders: true,
   legacyHeaders: false,
   skip: (request) => {
@@ -30,7 +30,7 @@ const authLimit = rateLimit({
   //   collectionName: "expressRateRecords-authLimit",
   // }),
   windowMs: 60 * 1000,
-  max: 300,
+  max: 100,
   standardHeaders: true,
   legacyHeaders: false,
   keyGenerator: (req, res) => {
@@ -46,8 +46,8 @@ export const passwordLimiter = rateLimit({
   //   errorHandler: console.error.bind(null, 'rate-limit-mongo'),
   //   collectionName: "expressRateRecords-passwordLimiter",
   // }),
-  windowMs: 60 * 1000,
-  max: 300,
+  windowMs: 60 * 60 * 1000,
+  max: 10,
   standardHeaders: true,
   legacyHeaders: false,
   keyGenerator: (req, res) => {

backend/src/helpers/reminder.ts

@@ -1,58 +0,0 @@
-import { ISecret } from "../models";
-import {
-  createRecurringSecretReminder,
-  deleteRecurringSecretReminder,
-  updateRecurringSecretReminder
-} from "../queues/reminders/sendSecretReminders";
-
-type TPartialSecret = Pick<
-  ISecret,
-  "_id" | "secretReminderRepeatDays" | "secretReminderNote" | "workspace"
->;
-type TPartialSecretDeleteReminder = Pick<ISecret, "_id" | "secretReminderRepeatDays">;
-
-export const createReminder = async (oldSecret: TPartialSecret, newSecret: TPartialSecret) => {
-  if (oldSecret._id !== newSecret._id) {
-    throw new Error("Secret id's don't match");
-  }
-
-  if (!newSecret.secretReminderRepeatDays) {
-    throw new Error("No repeat days provided");
-  }
-
-  const secretId = oldSecret._id.toString();
-  const workspaceId = oldSecret.workspace.toString();
-
-  if (oldSecret.secretReminderRepeatDays) {
-    // This will first delete the existing recurring job, and then create a new one.
-    await updateRecurringSecretReminder({
-      workspaceId,
-      secretId,
-      repeatDays: newSecret.secretReminderRepeatDays,
-      note: newSecret.secretReminderNote
-    });
-  } else {
-    // This will create a new recurring job.
-    await createRecurringSecretReminder({
-      workspaceId,
-      secretId,
-      repeatDays: newSecret.secretReminderRepeatDays,
-      note: newSecret.secretReminderNote
-    });
-  }
-};
-
-export const deleteReminder = async (secret: TPartialSecretDeleteReminder) => {
-  if (!secret._id) {
-    throw new Error("No secret id provided");
-  }
-
-  if (!secret.secretReminderRepeatDays) {
-    throw new Error("No repeat days provided");
-  }
-
-  await deleteRecurringSecretReminder({
-    secretId: secret._id.toString(),
-    repeatDays: secret.secretReminderRepeatDays
-  });
-};

backend/src/helpers/secret.ts

@@ -1,8 +1,12 @@
 import { Types } from "mongoose";
 import { ISecret, Secret } from "../models";
-import { EESecretService } from "../ee/services";
-import { SecretVersion } from "../ee/models";
+import { EELogService, EESecretService } from "../ee/services";
+import { IAction, SecretVersion } from "../ee/models";
 import {
+  ACTION_ADD_SECRETS,
+  ACTION_DELETE_SECRETS,
+  ACTION_READ_SECRETS,
+  ACTION_UPDATE_SECRETS,
   ALGORITHM_AES_256_GCM,
   ENCODING_SCHEME_UTF8,
   SECRET_PERSONAL,
@@ -316,6 +320,7 @@ export const v2PushSecrets = async ({
   ipAddress: string;
 }): Promise<void> => {
   // TODO: clean up function and fix up types
+  const actions: IAction[] = [];
 
   // construct useful data structures
   const oldSecrets = await getSecrets({
@@ -351,6 +356,15 @@ export const v2PushSecrets = async ({
     await EESecretService.markDeletedSecretVersions({
       secretIds: toDelete,
     });
+
+    const deleteAction = await EELogService.createAction({
+      name: ACTION_DELETE_SECRETS,
+      userId: new Types.ObjectId(userId),
+      workspaceId: new Types.ObjectId(userId),
+      secretIds: toDelete,
+    });
+
+    deleteAction && actions.push(deleteAction);
   }
 
   const toUpdate = oldSecrets.filter((s) => {
@@ -437,6 +451,15 @@ export const v2PushSecrets = async ({
         };
       }),
     });
+
+    const updateAction = await EELogService.createAction({
+      name: ACTION_UPDATE_SECRETS,
+      userId: new Types.ObjectId(userId),
+      workspaceId: new Types.ObjectId(workspaceId),
+      secretIds: toUpdate.map((u) => u._id),
+    });
+
+    updateAction && actions.push(updateAction);
   }
 
   // handle adding new secrets
@@ -471,6 +494,14 @@ export const v2PushSecrets = async ({
         });
       }),
     });
+
+    const addAction = await EELogService.createAction({
+      name: ACTION_ADD_SECRETS,
+      userId: new Types.ObjectId(userId),
+      workspaceId: new Types.ObjectId(workspaceId),
+      secretIds: newSecrets.map((n) => n._id),
+    });
+    addAction && actions.push(addAction);
   }
 
   // (EE) take a secret snapshot
@@ -478,6 +509,17 @@ export const v2PushSecrets = async ({
     workspaceId: new Types.ObjectId(workspaceId),
     environment,
   });
+
+  // (EE) create (audit) log
+  if (actions.length > 0) {
+    await EELogService.createLog({
+      userId: new Types.ObjectId(userId),
+      workspaceId: new Types.ObjectId(workspaceId),
+      actions,
+      channel,
+      ipAddress,
+    });
+  }
 };
 
 /**
@@ -547,6 +589,22 @@ export const pullSecrets = async ({
     environment,
   });
 
+  const readAction = await EELogService.createAction({
+    name: ACTION_READ_SECRETS,
+    userId: new Types.ObjectId(userId),
+    workspaceId: new Types.ObjectId(workspaceId),
+    secretIds: secrets.map((n: any) => n._id),
+  });
+
+  readAction &&
+    (await EELogService.createLog({
+      userId: new Types.ObjectId(userId),
+      workspaceId: new Types.ObjectId(workspaceId),
+      actions: [readAction],
+      channel,
+      ipAddress,
+    }));
+
   return secrets;
 };
 

backend/src/helpers/secrets.ts

@@ -13,11 +13,13 @@ import {
   Folder,
   ISecret,
   IServiceTokenData,
+  IServiceTokenDataV3,
   Secret,
   SecretBlindIndexData,
   ServiceTokenData,
   TFolderRootSchema
 } from "../models";
+import { Permission } from "../models/serviceTokenDataV3";
 import { EventType, SecretVersion } from "../ee/models";
 import {
   BadRequestError,
@@ -27,6 +29,10 @@ import {
   UnauthorizedRequestError
 } from "../utils/errors";
 import {
+  ACTION_ADD_SECRETS,
+  ACTION_DELETE_SECRETS,
+  ACTION_READ_SECRETS,
+  ACTION_UPDATE_SECRETS,
   ALGORITHM_AES_256_GCM,
   ENCODING_SCHEME_BASE64,
   ENCODING_SCHEME_UTF8,
@@ -42,13 +48,49 @@ import {
 } from "../utils/crypto";
 import { TelemetryService } from "../services";
 import { client, getEncryptionKey, getRootEncryptionKey } from "../config";
-import { EEAuditLogService, EESecretService } from "../ee/services";
-import { getAuthDataPayloadUserObj } from "../utils/authn/helpers";
+import { EEAuditLogService, EELogService, EESecretService } from "../ee/services";
+import { getAuthDataPayloadIdObj, getAuthDataPayloadUserObj } from "../utils/auth";
 import { getFolderByPath, getFolderIdFromServiceToken } from "../services/FolderService";
 import picomatch from "picomatch";
 import path from "path";
 import { getAnImportedSecret } from "../services/SecretImportService";
 
+/**
+ * Validate scope for service token v3
+ * @param authPayload
+ * @param environment
+ * @param secretPath
+ * @returns
+ */
+export const isValidScopeV3 = ({
+  authPayload,
+  environment,
+  secretPath,
+  requiredPermissions
+}: {
+  authPayload: IServiceTokenDataV3;
+  environment: string;
+  secretPath: string;
+  requiredPermissions: Permission[];
+}) => {
+  const { scopes } = authPayload;
+
+  const validScope = scopes.find(
+    (scope) =>
+      picomatch.isMatch(secretPath, scope.secretPath, { strictSlashes: false }) &&
+      scope.environment === environment
+  );
+
+  if (
+    validScope &&
+    !requiredPermissions.every((permission) => validScope.permissions.includes(permission))
+  ) {
+    return false;
+  }
+
+  return Boolean(validScope);
+};
+
 /**
  * Validate scope for service token v2
  * @param authPayload
@@ -436,6 +478,23 @@ export const createSecretHelper = async ({
     secretVersions: [secretVersion]
   });
 
+  // (EE) create (audit) log
+  const action = await EELogService.createAction({
+    name: ACTION_ADD_SECRETS,
+    ...getAuthDataPayloadIdObj(authData),
+    workspaceId,
+    secretIds: [secret._id]
+  });
+
+  action &&
+    (await EELogService.createLog({
+      ...getAuthDataPayloadIdObj(authData),
+      workspaceId,
+      actions: [action],
+      channel: authData.userAgentType,
+      ipAddress: authData.ipAddress
+    }));
+
   await EEAuditLogService.createAuditLog(
     authData,
     {
@@ -494,22 +553,14 @@ export const getSecretsHelper = async ({
   workspaceId,
   environment,
   authData,
+  folderId,
   secretPath = "/"
 }: GetSecretsParams) => {
   let secrets: ISecret[] = [];
   // if using service token filter towards the folderId by secretpath
 
-  const folders = await Folder.findOne({
-    workspace: workspaceId,
-    environment
-  });
-  let folderId = "root";
-  if (!folders && folderId !== "root") return [];
-  // get folder from folder tree
-  if (folders) {
-    const folder = getFolderByPath(folders.nodes, secretPath);
-    if (!folder) return [];
-    folderId = folder?.id;
+  if (!folderId) {
+    folderId = await getFolderIdFromServiceToken(workspaceId, environment, secretPath);
   }
 
   // get personal secrets first
@@ -538,6 +589,23 @@ export const getSecretsHelper = async ({
       .lean()
   );
 
+  // (EE) create (audit) log
+  const action = await EELogService.createAction({
+    name: ACTION_READ_SECRETS,
+    ...getAuthDataPayloadIdObj(authData),
+    workspaceId,
+    secretIds: secrets.map((secret) => secret._id)
+  });
+
+  action &&
+    (await EELogService.createLog({
+      ...getAuthDataPayloadIdObj(authData),
+      workspaceId,
+      actions: [action],
+      channel: authData.userAgentType,
+      ipAddress: authData.ipAddress
+    }));
+
   await EEAuditLogService.createAuditLog(
     authData,
     {
@@ -574,20 +642,18 @@ export const getSecretsHelper = async ({
     const approximateForNoneCapturedEvents = secrets.length * 10;
 
     if (shouldCapture) {
-      if (workspaceId.toString() != "650e71fbae3e6c8572f436d4") {
-        postHogClient.capture({
-          event: "secrets pulled",
-          distinctId: await TelemetryService.getDistinctId({ authData }),
-          properties: {
-            numberOfSecrets: shouldRecordK8Event ? approximateForNoneCapturedEvents : secrets.length,
-            environment,
-            workspaceId,
-            folderId,
-            channel: authData.userAgentType,
-            userAgent: authData.userAgent
-          }
-        });
-      }
+      postHogClient.capture({
+        event: "secrets pulled",
+        distinctId: await TelemetryService.getDistinctId({ authData }),
+        properties: {
+          numberOfSecrets: shouldRecordK8Event ? approximateForNoneCapturedEvents : secrets.length,
+          environment,
+          workspaceId,
+          folderId,
+          channel: authData.userAgentType,
+          userAgent: authData.userAgent
+        }
+      });
     }
   }
 
@@ -611,85 +677,63 @@ export const getSecretHelper = async ({
   type,
   authData,
   secretPath = "/",
-  include_imports = true,
-  version
+  include_imports = true
 }: GetSecretParams) => {
-  
   const secretBlindIndex = await generateSecretBlindIndexHelper({
     secretName,
     workspaceId: new Types.ObjectId(workspaceId)
   });
   let secret: ISecret | null | undefined = null;
-
   // if using service token filter towards the folderId by secretpath
 
   const folderId = await getFolderIdFromServiceToken(workspaceId, environment, secretPath);
 
   // try getting personal secret first (if exists)
-  if (version === undefined) {
+  secret = await Secret.findOne({
+    secretBlindIndex,
+    workspace: new Types.ObjectId(workspaceId),
+    environment,
+    folder: folderId,
+    type: type ?? SECRET_PERSONAL,
+    ...(type === SECRET_PERSONAL ? getAuthDataPayloadUserObj(authData) : {})
+  }).lean();
+
+  if (!secret) {
+    // case: failed to find personal secret matching criteria
+    // -> find shared secret matching criteria
     secret = await Secret.findOne({
       secretBlindIndex,
       workspace: new Types.ObjectId(workspaceId),
       environment,
       folder: folderId,
-      type: type ?? SECRET_PERSONAL,
-      ...(type === SECRET_PERSONAL ? getAuthDataPayloadUserObj(authData) : {})
+      type: SECRET_SHARED
     }).lean();
-  } else {
-    const secretVersion = await SecretVersion.findOne({
-      secretBlindIndex,
-      workspace: new Types.ObjectId(workspaceId),
-      environment,
-      folder: folderId,
-      type: type ?? SECRET_PERSONAL,
-      version
-    }).lean();
-  
-    if (secretVersion) {
-      secret = await new Secret({
-        ...secretVersion,
-        _id: secretVersion?.secret
-      });
-    }
   }
 
-  if (!secret) {
-    // case: failed to find personal secret matching criteria
-    // -> find shared secret matching criteria
-    if (version === undefined) {
-      secret = await Secret.findOne({
-        secretBlindIndex,
-        workspace: new Types.ObjectId(workspaceId),
-        environment,
-        folder: folderId,
-        type: SECRET_SHARED
-      }).lean();
-    } else {
-      const secretVersion = await SecretVersion.findOne({
-        secretBlindIndex,
-        workspace: new Types.ObjectId(workspaceId),
-        environment,
-        folder: folderId,
-        type: SECRET_SHARED,
-        version
-      }).lean();
-      
-      if (secretVersion) {
-        secret = await new Secret({
-          ...secretVersion,
-          _id: secretVersion?.secret
-        });
-      }
-    }
-  }
-  
   if (!secret && include_imports) {
     // if still no secret found search in imported secret and retreive
-    secret = await getAnImportedSecret(secretName, workspaceId.toString(), environment, folderId, version);
+    secret = await getAnImportedSecret(secretName, workspaceId.toString(), environment, folderId);
   }
 
   if (!secret) throw SecretNotFoundError();
 
+  // (EE) create (audit) log
+  const action = await EELogService.createAction({
+    name: ACTION_READ_SECRETS,
+    ...getAuthDataPayloadIdObj(authData),
+    workspaceId,
+    secretIds: [secret._id]
+  });
+
+  action &&
+    (await EELogService.createLog({
+      ...getAuthDataPayloadIdObj(authData),
+      workspaceId,
+      actions: [action],
+      channel: authData.userAgentType,
+      ipAddress: authData.ipAddress
+    }));
+
   await EEAuditLogService.createAuditLog(
     authData,
     {
@@ -758,8 +802,6 @@ export const updateSecretHelper = async ({
   secretValueIV,
   secretValueTag,
   secretPath,
-  secretReminderRepeatDays,
-  secretReminderNote,
   tags,
   secretCommentCiphertext,
   secretCommentIV,
@@ -824,10 +866,6 @@ export const updateSecretHelper = async ({
         secretCommentIV,
         secretCommentTag,
         secretCommentCiphertext,
-
-        secretReminderRepeatDays,
-        secretReminderNote,
-
         skipMultilineEncoding,
         secretBlindIndex: newSecretNameBlindIndex,
         secretKeyIV,
@@ -899,6 +937,23 @@ export const updateSecretHelper = async ({
     secretVersions: [secretVersion]
   });
 
+  // (EE) create (audit) log
+  const action = await EELogService.createAction({
+    name: ACTION_UPDATE_SECRETS,
+    ...getAuthDataPayloadIdObj(authData),
+    workspaceId,
+    secretIds: [secret._id]
+  });
+
+  action &&
+    (await EELogService.createLog({
+      ...getAuthDataPayloadIdObj(authData),
+      workspaceId,
+      actions: [action],
+      channel: authData.userAgentType,
+      ipAddress: authData.ipAddress
+    }));
+
   await EEAuditLogService.createAuditLog(
     authData,
     {
@@ -1026,6 +1081,23 @@ export const deleteSecretHelper = async ({
     secretIds: secrets.map((secret) => secret._id)
   });
 
+  // (EE) create (audit) log
+  const action = await EELogService.createAction({
+    name: ACTION_DELETE_SECRETS,
+    ...getAuthDataPayloadIdObj(authData),
+    workspaceId,
+    secretIds: secrets.map((secret) => secret._id)
+  });
+
+  action &&
+    (await EELogService.createLog({
+      ...getAuthDataPayloadIdObj(authData),
+      workspaceId,
+      actions: [action],
+      channel: authData.userAgentType,
+      ipAddress: authData.ipAddress
+    }));
+
   await EEAuditLogService.createAuditLog(
     authData,
     {
@@ -1689,6 +1761,22 @@ export const deleteSecretBatchHelper = async ({
     secretIds: deletedSecrets.map((secret) => secret._id)
   });
 
+  const action = await EELogService.createAction({
+    name: ACTION_DELETE_SECRETS,
+    ...getAuthDataPayloadIdObj(authData),
+    workspaceId,
+    secretIds: deletedSecrets.map((secret) => secret._id)
+  });
+
+  action &&
+    (await EELogService.createLog({
+      ...getAuthDataPayloadIdObj(authData),
+      workspaceId,
+      actions: [action],
+      channel: authData.userAgentType,
+      ipAddress: authData.ipAddress
+    }));
+
   await EEAuditLogService.createAuditLog(
     authData,
     {