add create service token to cli + docs for it

Stable multiline input

.env.example

@@ -9,6 +9,7 @@ JWT_SIGNUP_SECRET=3679e04ca949f914c03332aaaeba805a
 JWT_REFRESH_SECRET=5f2f3c8f0159068dc2bbb3a652a716ff
 JWT_AUTH_SECRET=4be6ba5602e0fa0ac6ac05c3cd4d247f
 JWT_SERVICE_SECRET=f32f716d70a42c5703f4656015e76200
+JWT_PROVIDER_AUTH_SECRET=f32f716d70a42c5703f4656015e76201
 
 # JWT lifetime
 # Optional lifetimes for JWT tokens expressed in seconds or a string 
@@ -16,6 +17,7 @@ JWT_SERVICE_SECRET=f32f716d70a42c5703f4656015e76200
 JWT_AUTH_LIFETIME=
 JWT_REFRESH_LIFETIME=
 JWT_SIGNUP_LIFETIME=
+JWT_PROVIDER_AUTH_LIFETIME=
 
 # MongoDB
 # Backend will connect to the MongoDB instance at connection string MONGO_URL which can either be a ref
@@ -23,6 +25,9 @@ JWT_SIGNUP_LIFETIME=
 # Required
 MONGO_URL=mongodb://root:example@mongo:27017/?authSource=admin
 
+# Redis
+REDIS_URL=redis://redis:6379
+
 # Optional credentials for MongoDB container instance and Mongo-Express
 MONGO_USERNAME=root
 MONGO_PASSWORD=example
@@ -45,11 +50,13 @@ CLIENT_ID_VERCEL=
 CLIENT_ID_NETLIFY=
 CLIENT_ID_GITHUB=
 CLIENT_ID_GITLAB=
+CLIENT_ID_BITBUCKET=
 CLIENT_SECRET_HEROKU=
 CLIENT_SECRET_VERCEL=
 CLIENT_SECRET_NETLIFY=
 CLIENT_SECRET_GITHUB=
 CLIENT_SECRET_GITLAB=
+CLIENT_SECRET_BITBUCKET=
 CLIENT_SLUG_VERCEL=
 
 # Sentry (optional) for monitoring errors
@@ -59,10 +66,6 @@ SENTRY_DSN=
 # Ignore - Not applicable for self-hosted version
 POSTHOG_HOST=
 POSTHOG_PROJECT_API_KEY=
-STRIPE_SECRET_KEY=
+
-STRIPE_PUBLISHABLE_KEY=
+CLIENT_ID_GOOGLE=
-STRIPE_WEBHOOK_SECRET=
+CLIENT_SECRET_GOOGLE=
-STRIPE_PRODUCT_STARTER=
-STRIPE_PRODUCT_TEAM=
-STRIPE_PRODUCT_PRO=
-NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=

.github/ISSUE_TEMPLATE/feature_request.md

@@ -8,7 +8,7 @@ assignees: ''
 ---
 
 ### Feature description
-A clear and concise description of what the the feature should be.
+A clear and concise description of what the feature should be.
 
 ### Why would it be useful?
 Why would this feature be useful for Infisical users? 

.github/resources/docker-compose.be-test.yml

@@ -13,6 +13,7 @@ services:
       - MONGO_URL=mongodb://test:example@mongo:27017/?authSource=admin
       - MONGO_USERNAME=test
       - MONGO_PASSWORD=example
+      - ENCRYPTION_KEY=a984ecdf82ec779e55dbcc21303a900f
     networks:
       - infisical-test
 

.github/values.yaml

@@ -1,3 +1,10 @@
+# secretScanningGitApp:
+#   enabled: false
+#   deploymentAnnotations:
+#     secrets.infisical.com/auto-reload: "true"
+#   image:
+#     repository: infisical/staging_deployment_secret-scanning-git-app
+    
 frontend:
   enabled: true
   name: frontend
@@ -6,7 +13,7 @@ frontend:
     secrets.infisical.com/auto-reload: "true"
   replicaCount: 2
   image:
-    repository: infisical/frontend
+    repository: infisical/staging_deployment_frontend
     tag: "latest"
     pullPolicy: Always
   kubeSecretRef: managed-secret-frontend
@@ -25,7 +32,7 @@ backend:
     secrets.infisical.com/auto-reload: "true"
   replicaCount: 2
   image:
-    repository: infisical/backend
+    repository: infisical/staging_deployment_backend
     tag: "latest"
     pullPolicy: Always
   kubeSecretRef: managed-backend-secret
@@ -51,8 +58,8 @@ mongodbConnection:
 
 ingress:
   enabled: true
-  annotations:
+  # annotations:
-    kubernetes.io/ingress.class: "nginx"
+  #   kubernetes.io/ingress.class: "nginx"
     # cert-manager.io/issuer: letsencrypt-nginx
   hostName: gamma.infisical.com ## <- Replace with your own domain
   frontend:

.github/workflows/build-docker-image-to-prod.yml

@@ -0,0 +1,118 @@
+name: Release production images (frontend, backend)
+on:
+  push:
+    tags:
+      - "infisical/v*.*.*"
+
+jobs:
+  backend-image:
+    name: Build backend image
+    runs-on: ubuntu-latest
+    steps:
+      - name: Extract version from tag
+        id: extract_version
+        run: echo "::set-output name=version::${GITHUB_REF_NAME#infisical/}"
+      - name: ☁️ Checkout source
+        uses: actions/checkout@v3
+      - name: 📦 Install dependencies to test all dependencies
+        run: npm ci --only-production
+        working-directory: backend
+      # - name: 🧪 Run tests
+      #   run: npm run test:ci
+      #   working-directory: backend
+      - name: Save commit hashes for tag
+        id: commit
+        uses: pr-mpt/actions-commit-hash@v2
+      - name: 🔧 Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: 🐋 Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Set up Depot CLI
+        uses: depot/setup-action@v1
+      - name: 📦 Build backend and export to Docker
+        uses: depot/build-push-action@v1
+        with:
+          project: 64mmf0n610
+          token: ${{ secrets.DEPOT_PROJECT_TOKEN }}
+          load: true
+          context: backend
+          tags: infisical/backend:test
+      - name: ⏻ Spawn backend container and dependencies
+        run: |
+          docker compose -f .github/resources/docker-compose.be-test.yml up --wait --quiet-pull
+      - name: 🧪 Test backend image
+        run: |
+          ./.github/resources/healthcheck.sh infisical-backend-test
+      - name: ⏻ Shut down backend container and dependencies
+        run: |
+          docker compose -f .github/resources/docker-compose.be-test.yml down
+      - name: 🏗️ Build backend and push
+        uses: depot/build-push-action@v1
+        with:
+          project: 64mmf0n610
+          token: ${{ secrets.DEPOT_PROJECT_TOKEN }}
+          push: true
+          context: backend
+          tags: |
+            infisical/backend:${{ steps.commit.outputs.short }}
+            infisical/backend:latest
+            infisical/backend:${{ steps.extract_version.outputs.version }}
+          platforms: linux/amd64,linux/arm64
+
+  frontend-image:
+    name: Build frontend image
+    runs-on: ubuntu-latest
+    steps:
+      - name: Extract version from tag
+        id: extract_version
+        run: echo "::set-output name=version::${GITHUB_REF_NAME#infisical/}"
+      - name: ☁️ Checkout source
+        uses: actions/checkout@v3
+      - name: Save commit hashes for tag
+        id: commit
+        uses: pr-mpt/actions-commit-hash@v2
+      - name: 🔧 Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: 🐋 Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Set up Depot CLI
+        uses: depot/setup-action@v1
+      - name: 📦 Build frontend and export to Docker
+        uses: depot/build-push-action@v1
+        with:
+          load: true
+          token: ${{ secrets.DEPOT_PROJECT_TOKEN }}
+          project: 64mmf0n610
+          context: frontend
+          tags: infisical/frontend:test
+          build-args: |
+            POSTHOG_API_KEY=${{ secrets.PUBLIC_POSTHOG_API_KEY }}
+      - name: ⏻ Spawn frontend container
+        run: |
+          docker run -d --rm --name infisical-frontend-test infisical/frontend:test
+      - name: 🧪 Test frontend image
+        run: |
+          ./.github/resources/healthcheck.sh infisical-frontend-test
+      - name: ⏻ Shut down frontend container
+        run: |
+          docker stop infisical-frontend-test
+      - name: 🏗️ Build frontend and push
+        uses: depot/build-push-action@v1
+        with:
+          project: 64mmf0n610
+          push: true
+          token: ${{ secrets.DEPOT_PROJECT_TOKEN }}
+          context: frontend
+          tags: |
+            infisical/frontend:${{ steps.commit.outputs.short }}
+            infisical/frontend:latest
+            infisical/frontend:${{ steps.extract_version.outputs.version }}
+          platforms: linux/amd64,linux/arm64
+          build-args: |
+            POSTHOG_API_KEY=${{ secrets.PUBLIC_POSTHOG_API_KEY }}

.github/workflows/build-staging-img.yml

@@ -1,25 +1,19 @@
 name: Build, Publish and Deploy to Gamma
-on:
+on: [workflow_dispatch]
-  push:
-    tags:
-      - "infisical/v*.*.*"
 
 jobs:
   backend-image:
     name: Build backend image
     runs-on: ubuntu-latest
     steps:
-      - name: Extract version from tag
-        id: extract_version
-        run: echo "::set-output name=version::${GITHUB_REF_NAME#infisical/}"
       - name: ☁️ Checkout source
         uses: actions/checkout@v3
       - name: 📦 Install dependencies to test all dependencies
         run: npm ci --only-production
         working-directory: backend
-      - name: 🧪 Run tests
+      # - name: 🧪 Run tests
-        run: npm run test:ci
+      #   run: npm run test:ci
-        working-directory: backend
+      #   working-directory: backend
       - name: Save commit hashes for tag
         id: commit
         uses: pr-mpt/actions-commit-hash@v2
@@ -57,18 +51,14 @@ jobs:
           push: true
           context: backend
           tags: |
-            infisical/backend:${{ steps.commit.outputs.short }}
+            infisical/staging_deployment_backend:${{ steps.commit.outputs.short }}
-            infisical/backend:latest
+            infisical/staging_deployment_backend:latest
-            infisical/backend:${{ steps.extract_version.outputs.version }}
           platforms: linux/amd64,linux/arm64
 
   frontend-image:
     name: Build frontend image
     runs-on: ubuntu-latest
     steps:
-      - name: Extract version from tag
-        id: extract_version
-        run: echo "::set-output name=version::${GITHUB_REF_NAME#infisical/}"
       - name: ☁️ Checkout source
         uses: actions/checkout@v3
       - name: Save commit hashes for tag
@@ -90,12 +80,12 @@ jobs:
           token: ${{ secrets.DEPOT_PROJECT_TOKEN }}
           project: 64mmf0n610
           context: frontend
-          tags: infisical/frontend:test
+          tags: infisical/staging_deployment_frontend:test
           build-args: |
             POSTHOG_API_KEY=${{ secrets.PUBLIC_POSTHOG_API_KEY }}
       - name: ⏻ Spawn frontend container
         run: |
-          docker run -d --rm --name infisical-frontend-test infisical/frontend:test
+          docker run -d --rm --name infisical-frontend-test infisical/staging_deployment_frontend:test
       - name: 🧪 Test frontend image
         run: |
           ./.github/resources/healthcheck.sh infisical-frontend-test
@@ -110,9 +100,8 @@ jobs:
           token: ${{ secrets.DEPOT_PROJECT_TOKEN }}
           context: frontend
           tags: |
-            infisical/frontend:${{ steps.commit.outputs.short }}
+            infisical/staging_deployment_frontend:${{ steps.commit.outputs.short }}
-            infisical/frontend:latest
+            infisical/staging_deployment_frontend:latest
-            infisical/frontend:${{ steps.extract_version.outputs.version }}
           platforms: linux/amd64,linux/arm64
           build-args: |
             POSTHOG_API_KEY=${{ secrets.PUBLIC_POSTHOG_API_KEY }}
@@ -146,7 +135,7 @@ jobs:
       - name: Download helm values to file and upgrade gamma deploy
         run: |
           wget https://raw.githubusercontent.com/Infisical/infisical/main/.github/values.yaml
-          helm upgrade infisical infisical-helm-charts/infisical  --values values.yaml --recreate-pods
+          helm upgrade infisical infisical-helm-charts/infisical  --values values.yaml --wait --install
           if [[ $(helm status infisical) == *"FAILED"* ]]; then
             echo "Helm upgrade failed"
             exit 1

.github/workflows/release-standalone-docker-img.yml

@@ -1,11 +1,17 @@
 name: Release standalone docker image
-on: [workflow_dispatch]
+on:
+  push:
+    tags:
+      - "infisical/v*.*.*"
 
 jobs:
   infisical-standalone:
     name: Build infisical standalone image
     runs-on: ubuntu-latest
     steps:
+      - name: Extract version from tag
+        id: extract_version
+        run: echo "::set-output name=version::${GITHUB_REF_NAME#infisical/}"
       - name: ☁️ Checkout source
         uses: actions/checkout@v3
         with:
@@ -64,5 +70,6 @@ jobs:
           tags: |
             infisical/infisical:latest
             infisical/infisical:${{ steps.commit.outputs.short }}
+            infisical/infisical:${{ steps.extract_version.outputs.version }}
           platforms: linux/amd64,linux/arm64
           file: Dockerfile.standalone-infisical

.github/workflows/release_docker_k8_operator.yaml

@@ -1,10 +1,16 @@
-name: Release Docker image for K8 operator 
+name: Release Docker image for K8 operator
-on: [workflow_dispatch]
+on:
+  push:
+    tags:
+      - "infisical-k8-operator/v*.*.*"
 
 jobs:
   release:
     runs-on: ubuntu-latest
     steps:
+      - name: Extract version from tag
+        id: extract_version
+        run: echo "::set-output name=version::${GITHUB_REF_NAME#infisical-k8-operator/}"
       - uses: actions/checkout@v2
 
       - name: 🔧 Set up QEMU
@@ -26,4 +32,6 @@ jobs:
           context: k8-operator
           push: true
           platforms: linux/amd64,linux/arm64
-          tags: infisical/kubernetes-operator:latest
+          tags: |
+            infisical/kubernetes-operator:latest
+            infisical/kubernetes-operator:${{ steps.extract_version.outputs.version }}

.gitignore

@@ -2,6 +2,7 @@
 node_modules
 .env
 .env.dev
+.env.gamma
 .env.prod
 .env.infisical
 
@@ -56,3 +57,6 @@ yarn-error.log*
 
 # Infisical init
 .infisical.json
+
+# Editor specific
+.vscode/*

.goreleaser.yaml

@@ -108,6 +108,22 @@ brews:
       zsh_completion.install "completions/infisical.zsh" => "_infisical"
       fish_completion.install "completions/infisical.fish"
       man1.install "manpages/infisical.1.gz"
+  - name: 'infisical@{{.Version}}'
+    tap:
+      owner: Infisical
+      name: homebrew-get-cli
+    commit_author:
+      name: "Infisical"
+      email: ai@infisical.com
+    folder: Formula
+    homepage: "https://infisical.com"
+    description: "The official Infisical CLI"
+    install: |-
+      bin.install "infisical"
+      bash_completion.install "completions/infisical.bash" => "infisical"
+      zsh_completion.install "completions/infisical.zsh" => "_infisical"
+      fish_completion.install "completions/infisical.fish"
+      man1.install "manpages/infisical.1.gz"
 
 nfpms:
   - id: infisical

.husky/pre-commit

@@ -1,4 +1,3 @@
-
 #!/usr/bin/env sh
 . "$(dirname -- "$0")/_/husky.sh"
 

.infisicalignore

@@ -0,0 +1 @@
+.github/resources/docker-compose.be-test.yml:generic-api-key:16

.pre-commit-config.yaml

@@ -1,5 +0,0 @@
-repos:
-  - repo: https://github.com/gitleaks/gitleaks
-    rev: v8.16.3
-    hooks:
-      - id: gitleaks

.pre-commit-hooks.yaml

@@ -1,6 +0,0 @@
-- id: infisical-scan
-  name: Scan for hardcoded secrets
-  description: Will scan for hardcoded secrets using Infisical CLI
-  entry: infisical scan git-changes --verbose --redact --staged
-  language: golang
-  pass_filenames: false

Dockerfile.standalone-infisical

@@ -25,6 +25,8 @@ ARG POSTHOG_HOST
 ENV NEXT_PUBLIC_POSTHOG_HOST $POSTHOG_HOST
 ARG POSTHOG_API_KEY
 ENV NEXT_PUBLIC_POSTHOG_API_KEY $POSTHOG_API_KEY
+ARG INTERCOM_ID
+ENV NEXT_PUBLIC_INTERCOM_ID $INTERCOM_ID
 
 # Build
 RUN npm run build
@@ -42,6 +44,9 @@ VOLUME /app/.next/cache/images
 ARG POSTHOG_API_KEY
 ENV NEXT_PUBLIC_POSTHOG_API_KEY=$POSTHOG_API_KEY \
   BAKED_NEXT_PUBLIC_POSTHOG_API_KEY=$POSTHOG_API_KEY
+ARG INTERCOM_ID
+ENV NEXT_PUBLIC_INTERCOM_ID=$INTERCOM_ID \
+  BAKED_NEXT_PUBLIC_INTERCOM_ID=$INTERCOM_ID
 
 COPY --chown=nextjs:nodejs --chmod=555 frontend/scripts ./scripts
 COPY --from=frontend-builder /app/public ./public

backend/.eslintrc

@@ -1,12 +1,40 @@
 {
   "parser": "@typescript-eslint/parser",
-  "plugins": ["@typescript-eslint"],
+  "plugins": [
+    "@typescript-eslint",
+    "unused-imports"
+  ],
   "extends": [
     "eslint:recommended",
     "plugin:@typescript-eslint/eslint-recommended",
     "plugin:@typescript-eslint/recommended"
   ],
   "rules": {
-    "no-console": 2
+    "no-empty-function": "off",
+    "@typescript-eslint/no-empty-function": "off",
+    "no-console": 2,
+    "quotes": [
+      "error",
+      "double",
+      {
+        "avoidEscape": true
+      }
+    ],
+    "comma-dangle": [
+      "error",
+      "only-multiline"
+    ],
+    "@typescript-eslint/no-unused-vars": "off",
+    "unused-imports/no-unused-imports": "error",
+    "unused-imports/no-unused-vars": [
+      "warn",
+      {
+        "vars": "all",
+        "varsIgnorePattern": "^_",
+        "args": "after-used",
+        "argsIgnorePattern": "^_"
+      }
+    ],
+    "sort-imports": 1
   }
-}
+}

backend/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "singleQuote": false,
+  "printWidth": 100,
+  "trailingComma": "none",
+  "tabWidth": 2,
+  "semi": true
+}

backend/Dockerfile

@@ -14,14 +14,20 @@ FROM node:16-alpine
 
 WORKDIR /app
 
+ENV npm_config_cache /home/node/.npm
+
 COPY package*.json ./
-RUN npm ci --only-production
+RUN npm ci --only-production && npm cache clean --force
 
 COPY --from=build /app .
 
+RUN apk add --no-cache bash curl && curl -1sLf \
+  'https://dl.cloudsmith.io/public/infisical/infisical-cli/setup.alpine.sh' | bash \
+  && apk add infisical=0.8.1 && apk add --no-cache git
+
 HEALTHCHECK --interval=10s --timeout=3s --start-period=10s \  
   CMD node healthcheck.js
 
 EXPOSE 4000
 
-CMD ["npm", "run", "start"]
+CMD ["node", "build/index.js"]

backend/environment.d.ts

@@ -14,7 +14,7 @@ declare global {
 			JWT_SIGNUP_LIFETIME: string;
 			JWT_SIGNUP_SECRET: string;
       MONGO_URL: string;
-      NODE_ENV: 'development' | 'staging' | 'testing' | 'production';
+      NODE_ENV: "development" | "staging" | "testing" | "production";
       VERBOSE_ERROR_OUTPUT: string;
       LOKI_HOST: string;
       CLIENT_ID_HEROKU: string;
@@ -39,12 +39,6 @@ declare global {
       SMTP_PASSWORD: string;
       SMTP_FROM_ADDRESS: string;
       SMTP_FROM_NAME: string;
-      STRIPE_PRODUCT_STARTER: string;
-      STRIPE_PRODUCT_TEAM: string;
-      STRIPE_PRODUCT_PRO: string;
-      STRIPE_PUBLISHABLE_KEY: string;
-      STRIPE_SECRET_KEY: string;
-      STRIPE_WEBHOOK_SECRET: string;
       TELEMETRY_ENABLED: string;
       LICENSE_KEY: string;
     }

backend/jest.config.ts

@@ -1,9 +1,9 @@
 export default {
-  preset: 'ts-jest',
+  preset: "ts-jest",
-  testEnvironment: 'node',
+  testEnvironment: "node",
-  collectCoverageFrom: ['src/*.{js,ts}', '!**/node_modules/**'],
+  collectCoverageFrom: ["src/*.{js,ts}", "!**/node_modules/**"],
-  modulePaths: ['<rootDir>/src'],
+  modulePaths: ["<rootDir>/src"],
-  testMatch: ['<rootDir>/tests/**/*.test.ts'],
+  testMatch: ["<rootDir>/tests/**/*.test.ts"],
-  setupFiles: ['<rootDir>/test-resources/env-vars.js'],
+  setupFiles: ["<rootDir>/test-resources/env-vars.js"],
-  setupFilesAfterEnv: ['<rootDir>/tests/setupTests.ts']
+  setupFilesAfterEnv: ["<rootDir>/tests/setupTests.ts"],
 };

backend/package.json

@@ -1,51 +1,60 @@
 {
   "dependencies": {
     "@aws-sdk/client-secrets-manager": "^3.319.0",
+    "@casl/ability": "^6.5.0",
+    "@casl/mongoose": "^7.2.1",
     "@godaddy/terminus": "^4.12.0",
+    "@node-saml/passport-saml": "^4.0.4",
     "@octokit/rest": "^19.0.5",
     "@sentry/node": "^7.49.0",
     "@sentry/tracing": "^7.48.0",
     "@types/crypto-js": "^4.1.1",
     "@types/libsodium-wrappers": "^0.7.10",
+    "@ucast/mongo2js": "^1.3.4",
     "argon2": "^0.30.3",
-    "await-to-js": "^3.0.0",
     "aws-sdk": "^2.1364.0",
     "axios": "^1.3.5",
     "axios-retry": "^3.4.0",
     "bcrypt": "^5.1.0",
     "bigint-conversion": "^2.4.0",
-    "builder-pattern": "^2.2.0",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",
     "crypto-js": "^4.1.1",
     "dotenv": "^16.0.1",
     "express": "^4.18.1",
+    "express-async-errors": "^3.1.1",
     "express-rate-limit": "^6.7.0",
     "express-validator": "^6.14.2",
     "handlebars": "^4.7.7",
     "helmet": "^5.1.1",
     "infisical-node": "^1.2.1",
+    "ioredis": "^5.3.2",
     "js-yaml": "^4.1.0",
     "jsonwebtoken": "^9.0.0",
     "jsrp": "^0.2.4",
     "libsodium-wrappers": "^0.7.10",
     "lodash": "^4.17.21",
-    "mongoose": "^6.10.5",
+    "mongodb": "^5.7.0",
+    "mongoose": "^7.4.1",
+    "nanoid": "^3.3.6",
     "node-cache": "^5.1.2",
     "nodemailer": "^6.8.0",
+    "passport": "^0.6.0",
+    "passport-github": "^1.1.0",
+    "passport-google-oauth20": "^2.0.0",
     "posthog-node": "^2.6.0",
+    "probot": "^12.3.1",
     "query-string": "^7.1.3",
-    "request-ip": "^3.3.0",
+    "rate-limit-mongo": "^2.3.2",
     "rimraf": "^3.0.2",
-    "stripe": "^10.7.0",
-    "swagger-autogen": "^2.22.0",
     "swagger-ui-express": "^4.6.2",
     "tweetnacl": "^1.0.3",
     "tweetnacl-util": "^0.15.1",
     "typescript": "^4.9.3",
     "utility-types": "^3.10.0",
     "winston": "^3.8.2",
-    "winston-loki": "^6.0.6"
+    "winston-loki": "^6.0.6",
+    "zod": "^3.21.4"
   },
   "name": "infisical-api",
   "version": "1.0.0",
@@ -54,7 +63,7 @@
     "start": "node build/index.js",
     "dev": "nodemon",
     "swagger-autogen": "node ./swagger/index.ts",
-    "build": "rimraf ./build && tsc && cp -R ./src/templates ./build",
+    "build": "rimraf ./build && tsc && cp -R ./src/templates ./build && cp -R ./src/data ./build",
     "lint": "eslint . --ext .ts",
     "lint-and-fix": "eslint . --ext .ts --fix",
     "lint-staged": "lint-staged",
@@ -79,6 +88,7 @@
     "@posthog/plugin-scaffold": "^1.3.4",
     "@types/bcrypt": "^5.0.0",
     "@types/bcryptjs": "^2.4.2",
+    "@types/bull": "^4.10.0",
     "@types/cookie-parser": "^1.4.3",
     "@types/cors": "^2.8.12",
     "@types/express": "^4.17.14",
@@ -87,6 +97,8 @@
     "@types/lodash": "^4.14.191",
     "@types/node": "^18.11.3",
     "@types/nodemailer": "^6.4.6",
+    "@types/passport": "^1.0.12",
+    "@types/picomatch": "^2.3.0",
     "@types/supertest": "^2.0.12",
     "@types/swagger-jsdoc": "^6.0.1",
     "@types/swagger-ui-express": "^4.1.3",
@@ -94,12 +106,15 @@
     "@typescript-eslint/parser": "^5.40.1",
     "cross-env": "^7.0.3",
     "eslint": "^8.26.0",
+    "eslint-plugin-unused-imports": "^2.0.0",
     "install": "^0.13.0",
     "jest": "^29.3.1",
     "jest-junit": "^15.0.0",
     "nodemon": "^2.0.19",
     "npm": "^8.19.3",
+    "smee-client": "^1.2.3",
     "supertest": "^6.3.3",
+    "swagger-autogen": "^2.23.5",
     "ts-jest": "^29.0.3",
     "ts-node": "^10.9.1"
   },

backend/src/config/index.ts

@@ -1,89 +1,100 @@
-import InfisicalClient from 'infisical-node';
+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 getPort = async () => (await client.getSecret("PORT")).secretValue || 4000;
 export const getEncryptionKey = async () => {
-  const secretValue = (await client.getSecret('ENCRYPTION_KEY')).secretValue;
+  const secretValue = (await client.getSecret("ENCRYPTION_KEY")).secretValue;
-  return secretValue === '' ? undefined : secretValue;
+  return secretValue === "" ? undefined : secretValue;
 }
 export const getRootEncryptionKey = async () => {
-  const secretValue = (await client.getSecret('ROOT_ENCRYPTION_KEY')).secretValue; 
+  const secretValue = (await client.getSecret("ROOT_ENCRYPTION_KEY")).secretValue;
-  return secretValue === '' ? undefined : secretValue;
+  return secretValue === "" ? undefined : secretValue;
 }
-export const getInviteOnlySignup = async () => (await client.getSecret('INVITE_ONLY_SIGNUP')).secretValue === 'true'
+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 getSaltRounds = async () => parseInt((await client.getSecret("SALT_ROUNDS")).secretValue) || 10;
-export const getJwtAuthLifetime = async () => (await client.getSecret('JWT_AUTH_LIFETIME')).secretValue || '10d';
+export const getJwtAuthLifetime = async () => (await client.getSecret("JWT_AUTH_LIFETIME")).secretValue || "10d";
-export const getJwtAuthSecret = async () => (await client.getSecret('JWT_AUTH_SECRET')).secretValue;
+export const getJwtAuthSecret = async () => (await client.getSecret("JWT_AUTH_SECRET")).secretValue;
-export const getJwtMfaLifetime = async () => (await client.getSecret('JWT_MFA_LIFETIME')).secretValue || '5m';
+export const getJwtMfaLifetime = async () => (await client.getSecret("JWT_MFA_LIFETIME")).secretValue || "5m";
-export const getJwtMfaSecret = async () => (await client.getSecret('JWT_MFA_LIFETIME')).secretValue || '5m';
+export const getJwtMfaSecret = async () => (await client.getSecret("JWT_MFA_LIFETIME")).secretValue || "5m";
-export const getJwtRefreshLifetime = async () => (await client.getSecret('JWT_REFRESH_LIFETIME')).secretValue || '90d';
+export const getJwtRefreshLifetime = async () => (await client.getSecret("JWT_REFRESH_LIFETIME")).secretValue || "90d";
-export const getJwtRefreshSecret = async () => (await client.getSecret('JWT_REFRESH_SECRET')).secretValue;
+export const getJwtRefreshSecret = async () => (await client.getSecret("JWT_REFRESH_SECRET")).secretValue;
-export const getJwtServiceSecret = async () => (await client.getSecret('JWT_SERVICE_SECRET')).secretValue;
+export const getJwtServiceSecret = async () => (await client.getSecret("JWT_SERVICE_SECRET")).secretValue;
-export const getJwtSignupLifetime = async () => (await client.getSecret('JWT_SIGNUP_LIFETIME')).secretValue || '15m';
+export const getJwtSignupLifetime = async () => (await client.getSecret("JWT_SIGNUP_LIFETIME")).secretValue || "15m";
-export const getJwtSignupSecret = async () => (await client.getSecret('JWT_SIGNUP_SECRET')).secretValue;
+export const getJwtProviderAuthSecret = async () => (await client.getSecret("JWT_PROVIDER_AUTH_SECRET")).secretValue;
-export const getMongoURL = async () => (await client.getSecret('MONGO_URL')).secretValue;
+export const getJwtProviderAuthLifetime = async () => (await client.getSecret("JWT_PROVIDER_AUTH_LIFETIME")).secretValue || "15m";
-export const getNodeEnv = async () => (await client.getSecret('NODE_ENV')).secretValue || 'production';
+export const getJwtSignupSecret = async () => (await client.getSecret("JWT_SIGNUP_SECRET")).secretValue;
-export const getVerboseErrorOutput = async () => (await client.getSecret('VERBOSE_ERROR_OUTPUT')).secretValue === 'true' && true;
+export const getMongoURL = async () => (await client.getSecret("MONGO_URL")).secretValue;
-export const getLokiHost = async () => (await client.getSecret('LOKI_HOST')).secretValue;
+export const getNodeEnv = async () => (await client.getSecret("NODE_ENV")).secretValue || "production";
-export const getClientIdAzure = async () => (await client.getSecret('CLIENT_ID_AZURE')).secretValue;
+export const getVerboseErrorOutput = async () => (await client.getSecret("VERBOSE_ERROR_OUTPUT")).secretValue === "true" && true;
-export const getClientIdHeroku = async () => (await client.getSecret('CLIENT_ID_HEROKU')).secretValue;
+export const getLokiHost = async () => (await client.getSecret("LOKI_HOST")).secretValue;
-export const getClientIdVercel = async () => (await client.getSecret('CLIENT_ID_VERCEL')).secretValue;
+export const getClientIdAzure = async () => (await client.getSecret("CLIENT_ID_AZURE")).secretValue;
-export const getClientIdNetlify = async () => (await client.getSecret('CLIENT_ID_NETLIFY')).secretValue;
+export const getClientIdHeroku = async () => (await client.getSecret("CLIENT_ID_HEROKU")).secretValue;
-export const getClientIdGitHub = async () => (await client.getSecret('CLIENT_ID_GITHUB')).secretValue;
+export const getClientIdVercel = async () => (await client.getSecret("CLIENT_ID_VERCEL")).secretValue;
-export const getClientIdGitLab = async () => (await client.getSecret('CLIENT_ID_GITLAB')).secretValue;
+export const getClientIdNetlify = async () => (await client.getSecret("CLIENT_ID_NETLIFY")).secretValue;
-export const getClientSecretAzure = async () => (await client.getSecret('CLIENT_SECRET_AZURE')).secretValue;
+export const getClientIdGitHub = async () => (await client.getSecret("CLIENT_ID_GITHUB")).secretValue;
-export const getClientSecretHeroku = async () => (await client.getSecret('CLIENT_SECRET_HEROKU')).secretValue;
+export const getClientIdGitLab = async () => (await client.getSecret("CLIENT_ID_GITLAB")).secretValue;
-export const getClientSecretVercel = async () => (await client.getSecret('CLIENT_SECRET_VERCEL')).secretValue;
+export const getClientIdBitBucket = async () => (await client.getSecret("CLIENT_ID_BITBUCKET")).secretValue;
-export const getClientSecretNetlify = async () => (await client.getSecret('CLIENT_SECRET_NETLIFY')).secretValue;
+export const getClientIdGCPSecretManager = async () => (await client.getSecret("CLIENT_ID_GCP_SECRET_MANAGER")).secretValue;
-export const getClientSecretGitHub = async () => (await client.getSecret('CLIENT_SECRET_GITHUB')).secretValue;
+export const getClientSecretAzure = async () => (await client.getSecret("CLIENT_SECRET_AZURE")).secretValue;
-export const getClientSecretGitLab = async () => (await client.getSecret('CLIENT_SECRET_GITLAB')).secretValue;
+export const getClientSecretHeroku = async () => (await client.getSecret("CLIENT_SECRET_HEROKU")).secretValue;
-export const getClientSlugVercel = async () => (await client.getSecret('CLIENT_SLUG_VERCEL')).secretValue;
+export const getClientSecretVercel = async () => (await client.getSecret("CLIENT_SECRET_VERCEL")).secretValue;
-export const getPostHogHost = async () => (await client.getSecret('POSTHOG_HOST')).secretValue || 'https://app.posthog.com';
+export const getClientSecretNetlify = async () => (await client.getSecret("CLIENT_SECRET_NETLIFY")).secretValue;
-export const getPostHogProjectApiKey = async () => (await client.getSecret('POSTHOG_PROJECT_API_KEY')).secretValue || 'phc_nSin8j5q2zdhpFDI1ETmFNUIuTG4DwKVyIigrY10XiE';
+export const getClientSecretGitHub = async () => (await client.getSecret("CLIENT_SECRET_GITHUB")).secretValue;
-export const getSentryDSN = async () => (await client.getSecret('SENTRY_DSN')).secretValue;
+export const getClientSecretGitLab = async () => (await client.getSecret("CLIENT_SECRET_GITLAB")).secretValue;
-export const getSiteURL = async () => (await client.getSecret('SITE_URL')).secretValue;
+export const getClientSecretBitBucket = async () => (await client.getSecret("CLIENT_SECRET_BITBUCKET")).secretValue;
-export const getSmtpHost = async () => (await client.getSecret('SMTP_HOST')).secretValue;
+export const getClientSecretGCPSecretManager = async () => (await client.getSecret("CLIENT_SECRET_GCP_SECRET_MANAGER")).secretValue;
-export const getSmtpSecure = async () => (await client.getSecret('SMTP_SECURE')).secretValue === 'true' || false;
+export const getClientSlugVercel = async () => (await client.getSecret("CLIENT_SLUG_VERCEL")).secretValue;
-export const getSmtpPort = async () => parseInt((await client.getSecret('SMTP_PORT')).secretValue) || 587;
+
-export const getSmtpUsername = async () => (await client.getSecret('SMTP_USERNAME')).secretValue;
+export const getClientIdGoogleLogin = async () => (await client.getSecret("CLIENT_ID_GOOGLE_LOGIN")).secretValue;
-export const getSmtpPassword = async () => (await client.getSecret('SMTP_PASSWORD')).secretValue;
+export const getClientSecretGoogleLogin = async () => (await client.getSecret("CLIENT_SECRET_GOOGLE_LOGIN")).secretValue;
-export const getSmtpFromAddress = async () => (await client.getSecret('SMTP_FROM_ADDRESS')).secretValue;
+export const getClientIdGitHubLogin = async () => (await client.getSecret("CLIENT_ID_GITHUB_LOGIN")).secretValue;
-export const getSmtpFromName = async () => (await client.getSecret('SMTP_FROM_NAME')).secretValue || 'Infisical';
+export const getClientSecretGitHubLogin = async () => (await client.getSecret("CLIENT_SECRET_GITHUB_LOGIN")).secretValue;
+
+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 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 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 getLicenseKey = async () => {
-  const secretValue = (await client.getSecret('LICENSE_KEY')).secretValue;
+  const secretValue = (await client.getSecret("LICENSE_KEY")).secretValue;
-  return secretValue === '' ? undefined : secretValue;
+  return secretValue === "" ? undefined : secretValue;
 }
 export const getLicenseServerKey = async () => {
-  const secretValue = (await client.getSecret('LICENSE_SERVER_KEY')).secretValue;
+  const secretValue = (await client.getSecret("LICENSE_SERVER_KEY")).secretValue;
-  return secretValue === '' ? undefined : 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";
 
-// TODO: deprecate from here
+export const getTelemetryEnabled = async () => (await client.getSecret("TELEMETRY_ENABLED")).secretValue !== "false" && true;
-export const getStripeProductStarter = async () => (await client.getSecret('STRIPE_PRODUCT_STARTER')).secretValue;
+export const getLoopsApiKey = async () => (await client.getSecret("LOOPS_API_KEY")).secretValue;
-export const getStripeProductPro = async () => (await client.getSecret('STRIPE_PRODUCT_PRO')).secretValue;
+export const getSmtpConfigured = async () => (await client.getSecret("SMTP_HOST")).secretValue == "" || (await client.getSecret("SMTP_HOST")).secretValue == undefined ? false : true
-export const getStripeProductTeam = async () => (await client.getSecret('STRIPE_PRODUCT_TEAM')).secretValue;
-export const getStripePublishableKey = async () => (await client.getSecret('STRIPE_PUBLISHABLE_KEY')).secretValue;
-export const getStripeSecretKey = async () => (await client.getSecret('STRIPE_SECRET_KEY')).secretValue;
-export const getStripeWebhookSecret = async () => (await client.getSecret('STRIPE_WEBHOOK_SECRET')).secretValue;
-
-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 getHttpsEnabled = async () => {
   if ((await getNodeEnv()) != "production") {
     // no https for anything other than prod
     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 (await client.getSecret('HTTPS_ENABLED')).secretValue === 'true' && true
+  return (await client.getSecret("HTTPS_ENABLED")).secretValue === "true" && true
-}
+}

backend/src/config/request.ts

@@ -1,16 +1,16 @@
-import axios from 'axios';
+import axios from "axios";
-import axiosRetry from 'axios-retry';
+import axiosRetry from "axios-retry";
 import {
-  getLicenseServerKeyAuthToken,
-  setLicenseServerKeyAuthToken,
   getLicenseKeyAuthToken,
-  setLicenseKeyAuthToken
+  getLicenseServerKeyAuthToken,
-} from './storage';
+  setLicenseKeyAuthToken,
+  setLicenseServerKeyAuthToken,
+} from "./storage";
 import {
   getLicenseKey,
   getLicenseServerKey, 
-  getLicenseServerUrl
+  getLicenseServerUrl,
-} from './index';
+} from "./index";
 
 // should have JWT to interact with the license server
 export const licenseServerKeyRequest = axios.create();
@@ -35,8 +35,8 @@ export const refreshLicenseServerKeyToken = async () => {
     `${licenseServerUrl}/api/auth/v1/license-server-login`, {},
     {
       headers: {
-        'X-API-KEY': licenseServerKey
+        "X-API-KEY": licenseServerKey,
-      }
+      },
     }
   );
 
@@ -53,8 +53,8 @@ export const refreshLicenseKeyToken = async () => {
     `${licenseServerUrl}/api/auth/v1/license-login`, {},
     {
       headers: {
-        'X-API-KEY': licenseKey
+        "X-API-KEY": licenseKey,
-      }
+      },
     }
   );
 
@@ -86,7 +86,7 @@ licenseServerKeyRequest.interceptors.response.use((response) => {
     // refresh
     const token = await refreshLicenseServerKeyToken();            
     
-    axios.defaults.headers.common['Authorization'] = 'Bearer ' + token;
+    axios.defaults.headers.common["Authorization"] = "Bearer " + token;
     return licenseServerKeyRequest(originalRequest);
   }
 
@@ -116,7 +116,7 @@ licenseKeyRequest.interceptors.response.use((response) => {
     // refresh
     const token = await refreshLicenseKeyToken();            
     
-    axios.defaults.headers.common['Authorization'] = 'Bearer ' + token;
+    axios.defaults.headers.common["Authorization"] = "Bearer " + token;
     return licenseKeyRequest(originalRequest);
   }
 

backend/src/config/storage.ts

@@ -5,7 +5,7 @@ const MemoryLicenseServerKeyTokenStorage = () => {
       setToken: (token: string) => {
         authToken = token;
       },
-      getToken: () => authToken
+      getToken: () => authToken,
     };
 };
 
@@ -16,7 +16,7 @@ const MemoryLicenseKeyTokenStorage = () => {
       setToken: (token: string) => {
         authToken = token;
       },
-      getToken: () => authToken
+      getToken: () => authToken,
     };
 };
 

backend/src/controllers/v1/authController.ts

@@ -1,29 +1,29 @@
-import * as Sentry from '@sentry/node';
+import { Request, Response } from "express";
-import { Request, Response } from 'express';
+import jwt from "jsonwebtoken";
-import jwt from 'jsonwebtoken';
+import * as bigintConversion from "bigint-conversion";
-import * as bigintConversion from 'bigint-conversion';
 // eslint-disable-next-line @typescript-eslint/no-var-requires
-const jsrp = require('jsrp');
+const jsrp = require("jsrp");
-import { User, LoginSRPDetail } from '../../models';
+import { LoginSRPDetail, TokenVersion, User } from "../../models";
-import { createToken, issueAuthTokens, clearTokens } from '../../helpers/auth';
+import { clearTokens, createToken, issueAuthTokens } from "../../helpers/auth";
-import { checkUserDevice } from '../../helpers/user';
+import { checkUserDevice } from "../../helpers/user";
+import { ACTION_LOGIN, ACTION_LOGOUT } from "../../variables";
+import { BadRequestError, UnauthorizedRequestError } from "../../utils/errors";
+import { EELogService } from "../../ee/services";
+import { getUserAgentType } from "../../utils/posthog";
 import {
-  ACTION_LOGIN,
+  getHttpsEnabled,
-  ACTION_LOGOUT
-} from '../../variables';
-import { BadRequestError } from '../../utils/errors';
-import { EELogService } from '../../ee/services';
-import { getChannelFromUserAgent } from '../../utils/posthog'; // TODO: move this
-import {
-  getJwtRefreshSecret,
   getJwtAuthLifetime,
   getJwtAuthSecret,
-  getHttpsEnabled
+  getJwtRefreshSecret
-} from '../../config';
+} from "../../config";
+import { ActorType } from "../../ee/models";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/auth";
 
-declare module 'jsonwebtoken' {
+declare module "jsonwebtoken" {
   export interface UserIDJwtPayload extends jwt.JwtPayload {
     userId: string;
+    refreshVersion?: number;
   }
 }
 
@@ -34,47 +34,42 @@ declare module 'jsonwebtoken' {
  * @returns
  */
 export const login1 = async (req: Request, res: Response) => {
-  try {
+  const {
-    const {
+    body: { email, clientPublicKey }
-      email,
+  } = await validateRequest(reqValidator.Login1V1, req);
-      clientPublicKey
-    }: { email: string; clientPublicKey: string } = req.body;
 
-    const user = await User.findOne({
+  const user = await User.findOne({
-      email
+    email
-    }).select('+salt +verifier');
+  }).select("+salt +verifier");
 
-    if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
-    const server = new jsrp.server();
+  const server = new jsrp.server();
-    server.init(
+  server.init(
-      {
+    {
-        salt: user.salt,
+      salt: user.salt,
-        verifier: user.verifier
+      verifier: user.verifier
-      },
+    },
-      async () => {
+    async () => {
-        // generate server-side public key
+      // generate server-side public key
-        const serverPublicKey = server.getPublicKey();
+      const serverPublicKey = server.getPublicKey();
 
-        await LoginSRPDetail.findOneAndReplace({ email: email }, {
+      await LoginSRPDetail.findOneAndReplace(
+        { email: email },
+        {
           email: email,
           clientPublicKey: clientPublicKey,
-          serverBInt: bigintConversion.bigintToBuf(server.bInt),
+          serverBInt: bigintConversion.bigintToBuf(server.bInt)
-        }, { upsert: true, returnNewDocument: false })
+        },
+        { upsert: true, returnNewDocument: false }
+      );
 
-        return res.status(200).send({
+      return res.status(200).send({
-          serverPublicKey,
+        serverPublicKey,
-          salt: user.salt
+        salt: user.salt
-        });
+      });
-      }
+    }
-    );
+  );
-  } catch (err) {
-    Sentry.setUser(null);
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: 'Failed to start authentication process'
-    });
-  }
 };
 
 /**
@@ -85,84 +80,88 @@ export const login1 = async (req: Request, res: Response) => {
  * @returns
  */
 export const login2 = async (req: Request, res: Response) => {
-  try {
+  const {
-    const { email, clientProof } = req.body;
+    body: { email, clientProof }
-    const user = await User.findOne({
+  } = await validateRequest(reqValidator.Login2V1, req);
-      email
-    }).select('+salt +verifier +publicKey +encryptedPrivateKey +iv +tag');
 
-    if (!user) throw new Error('Failed to find user');
+  const user = await User.findOne({
+    email
+  }).select("+salt +verifier +publicKey +encryptedPrivateKey +iv +tag");
 
-    const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: email })
+  if (!user) throw new Error("Failed to find user");
 
-    if (!loginSRPDetailFromDB) {
+  const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: email });
-      return BadRequestError(Error("It looks like some details from the first login are not found. Please try login one again"))
-    }
 
-    const server = new jsrp.server();
+  if (!loginSRPDetailFromDB) {
-    server.init(
+    return BadRequestError(
-      {
+      Error(
-        salt: user.salt,
+        "It looks like some details from the first login are not found. Please try login one again"
-        verifier: user.verifier,
+      )
-        b: loginSRPDetailFromDB.serverBInt
+    );
-      },
+  }
-      async () => {
-        server.setClientPublicKey(loginSRPDetailFromDB.clientPublicKey);
 
-        // compare server and client shared keys
+  const server = new jsrp.server();
-        if (server.checkClientProof(clientProof)) {
+  server.init(
-          // issue tokens
+    {
+      salt: user.salt,
+      verifier: user.verifier,
+      b: loginSRPDetailFromDB.serverBInt
+    },
+    async () => {
+      server.setClientPublicKey(loginSRPDetailFromDB.clientPublicKey);
 
-          await checkUserDevice({
+      // compare server and client shared keys
-            user,
+      if (server.checkClientProof(clientProof)) {
-            ip: req.ip,
+        // issue tokens
-            userAgent: req.headers['user-agent'] ?? ''
-          });
 
-          const tokens = await issueAuthTokens({ userId: user._id.toString() });
+        await checkUserDevice({
+          user,
+          ip: req.realIP,
+          userAgent: req.headers["user-agent"] ?? ""
+        });
 
-          // store (refresh) token in httpOnly cookie
+        const tokens = await issueAuthTokens({
-          res.cookie('jid', tokens.refreshToken, {
+          userId: user._id,
-            httpOnly: true,
+          ip: req.realIP,
-            path: '/',
+          userAgent: req.headers["user-agent"] ?? ""
-            sameSite: 'strict',
+        });
-            secure: await getHttpsEnabled()
-          });
 
-          const loginAction = await EELogService.createAction({
+        // store (refresh) token in httpOnly cookie
-            name: ACTION_LOGIN,
+        res.cookie("jid", tokens.refreshToken, {
-            userId: user._id
+          httpOnly: true,
-          });
+          path: "/",
+          sameSite: "strict",
+          secure: await getHttpsEnabled()
+        });
 
-          loginAction && await EELogService.createLog({
+        const loginAction = await EELogService.createAction({
+          name: ACTION_LOGIN,
+          userId: user._id
+        });
+
+        loginAction &&
+          (await EELogService.createLog({
             userId: user._id,
             actions: [loginAction],
-            channel: getChannelFromUserAgent(req.headers['user-agent']),
+            channel: getUserAgentType(req.headers["user-agent"]),
-            ipAddress: req.ip
+            ipAddress: req.realIP
-          });
+          }));
 
-          // return (access) token in response
+        // return (access) token in response
-          return res.status(200).send({
+        return res.status(200).send({
-            token: tokens.token,
+          token: tokens.token,
-            publicKey: user.publicKey,
+          publicKey: user.publicKey,
-            encryptedPrivateKey: user.encryptedPrivateKey,
+          encryptedPrivateKey: user.encryptedPrivateKey,
-            iv: user.iv,
+          iv: user.iv,
-            tag: user.tag
+          tag: user.tag
-          });
-        }
-
-        return res.status(400).send({
-          message: 'Failed to authenticate. Try again?'
         });
       }
-    );
+
-  } catch (err) {
+      return res.status(400).send({
-    Sentry.setUser(null);
+        message: "Failed to authenticate. Try again?"
-    Sentry.captureException(err);
+      });
-    return res.status(400).send({
+    }
-      message: 'Failed to authenticate. Try again?'
+  );
-    });
-  }
 };
 
 /**
@@ -172,41 +171,51 @@ export const login2 = async (req: Request, res: Response) => {
  * @returns
  */
 export const logout = async (req: Request, res: Response) => {
-  try {
+  if (req.authData.actor.type === ActorType.USER && req.authData.tokenVersionId) {
-    await clearTokens({
+    await clearTokens(req.authData.tokenVersionId);
-      userId: req.user._id.toString()
-    });
-
-    // clear httpOnly cookie
-    res.cookie('jid', '', {
-      httpOnly: true,
-      path: '/',
-      sameSite: 'strict',
-      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: getChannelFromUserAgent(req.headers['user-agent']),
-      ipAddress: req.ip
-    });
-
-  } catch (err) {
-    Sentry.setUser({ email: req.user.email });
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: 'Failed to logout'
-    });
   }
 
+  // clear httpOnly cookie
+  res.cookie("jid", "", {
+    httpOnly: true,
+    path: "/",
+    sameSite: "strict",
+    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.'
+    message: "Successfully logged out."
+  });
+};
+
+export const revokeAllSessions = async (req: Request, res: Response) => {
+  await TokenVersion.updateMany(
+    {
+      user: req.user._id
+    },
+    {
+      $inc: {
+        refreshVersion: 1,
+        accessVersion: 1
+      }
+    }
+  );
+
+  return res.status(200).send({
+    message: "Successfully revoked all sessions."
   });
 };
 
@@ -218,52 +227,60 @@ export const logout = async (req: Request, res: Response) => {
  */
 export const checkAuth = async (req: Request, res: Response) => {
   return res.status(200).send({
-    message: 'Authenticated'
+    message: "Authenticated"
   });
-}
+};
 
 /**
- * Return new token by redeeming refresh token
+ * Return new JWT access token by first validating the refresh token
  * @param req
  * @param res
  * @returns
  */
 export const getNewToken = async (req: Request, res: Response) => {
-  try {
+  const refreshToken = req.cookies.jid;
-    const refreshToken = req.cookies.jid;
 
-    if (!refreshToken) {
+  if (!refreshToken)
-      throw new Error('Failed to find token in request cookies');
+    throw BadRequestError({
-    }
+      message: "Failed to find refresh token in request cookies"
-
-    const decodedToken = <jwt.UserIDJwtPayload>(
-      jwt.verify(refreshToken, await getJwtRefreshSecret())
-    );
-
-    const user = await User.findOne({
-      _id: decodedToken.userId
-    }).select('+publicKey');
-
-    if (!user) throw new Error('Failed to authenticate unfound user');
-    if (!user?.publicKey)
-      throw new Error('Failed to authenticate not fully set up account');
-
-    const token = createToken({
-      payload: {
-        userId: decodedToken.userId
-      },
-      expiresIn: await getJwtAuthLifetime(),
-      secret: await getJwtAuthSecret()
     });
 
-    return res.status(200).send({
+  const decodedToken = <jwt.UserIDJwtPayload>jwt.verify(refreshToken, await getJwtRefreshSecret());
-      token
+
+  const user = await User.findOne({
+    _id: decodedToken.userId
+  }).select("+publicKey +refreshVersion +accessVersion");
+
+  if (!user) throw new Error("Failed to authenticate unfound user");
+  if (!user?.publicKey) throw new Error("Failed to authenticate not fully set up account");
+
+  const tokenVersion = await TokenVersion.findById(decodedToken.tokenVersionId);
+
+  if (!tokenVersion)
+    throw UnauthorizedRequestError({
+      message: "Failed to validate refresh token"
     });
-  } catch (err) {
+
-    Sentry.setUser(null);
+  if (decodedToken.refreshVersion !== tokenVersion.refreshVersion)
-    Sentry.captureException(err);
+    throw BadRequestError({
-    return res.status(400).send({
+      message: "Failed to validate refresh token"
-      message: 'Invalid request'
     });
-  }
+
+  const token = createToken({
+    payload: {
+      userId: decodedToken.userId,
+      tokenVersionId: tokenVersion._id.toString(),
+      accessVersion: tokenVersion.refreshVersion
+    },
+    expiresIn: await getJwtAuthLifetime(),
+    secret: await getJwtAuthSecret()
+  });
+
+  return res.status(200).send({
+    token
+  });
+};
+
+export const handleAuthProviderCallback = (req: Request, res: Response) => {
+  res.redirect(`/login/provider/success?token=${encodeURIComponent(req.providerAuthToken)}`);
 };

backend/src/controllers/v1/botController.ts

@@ -1,12 +1,20 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import { Types } from 'mongoose';
+import { Types } from "mongoose";
-import * as Sentry from '@sentry/node';
+import { Bot, BotKey } from "../../models";
-import { Bot, BotKey } from '../../models';
+import { createBot } from "../../helpers/bot";
-import { createBot } from '../../helpers/bot';
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/bot";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  getUserProjectPermissions
+} from "../../ee/services/ProjectRoleService";
+import { ForbiddenError } from "@casl/ability";
+import { BadRequestError } from "../../utils/errors";
 
 interface BotKey {
-    encryptedKey: string;
+  encryptedKey: string;
-    nonce: string;
+  nonce: string;
 }
 
 /**
@@ -17,33 +25,31 @@ interface BotKey {
  * @returns
  */
 export const getBotByWorkspaceId = async (req: Request, res: Response) => {
-    let bot;
+  const {
-	try {
+    params: { workspaceId }
-        const { workspaceId } = req.params;
+  } = await validateRequest(reqValidator.GetBotByWorkspaceIdV1, req);
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Read,
+    ProjectPermissionSub.Integrations
+  );
 
-        bot = await Bot.findOne({
+  let bot = await Bot.findOne({
-            workspace: workspaceId
+    workspace: workspaceId
-        });
+  });
-        
+
-        if (!bot) {
+  if (!bot) {
-            // case: bot doesn't exist for workspace with id [workspaceId]
+    // case: bot doesn't exist for workspace with id [workspaceId]
-            // -> create a new bot and return it
+    // -> create a new bot and return it
-            bot = await createBot({
+    bot = await createBot({
-                name: 'Infisical Bot',
+      name: "Infisical Bot",
-                workspaceId: new Types.ObjectId(workspaceId)
+      workspaceId: new Types.ObjectId(workspaceId)
-            });
-        }
-	} catch (err) {
-        Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-        return res.status(400).send({
-			message: 'Failed to get bot for workspace'
-		});
-	}
-    
-    return res.status(200).send({
-        bot
     });
+  }
+
+  return res.status(200).send({
+    bot
+  });
 };
 
 /**
@@ -53,56 +59,69 @@ export const getBotByWorkspaceId = async (req: Request, res: Response) => {
  * @returns
  */
 export const setBotActiveState = async (req: Request, res: Response) => {
-    let bot;
+  const {
-	try {
+    body: { botKey, isActive },
-        const { isActive, botKey }: { isActive: boolean, botKey: BotKey } = req.body;
+    params: { botId }
-        
+  } = await validateRequest(reqValidator.SetBotActiveStateV1, req);
-        if (isActive) {
-            // bot state set to active -> share workspace key with bot
-            if (!botKey?.encryptedKey || !botKey?.nonce) {
-                return res.status(400).send({
-                    message: 'Failed to set bot state to active - missing bot key'
-                });
-            }
-            
-            await BotKey.findOneAndUpdate({
-                workspace: req.bot.workspace
-            }, {
-                encryptedKey: botKey.encryptedKey,
-                nonce: botKey.nonce,
-                sender: req.user._id,
-                bot: req.bot._id,
-                workspace: req.bot.workspace
-            }, {
-                upsert: true,
-                new: true
-            });
-        } else {
-            // case: bot state set to inactive -> delete bot's workspace key
-            await BotKey.deleteOne({
-                bot: req.bot._id
-            });
-        }
 
-        bot = await Bot.findOneAndUpdate({
+  const bot = await Bot.findById(botId);
-            _id: req.bot._id
+  if (!bot) {
-        }, {
+    throw BadRequestError({ message: "Bot not found" });
-            isActive
+  }
-        }, {
+  const userId = req.user._id;
-            new: true
+
-        });
+  const { permission } = await getUserProjectPermissions(userId, bot.workspace.toString());
-        
+  ForbiddenError.from(permission).throwUnlessCan(
-        if (!bot) throw new Error('Failed to update bot active state');
+    ProjectPermissionActions.Edit,
-        
+    ProjectPermissionSub.Integrations
-	} catch (err) {
+  );
-        Sentry.setUser({ email: req.user.email });
+
-		Sentry.captureException(err);
+  if (isActive) {
-        return res.status(400).send({
+    // bot state set to active -> share workspace key with bot
-			message: 'Failed to update bot active state'
+    if (!botKey?.encryptedKey || !botKey?.nonce) {
-		});
+      return res.status(400).send({
-	}
+        message: "Failed to set bot state to active - missing bot key"
-    
+      });
-    return res.status(200).send({
+    }
-        bot
+
+    await BotKey.findOneAndUpdate(
+      {
+        workspace: bot.workspace
+      },
+      {
+        encryptedKey: botKey.encryptedKey,
+        nonce: botKey.nonce,
+        sender: userId,
+        bot: bot._id,
+        workspace: bot.workspace
+      },
+      {
+        upsert: true,
+        new: true
+      }
+    );
+  } else {
+    // case: bot state set to inactive -> delete bot's workspace key
+    await BotKey.deleteOne({
+      bot: bot._id
     });
+  }
+
+  const updatedBot = await Bot.findOneAndUpdate(
+    {
+      _id: bot._id
+    },
+    {
+      isActive
+    },
+    {
+      new: true
+    }
+  );
+
+  if (!updatedBot) throw new Error("Failed to update bot active state");
+
+  return res.status(200).send({
+    bot
+  });
 };

backend/src/controllers/v1/index.ts

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

backend/src/controllers/v1/integrationController.ts

@@ -1,11 +1,21 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import { Types } from 'mongoose';
+import { Types } from "mongoose";
-import * as Sentry from '@sentry/node';
+import { Folder, IWorkspace, Integration, IntegrationAuth } from "../../models";
-import { 
+import { EventService } from "../../services";
-	Integration
+import { eventStartIntegration } from "../../events";
-} from '../../models';
+import { getFolderByPath } from "../../services/FolderService";
-import { EventService } from '../../services';
+import { BadRequestError } from "../../utils/errors";
-import { eventPushSecrets } from '../../events';
+import { EEAuditLogService } from "../../ee/services";
+import { EventType } from "../../ee/models";
+import { syncSecretsToActiveIntegrationsQueue } from "../../queues/integrations/syncSecretsToThirdPartyServices";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/integration";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  getUserProjectPermissions
+} from "../../ee/services/ProjectRoleService";
+import { ForbiddenError } from "@casl/ability";
 
 /**
  * Create/initialize an (empty) integration for integration authorization
@@ -14,64 +24,115 @@ import { eventPushSecrets } from '../../events';
  * @returns
  */
 export const createIntegration = async (req: Request, res: Response) => {
-	let integration;
+  const {
-
+    body: {
-	try {
-		const {
-			integrationAuthId,
-			app,
-			appId,
-			isActive,
-			sourceEnvironment,
-			targetEnvironment,
-			targetEnvironmentId,
-      targetService,
-      targetServiceId,
-			owner,
-			path,
-			region
-		} = req.body;
-		
-		// TODO: validate [sourceEnvironment] and [targetEnvironment]
-
-		// initialize new integration after saving integration access token
-    integration = await new Integration({
-      workspace: req.integrationAuth.workspace._id,
-      environment: sourceEnvironment,
       isActive,
+      sourceEnvironment,
+      secretPath,
       app,
-			appId,
+      path,
-			targetEnvironment,
+      appId,
-			targetEnvironmentId,
+      owner,
+      region,
       targetService,
       targetServiceId,
-			owner,
+      integrationAuthId,
-			path,
+      targetEnvironment,
-			region,
+      targetEnvironmentId,
-      integration: req.integrationAuth.integration,
+      metadata
-      integrationAuth: new Types.ObjectId(integrationAuthId)
+    }
-    }).save();
+  } = await validateRequest(reqValidator.CreateIntegrationV1, req);
-		
-		if (integration) {
-			// trigger event - push secrets
-			EventService.handleEvent({
-				event: eventPushSecrets({
-					workspaceId: integration.workspace,
-          environment: sourceEnvironment
-				})
-			});
-		}
 
-	} catch (err) {
+  const integrationAuth = await IntegrationAuth.findById(integrationAuthId)
-		Sentry.setUser({ email: req.user.email });
+    .populate<{ workspace: IWorkspace }>("workspace")
-		Sentry.captureException(err);
+    .select(
-		return res.status(400).send({
+      "+refreshCiphertext +refreshIV +refreshTag +accessCiphertext +accessIV +accessTag +accessExpiresAt"
-			message: 'Failed to create integration'
+    );
-		});
+
-	}
+  if (!integrationAuth) throw BadRequestError({ message: "Integration auth not found" });
+
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    integrationAuth.workspace._id.toString()
+  );
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Create,
+    ProjectPermissionSub.Integrations
+  );
+
+  const folders = await Folder.findOne({
+    workspace: integrationAuth.workspace._id,
+    environment: sourceEnvironment
+  });
+
+  if (folders) {
+    const folder = getFolderByPath(folders.nodes, secretPath);
+    if (!folder) {
+      throw BadRequestError({
+        message: "Folder path doesn't exist"
+      });
+    }
+  }
+
+  // TODO: validate [sourceEnvironment] and [targetEnvironment]
+
+  // initialize new integration after saving integration access token
+  const integration = await new Integration({
+    workspace: integrationAuth.workspace._id,
+    environment: sourceEnvironment,
+    isActive,
+    app,
+    appId,
+    targetEnvironment,
+    targetEnvironmentId,
+    targetService,
+    targetServiceId,
+    owner,
+    path,
+    region,
+    secretPath,
+    integration: integrationAuth.integration,
+    integrationAuth: new Types.ObjectId(integrationAuthId),
+    metadata
+  }).save();
+
+  if (integration) {
+    // trigger event - push secrets
+    EventService.handleEvent({
+      event: eventStartIntegration({
+        workspaceId: integration.workspace,
+        environment: sourceEnvironment
+      })
+    });
+  }
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.CREATE_INTEGRATION,
+      metadata: {
+        integrationId: integration._id.toString(),
+        integration: integration.integration,
+        environment: integration.environment,
+        secretPath,
+        url: integration.url,
+        app: integration.app,
+        appId: integration.appId,
+        targetEnvironment: integration.targetEnvironment,
+        targetEnvironmentId: integration.targetEnvironmentId,
+        targetService: integration.targetService,
+        targetServiceId: integration.targetServiceId,
+        path: integration.path,
+        region: integration.region
+      }
+    },
+    {
+      workspaceId: integration.workspace
+    }
+  );
 
   return res.status(200).send({
-    integration,
+    integration
   });
 };
 
@@ -82,86 +143,156 @@ export const createIntegration = async (req: Request, res: Response) => {
  * @returns
  */
 export const updateIntegration = async (req: Request, res: Response) => {
-  let integration;
-
   // TODO: add integration-specific validation to ensure that each
   // integration has the correct fields populated in [Integration]
 
-  try {
+  const {
-    const {
+    body: {
       environment,
       isActive,
       app,
       appId,
       targetEnvironment,
       owner, // github-specific integration param
-    } = req.body;
+      secretPath
+    },
+    params: { integrationId }
+  } = await validateRequest(reqValidator.UpdateIntegrationV1, req);
 
-    integration = await Integration.findOneAndUpdate(
+  const integration = await Integration.findById(integrationId);
-      {
+  if (!integration) throw BadRequestError({ message: "Integration not found" });
-        _id: req.integration._id,
-      },
-      {
-        environment,
-        isActive,
-        app,
-        appId,
-        targetEnvironment,
-        owner,
-      },
-      {
-        new: true,
-      }
-    );
 
-    if (integration) {
+  const { permission } = await getUserProjectPermissions(
-      // trigger event - push secrets
+    req.user._id,
-      EventService.handleEvent({
+    integration.workspace.toString()
-        event: eventPushSecrets({
+  );
-          workspaceId: integration.workspace,
+  ForbiddenError.from(permission).throwUnlessCan(
-          environment
+    ProjectPermissionActions.Edit,
-        }),
+    ProjectPermissionSub.Integrations
+  );
+
+  const folders = await Folder.findOne({
+    workspace: integration.workspace,
+    environment
+  });
+
+  if (folders) {
+    const folder = getFolderByPath(folders.nodes, secretPath);
+    if (!folder) {
+      throw BadRequestError({
+        message: "Path for service token does not exist"
       });
     }
-  } catch (err) {
+  }
-    Sentry.setUser({ email: req.user.email });
+
-    Sentry.captureException(err);
+  const updatedIntegration = await Integration.findOneAndUpdate(
-    return res.status(400).send({
+    {
-      message: "Failed to update integration",
+      _id: integration._id
+    },
+    {
+      environment,
+      isActive,
+      app,
+      appId,
+      targetEnvironment,
+      owner,
+      secretPath
+    },
+    {
+      new: true
+    }
+  );
+
+  if (updatedIntegration) {
+    // trigger event - push secrets
+    EventService.handleEvent({
+      event: eventStartIntegration({
+        workspaceId: updatedIntegration.workspace,
+        environment
+      })
     });
   }
 
   return res.status(200).send({
-    integration,
+    integration: updatedIntegration
   });
 };
 
 /**
- * Delete integration with id [integrationId] and deactivate bot if there are
+ * Delete integration with id [integrationId]
- * no integrations left
  * @param req
  * @param res
  * @returns
  */
 export const deleteIntegration = async (req: Request, res: Response) => {
-  let integration;
+  const {
-  try {
+    params: { integrationId }
-    const { integrationId } = req.params;
+  } = await validateRequest(reqValidator.DeleteIntegrationV1, req);
 
-    integration = await Integration.findOneAndDelete({
+  const integration = await Integration.findById(integrationId);
-      _id: integrationId,
+  if (!integration) throw BadRequestError({ message: "Integration not found" });
-    });
 
-    if (!integration) throw new Error("Failed to find integration");
+  const { permission } = await getUserProjectPermissions(
-  } catch (err) {
+    req.user._id,
-    Sentry.setUser({ email: req.user.email });
+    integration.workspace.toString()
-    Sentry.captureException(err);
+  );
-    return res.status(400).send({
+  ForbiddenError.from(permission).throwUnlessCan(
-      message: "Failed to delete integration",
+    ProjectPermissionActions.Delete,
-    });
+    ProjectPermissionSub.Integrations
-  }
+  );
+
+  const deletedIntegration = await Integration.findOneAndDelete({
+    _id: integrationId
+  });
+
+  if (!deletedIntegration) throw new Error("Failed to find integration");
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.DELETE_INTEGRATION,
+      metadata: {
+        integrationId: integration._id.toString(),
+        integration: integration.integration,
+        environment: integration.environment,
+        secretPath: integration.secretPath,
+        url: integration.url,
+        app: integration.app,
+        appId: integration.appId,
+        targetEnvironment: integration.targetEnvironment,
+        targetEnvironmentId: integration.targetEnvironmentId,
+        targetService: integration.targetService,
+        targetServiceId: integration.targetServiceId,
+        path: integration.path,
+        region: integration.region
+      }
+    },
+    {
+      workspaceId: integration.workspace
+    }
+  );
 
   return res.status(200).send({
-    integration,
+    integration
   });
 };
+
+// Will trigger sync for all integrations within the given env and workspace id
+export const manualSync = async (req: Request, res: Response) => {
+  const {
+    body: { workspaceId, environment }
+  } = await validateRequest(reqValidator.ManualSyncV1, req);
+
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Edit,
+    ProjectPermissionSub.Integrations
+  );
+
+  syncSecretsToActiveIntegrationsQueue({
+    workspaceId,
+    environment
+  });
+
+  res.status(200).send();
+};

backend/src/controllers/v1/keyController.ts

@@ -1,7 +1,17 @@
-import { Request, Response } from 'express';
+import { Types } from "mongoose";
-import * as Sentry from '@sentry/node';
+import { Request, Response } from "express";
-import { Key } from '../../models';
+import { Key } from "../../models";
-import { findMembership } from '../../helpers/membership';
+import { findMembership } from "../../helpers/membership";
+import { EventType } from "../../ee/models";
+import { EEAuditLogService } from "../../ee/services";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/key";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  getUserProjectPermissions
+} from "../../ee/services/ProjectRoleService";
+import { ForbiddenError } from "@casl/ability";
 
 /**
  * Add (encrypted) copy of workspace key for workspace with id [workspaceId] for user with
@@ -11,38 +21,38 @@ import { findMembership } from '../../helpers/membership';
  * @returns
  */
 export const uploadKey = async (req: Request, res: Response) => {
-	try {
+  const {
-		const { workspaceId } = req.params;
+    params: { workspaceId },
-		const { key } = req.body;
+    body: { key }
+  } = await validateRequest(reqValidator.UploadKeyV1, req);
 
-		// validate membership of receiver
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-		const receiverMembership = await findMembership({
+  ForbiddenError.from(permission).throwUnlessCan(
-			user: key.userId,
+    ProjectPermissionActions.Edit,
-			workspace: workspaceId
+    ProjectPermissionSub.Member
-		});
+  );
 
-		if (!receiverMembership) {
+  // validate membership of receiver
-			throw new Error('Failed receiver membership validation for workspace');
+  const receiverMembership = await findMembership({
-		}
+    user: key.userId,
+    workspace: workspaceId
+  });
 
-		await new Key({
+  if (!receiverMembership) {
-			encryptedKey: key.encryptedKey,
+    throw new Error("Failed receiver membership validation for workspace");
-			nonce: key.nonce,
+  }
-			sender: req.user._id,
-			receiver: key.userId,
-			workspace: workspaceId
-		}).save();
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to upload key to workspace'
-		});
-	}
 
-	return res.status(200).send({
+  await new Key({
-		message: 'Successfully uploaded key to workspace'
+    encryptedKey: key.encryptedKey,
-	});
+    nonce: key.nonce,
+    sender: req.user._id,
+    receiver: key.userId,
+    workspace: workspaceId
+  }).save();
+
+  return res.status(200).send({
+    message: "Successfully uploaded key to workspace"
+  });
 };
 
 /**
@@ -52,31 +62,36 @@ export const uploadKey = async (req: Request, res: Response) => {
  * @returns
  */
 export const getLatestKey = async (req: Request, res: Response) => {
-	let latestKey;
+  const {
-	try {
+    params: { workspaceId }
-		const { workspaceId } = req.params;
+  } = await validateRequest(reqValidator.GetLatestKeyV1, req);
 
-		// get latest key
+  // get latest key
-		latestKey = await Key.find({
+  const latestKey = await Key.find({
-			workspace: workspaceId,
+    workspace: workspaceId,
-			receiver: req.user._id
+    receiver: req.user._id
-		})
+  })
-			.sort({ createdAt: -1 })
+    .sort({ createdAt: -1 })
-			.limit(1)
+    .limit(1)
-			.populate('sender', '+publicKey');
+    .populate("sender", "+publicKey");
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get latest key'
-		});
-	}
 
-	const resObj: any = {};
+  const resObj: any = {};
 
-	if (latestKey.length > 0) {
+  if (latestKey.length > 0) {
-		resObj['latestKey'] = latestKey[0];
+    resObj["latestKey"] = latestKey[0];
-	}
+    await EEAuditLogService.createAuditLog(
+      req.authData,
+      {
+        type: EventType.GET_WORKSPACE_KEY,
+        metadata: {
+          keyId: latestKey[0]._id.toString()
+        }
+      },
+      {
+        workspaceId: new Types.ObjectId(workspaceId)
+      }
+    );
+  }
 
-	return res.status(200).send(resObj);
+  return res.status(200).send(resObj);
-};
+};

backend/src/controllers/v1/membershipController.ts

@@ -1,13 +1,23 @@
-import * as Sentry from '@sentry/node';
+import { Request, Response } from "express";
-import { Request, Response } from 'express';
+import { Types } from "mongoose";
-import { Membership, MembershipOrg, User, Key } from '../../models';
+import { IUser, Key, Membership, MembershipOrg, User, Workspace } from "../../models";
+import { EventType } from "../../ee/models";
+import { deleteMembership as deleteMember, findMembership } from "../../helpers/membership";
+import { sendMail } from "../../helpers/nodemailer";
+import { ACCEPTED, ADMIN, CUSTOM, MEMBER, VIEWER } from "../../variables";
+import { getSiteURL } from "../../config";
+import { EEAuditLogService } from "../../ee/services";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/membership";
 import {
-	findMembership,
+  ProjectPermissionActions,
-	deleteMembership as deleteMember
+  ProjectPermissionSub,
-} from '../../helpers/membership';
+  getUserProjectPermissions
-import { sendMail } from '../../helpers/nodemailer';
+} from "../../ee/services/ProjectRoleService";
-import { ADMIN, MEMBER, ACCEPTED } from '../../variables';
+import { ForbiddenError } from "@casl/ability";
-import { getSiteURL } from '../../config';
+import Role from "../../ee/models/role";
+import { BadRequestError } from "../../utils/errors";
+import { InviteUserToWorkspaceV1 } from "../../validation/workspace";
 
 /**
  * Check that user is a member of workspace with id [workspaceId]
@@ -16,29 +26,23 @@ import { getSiteURL } from '../../config';
  * @returns
  */
 export const validateMembership = async (req: Request, res: Response) => {
-	try {
+  const {
-		const { workspaceId } = req.params;
+    params: { workspaceId }
+  } = await validateRequest(reqValidator.ValidateMembershipV1, req);
 
-		// validate membership
+  // validate membership
-		const membership = await findMembership({
+  const membership = await findMembership({
-			user: req.user._id,
+    user: req.user._id,
-			workspace: workspaceId
+    workspace: workspaceId
-		});
+  });
 
-		if (!membership) {
+  if (!membership) {
-			throw new Error('Failed to validate membership');
+    throw new Error("Failed to validate membership");
-		}
+  }
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed workspace connection check'
-		});
-	}
 
-	return res.status(200).send({
+  return res.status(200).send({
-		message: 'Workspace membership confirmed'
+    message: "Workspace membership confirmed"
-	});
+  });
 };
 
 /**
@@ -48,52 +52,50 @@ export const validateMembership = async (req: Request, res: Response) => {
  * @returns
  */
 export const deleteMembership = async (req: Request, res: Response) => {
-	let deletedMembership;
+  const {
-	try {
+    params: { membershipId }
-		const { membershipId } = req.params;
+  } = await validateRequest(reqValidator.DeleteMembershipV1, req);
 
-		// check if membership to delete exists
+  // check if membership to delete exists
-		const membershipToDelete = await Membership.findOne({
+  const membershipToDelete = await Membership.findOne({
-			_id: membershipId
+    _id: membershipId
-		}).populate('user');
+  }).populate<{ user: IUser }>("user");
 
-		if (!membershipToDelete) {
+  if (!membershipToDelete) {
-			throw new Error(
+    throw new Error("Failed to delete workspace membership that doesn't exist");
-				"Failed to delete workspace membership that doesn't exist"
+  }
-			);
-		}
 
-		// check if user is a member and admin of the workspace
+  const { permission } = await getUserProjectPermissions(
-		// whose membership we wish to delete
+    req.user._id,
-		const membership = await Membership.findOne({
+    membershipToDelete.workspace.toString()
-			user: req.user._id,
+  );
-			workspace: membershipToDelete.workspace
+  ForbiddenError.from(permission).throwUnlessCan(
-		});
+    ProjectPermissionActions.Delete,
+    ProjectPermissionSub.Member
+  );
 
-		if (!membership) {
+  // delete workspace membership
-			throw new Error('Failed to validate workspace membership');
+  const deletedMembership = await deleteMember({
-		}
+    membershipId: membershipToDelete._id.toString()
+  });
 
-		if (membership.role !== ADMIN) {
+  await EEAuditLogService.createAuditLog(
-			// user is not an admin member of the workspace
+    req.authData,
-			throw new Error('Insufficient role for deleting workspace membership');
+    {
-		}
+      type: EventType.REMOVE_WORKSPACE_MEMBER,
+      metadata: {
+        userId: membershipToDelete.user._id.toString(),
+        email: membershipToDelete.user.email
+      }
+    },
+    {
+      workspaceId: membershipToDelete.workspace
+    }
+  );
 
-		// delete workspace membership
+  return res.status(200).send({
-		deletedMembership = await deleteMember({
+    deletedMembership
-			membershipId: membershipToDelete._id.toString()
+  });
-		});
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to delete membership'
-		});
-	}
-
-	return res.status(200).send({
-		deletedMembership
-	});
 };
 
 /**
@@ -103,53 +105,80 @@ export const deleteMembership = async (req: Request, res: Response) => {
  * @returns
  */
 export const changeMembershipRole = async (req: Request, res: Response) => {
-	let membershipToChangeRole;
+  const {
-	try {
+    body: { role },
-		const { membershipId } = req.params;
+    params: { membershipId }
-		const { role } = req.body;
+  } = await validateRequest(reqValidator.ChangeMembershipRoleV1, req);
 
-		if (![ADMIN, MEMBER].includes(role)) {
+  // validate target membership
-			throw new Error('Failed to validate role');
+  const membershipToChangeRole = await Membership.findById(membershipId).populate<{ user: IUser }>(
-		}
+    "user"
+  );
 
-		// validate target membership
+  if (!membershipToChangeRole) {
-		membershipToChangeRole = await findMembership({
+    throw new Error("Failed to find membership to change role");
-			_id: membershipId
+  }
-		});
 
-		if (!membershipToChangeRole) {
+  const { permission } = await getUserProjectPermissions(
-			throw new Error('Failed to find membership to change role');
+    req.user._id,
-		}
+    membershipToChangeRole.workspace.toString()
+  );
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Edit,
+    ProjectPermissionSub.Member
+  );
 
-		// check if user is a member and admin of target membership's
+  const isCustomRole = ![ADMIN, MEMBER, VIEWER].includes(role);
-		// workspace
+  if (isCustomRole) {
-		const membership = await findMembership({
+    const wsRole = await Role.findOne({
-			user: req.user._id,
+      slug: role,
-			workspace: membershipToChangeRole.workspace
+      isOrgRole: false,
-		});
+      workspace: membershipToChangeRole.workspace
+    });
+    if (!wsRole) throw BadRequestError({ message: "Role not found" });
+    const membership = await Membership.findByIdAndUpdate(membershipId, {
+      role: CUSTOM,
+      customRole: wsRole
+    });
+    return res.status(200).send({
+      membership
+    });
+  }
 
-		if (!membership) {
+  const membership = await Membership.findByIdAndUpdate(
-			throw new Error('Failed to validate membership');
+    membershipId,
-		}
+    {
+      $set: {
+        role
+      },
+      $unset: {
+        customRole: 1
+      }
+    },
+    {
+      new: true
+    }
+  );
 
-		if (membership.role !== ADMIN) {
+  await EEAuditLogService.createAuditLog(
-			// user is not an admin member of the workspace
+    req.authData,
-			throw new Error('Insufficient role for changing member roles');
+    {
-		}
+      type: EventType.UPDATE_USER_WORKSPACE_ROLE,
+      metadata: {
+        userId: membershipToChangeRole.user._id.toString(),
+        email: membershipToChangeRole.user.email,
+        oldRole: membershipToChangeRole.role,
+        newRole: role
+      }
+    },
+    {
+      workspaceId: membershipToChangeRole.workspace
+    }
+  );
 
-		membershipToChangeRole.role = role;
+  return res.status(200).send({
-		await membershipToChangeRole.save();
+    membership
-	} catch (err) {
+  });
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to change membership role'
-		});
-	}
-
-	return res.status(200).send({
-		membership: membershipToChangeRole
-	});
 };
 
 /**
@@ -159,75 +188,86 @@ export const changeMembershipRole = async (req: Request, res: Response) => {
  * @returns
  */
 export const inviteUserToWorkspace = async (req: Request, res: Response) => {
-	let invitee, latestKey;
+  const {
-	try {
+    params: { workspaceId },
-		const { workspaceId } = req.params;
+    body: { email }
-		const { email }: { email: string } = req.body;
+  } = await validateRequest(InviteUserToWorkspaceV1, req);
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Create,
+    ProjectPermissionSub.Member
+  );
 
-		invitee = await User.findOne({
+  const invitee = await User.findOne({
-			email
+    email
-		}).select('+publicKey');
+  }).select("+publicKey");
 
-		if (!invitee || !invitee?.publicKey)
+  if (!invitee || !invitee?.publicKey) throw new Error("Failed to validate invitee");
-			throw new Error('Failed to validate invitee');
 
-		// validate invitee's workspace membership - ensure member isn't
+  // validate invitee's workspace membership - ensure member isn't
-		// already a member of the workspace
+  // already a member of the workspace
-		const inviteeMembership = await Membership.findOne({
+  const inviteeMembership = await Membership.findOne({
-			user: invitee._id,
+    user: invitee._id,
-			workspace: workspaceId
+    workspace: workspaceId
-		});
+  }).populate<{ user: IUser }>("user");
 
-		if (inviteeMembership)
+  if (inviteeMembership) throw new Error("Failed to add existing member of workspace");
-			throw new Error('Failed to add existing member of workspace');
 
-		// validate invitee's organization membership - ensure that only
+  const workspace = await Workspace.findById(workspaceId);
-		// (accepted) organization members can be added to the workspace
+  if (!workspace) throw new Error("Failed to find workspace");
-		const membershipOrg = await MembershipOrg.findOne({
+  // validate invitee's organization membership - ensure that only
-			user: invitee._id,
+  // (accepted) organization members can be added to the workspace
-			organization: req.membership.workspace.organization,
+  const membershipOrg = await MembershipOrg.findOne({
-			status: ACCEPTED
+    user: invitee._id,
-		});
+    organization: workspace.organization,
+    status: ACCEPTED
+  });
 
-		if (!membershipOrg)
+  if (!membershipOrg) throw new Error("Failed to validate invitee's organization membership");
-			throw new Error("Failed to validate invitee's organization membership");
 
-		// get latest key
+  // get latest key
-		latestKey = await Key.findOne({
+  const latestKey = await Key.findOne({
-			workspace: workspaceId,
+    workspace: workspaceId,
-			receiver: req.user._id
+    receiver: req.user._id
-		})
+  })
-			.sort({ createdAt: -1 })
+    .sort({ createdAt: -1 })
-			.populate('sender', '+publicKey');
+    .populate("sender", "+publicKey");
 
-		// create new workspace membership
+  // create new workspace membership
-		const m = await new Membership({
+  await new Membership({
-			user: invitee._id,
+    user: invitee._id,
-			workspace: workspaceId,
+    workspace: workspaceId,
-			role: MEMBER
+    role: MEMBER
-		}).save();
+  }).save();
 
-		await sendMail({
+  await sendMail({
-			template: 'workspaceInvitation.handlebars',
+    template: "workspaceInvitation.handlebars",
-			subjectLine: 'Infisical workspace invitation',
+    subjectLine: "Infisical workspace invitation",
-			recipients: [invitee.email],
+    recipients: [invitee.email],
-			substitutions: {
+    substitutions: {
-				inviterFirstName: req.user.firstName,
+      inviterFirstName: req.user.firstName,
-				inviterEmail: req.user.email,
+      inviterEmail: req.user.email,
-				workspaceName: req.membership.workspace.name,
+      workspaceName: workspace.name,
-				callback_url: (await getSiteURL()) + '/login'
+      callback_url: (await getSiteURL()) + "/login"
-			}
+    }
-		});
+  });
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to invite user to workspace'
-		});
-	}
 
-	return res.status(200).send({
+  await EEAuditLogService.createAuditLog(
-		invitee,
+    req.authData,
-		latestKey
+    {
-	});
+      type: EventType.ADD_WORKSPACE_MEMBER,
-};
+      metadata: {
+        userId: invitee._id.toString(),
+        email: invitee.email
+      }
+    },
+    {
+      workspaceId: new Types.ObjectId(workspaceId)
+    }
+  );
+
+  return res.status(200).send({
+    invitee,
+    latestKey
+  });
+};

backend/src/controllers/v1/membershipOrgController.ts

@@ -1,14 +1,29 @@
-import { Types } from 'mongoose';
+import { Types } from "mongoose";
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
+import { MembershipOrg, Organization, User } from "../../models";
-import { MembershipOrg, Organization, User } from '../../models';
+import { SSOConfig } from "../../ee/models";
-import { deleteMembershipOrg as deleteMemberFromOrg } from '../../helpers/membershipOrg';
+import { deleteMembershipOrg as deleteMemberFromOrg } from "../../helpers/membershipOrg";
-import { createToken } from '../../helpers/auth';
+import { createToken } from "../../helpers/auth";
-import { updateSubscriptionOrgQuantity } from '../../helpers/organization';
+import { updateSubscriptionOrgQuantity } from "../../helpers/organization";
-import { sendMail } from '../../helpers/nodemailer';
+import { sendMail } from "../../helpers/nodemailer";
-import { TokenService } from '../../services';
+import { TokenService } from "../../services";
-import { OWNER, ADMIN, MEMBER, ACCEPTED, INVITED, TOKEN_EMAIL_ORG_INVITATION } from '../../variables';
+import { EELicenseService } from "../../ee/services";
-import { getSiteURL, getJwtSignupLifetime, getJwtSignupSecret, getSmtpConfigured } from '../../config';
+import { ACCEPTED, INVITED, MEMBER, TOKEN_EMAIL_ORG_INVITATION } from "../../variables";
+import * as reqValidator from "../../validation/membershipOrg";
+import {
+  getJwtSignupLifetime,
+  getJwtSignupSecret,
+  getSiteURL,
+  getSmtpConfigured
+} from "../../config";
+import { validateUserEmail } from "../../validation";
+import { validateRequest } from "../../helpers/validation";
+import {
+  OrgPermissionActions,
+  OrgPermissionSubjects,
+  getUserOrgPermissions
+} from "../../ee/services/RoleService";
+import { ForbiddenError } from "@casl/ability";
 
 /**
  * Delete organization membership with id [membershipOrgId] from organization
@@ -16,55 +31,39 @@ import { getSiteURL, getJwtSignupLifetime, getJwtSignupSecret, getSmtpConfigured
  * @param res
  * @returns
  */
-export const deleteMembershipOrg = async (req: Request, res: Response) => {
+export const deleteMembershipOrg = async (req: Request, _res: Response) => {
-	let membershipOrgToDelete;
+  const {
-	try {
+    params: { membershipOrgId }
-		const { membershipOrgId } = req.params;
+  } = await validateRequest(reqValidator.DelOrgMembershipv1, req);
 
-		// check if organization membership to delete exists
+  // check if organization membership to delete exists
-		membershipOrgToDelete = await MembershipOrg.findOne({
+  const membershipOrgToDelete = await MembershipOrg.findOne({
-			_id: membershipOrgId
+    _id: membershipOrgId
-		}).populate('user');
+  }).populate("user");
 
-		if (!membershipOrgToDelete) {
+  if (!membershipOrgToDelete) {
-			throw new Error(
+    throw new Error("Failed to delete organization membership that doesn't exist");
-				"Failed to delete organization membership that doesn't exist"
+  }
-			);
-		}
 
-		// check if user is a member and admin of the organization
+  const { permission, membership: membershipOrg } = await getUserOrgPermissions(
-		// whose membership we wish to delete
+    req.user._id,
-		const membershipOrg = await MembershipOrg.findOne({
+    membershipOrgToDelete.organization.toString()
-			user: req.user._id,
+  );
-			organization: membershipOrgToDelete.organization
+  ForbiddenError.from(permission).throwUnlessCan(
-		});
+    OrgPermissionActions.Delete,
+    OrgPermissionSubjects.Member
+  );
 
-		if (!membershipOrg) {
+  // delete organization membership
-			throw new Error('Failed to validate organization membership');
+  await deleteMemberFromOrg({
-		}
+    membershipOrgId: membershipOrgToDelete._id.toString()
+  });
 
-		if (membershipOrg.role !== OWNER && membershipOrg.role !== ADMIN) {
+  await updateSubscriptionOrgQuantity({
-			// user is not an admin member of the organization
+    organizationId: membershipOrg.organization.toString()
-			throw new Error('Insufficient role for deleting organization membership');
+  });
-		}
 
-		// delete organization membership
+  return membershipOrgToDelete;
-		const deletedMembershipOrg = await deleteMemberFromOrg({
-			membershipOrgId: membershipOrgToDelete._id.toString()
-		});
-
-		await updateSubscriptionOrgQuantity({
-			organizationId: membershipOrg.organization.toString()
-		});
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to delete organization membership'
-		});
-	}
-
-	return membershipOrgToDelete;
 };
 
 /**
@@ -74,22 +73,14 @@ export const deleteMembershipOrg = async (req: Request, res: Response) => {
  * @returns
  */
 export const changeMembershipOrgRole = async (req: Request, res: Response) => {
-	// change role for (target) organization membership with id
+  // change role for (target) organization membership with id
-	// [membershipOrgId]
+  // [membershipOrgId]
 
-	let membershipToChangeRole;
+  let membershipToChangeRole;
-	// try {
-	// } catch (err) {
-	// 	Sentry.setUser({ email: req.user.email });
-	// 	Sentry.captureException(err);
-	// 	return res.status(400).send({
-	// 		message: 'Failed to change organization membership role'
-	// 	});
-	// }
 
-	return res.status(200).send({
+  return res.status(200).send({
-		membershipOrg: membershipToChangeRole
+    membershipOrg: membershipToChangeRole
-	});
+  });
 };
 
 /**
@@ -100,112 +91,128 @@ export const changeMembershipOrgRole = async (req: Request, res: Response) => {
  * @returns
  */
 export const inviteUserToOrganization = async (req: Request, res: Response) => {
-	let invitee, inviteeMembershipOrg, completeInviteLink;
+  let inviteeMembershipOrg, completeInviteLink;
-	try {
+  const {
-		const { organizationId, inviteeEmail } = req.body;
+    body: { inviteeEmail, organizationId }
-		const host = req.headers.host;
+  } = await validateRequest(reqValidator.InviteUserToOrgv1, req);
-		const siteUrl = `${req.protocol}://${host}`;
 
-		// validate membership
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-		const membershipOrg = await MembershipOrg.findOne({
+  ForbiddenError.from(permission).throwUnlessCan(
-			user: req.user._id,
+    OrgPermissionActions.Create,
-			organization: organizationId
+    OrgPermissionSubjects.Member
-		});
+  );
 
-		if (!membershipOrg) {
+  const host = req.headers.host;
-			throw new Error('Failed to validate organization membership');
+  const siteUrl = `${req.protocol}://${host}`;
-		}
+  const plan = await EELicenseService.getPlan(new Types.ObjectId(organizationId));
 
-		invitee = await User.findOne({
+  const ssoConfig = await SSOConfig.findOne({
-			email: inviteeEmail
+    organization: new Types.ObjectId(organizationId)
-		}).select('+publicKey');
+  });
 
-		if (invitee) {
+  if (ssoConfig && ssoConfig.isActive) {
-			// case: invitee is an existing user
+    // case: SAML SSO is enabled for the organization
+    return res.status(400).send({
+      message: "Failed to invite member due to SAML SSO configured for organization"
+    });
+  }
 
-			inviteeMembershipOrg = await MembershipOrg.findOne({
+  if (plan.memberLimit !== null) {
-				user: invitee._id,
+    // case: limit imposed on number of members allowed
-				organization: organizationId
-			});
 
-			if (inviteeMembershipOrg && inviteeMembershipOrg.status === ACCEPTED) {
+    if (plan.membersUsed >= plan.memberLimit) {
-				throw new Error(
+      // case: number of members used exceeds the number of members allowed
-					'Failed to invite an existing member of the organization'
+      return res.status(400).send({
-				);
+        message:
-			}
+          "Failed to invite member due to member limit reached. Upgrade plan to invite more members."
+      });
+    }
+  }
 
-			if (!inviteeMembershipOrg) {
+  const invitee = await User.findOne({
-				
+    email: inviteeEmail
-				await new MembershipOrg({
+  }).select("+publicKey");
-					user: invitee,
-					inviteEmail: inviteeEmail,
-					organization: organizationId,
-					role: MEMBER,
-					status: INVITED
-				}).save();
-			}
-		} else {
-			// check if invitee has been invited before
-			inviteeMembershipOrg = await MembershipOrg.findOne({
-				inviteEmail: inviteeEmail,
-				organization: organizationId
-			});
 
-			if (!inviteeMembershipOrg) {
+  if (invitee) {
-				// case: invitee has never been invited before
+    // case: invitee is an existing user
 
-				await new MembershipOrg({
+    inviteeMembershipOrg = await MembershipOrg.findOne({
-					inviteEmail: inviteeEmail,
+      user: invitee._id,
-					organization: organizationId,
+      organization: organizationId
-					role: MEMBER,
+    });
-					status: INVITED
-				}).save();
-			}
-		}
 
-		const organization = await Organization.findOne({ _id: organizationId });
+    if (inviteeMembershipOrg && inviteeMembershipOrg.status === ACCEPTED) {
+      throw new Error("Failed to invite an existing member of the organization");
+    }
 
-		if (organization) {
+    if (!inviteeMembershipOrg) {
+      await new MembershipOrg({
+        user: invitee,
+        inviteEmail: inviteeEmail,
+        organization: organizationId,
+        role: MEMBER,
+        status: INVITED
+      }).save();
+    }
+  } else {
+    // check if invitee has been invited before
+    inviteeMembershipOrg = await MembershipOrg.findOne({
+      inviteEmail: inviteeEmail,
+      organization: organizationId
+    });
 
-			const token = await TokenService.createToken({
+    if (!inviteeMembershipOrg) {
-				type: TOKEN_EMAIL_ORG_INVITATION,
+      // case: invitee has never been invited before
-				email: inviteeEmail,
-				organizationId: organization._id
-			});
 
-			await sendMail({
+      // validate that email is not disposable
-				template: 'organizationInvitation.handlebars',
+      validateUserEmail(inviteeEmail);
-				subjectLine: 'Infisical organization invitation',
-				recipients: [inviteeEmail],
-				substitutions: {
-					inviterFirstName: req.user.firstName,
-					inviterEmail: req.user.email,
-					organizationName: organization.name,
-					email: inviteeEmail,
-					organizationId: organization._id.toString(),
-					token,
-					callback_url: (await getSiteURL()) + '/signupinvite'
-				}
-			});
 
-			if (!(await getSmtpConfigured())) {
+      await new MembershipOrg({
-				completeInviteLink = `${siteUrl + '/signupinvite'}?token=${token}&to=${inviteeEmail}&organization_id=${organization._id}`
+        inviteEmail: inviteeEmail,
-			}
+        organization: organizationId,
-		}
+        role: MEMBER,
+        status: INVITED
+      }).save();
+    }
+  }
 
-		await updateSubscriptionOrgQuantity({ organizationId });
+  const organization = await Organization.findOne({ _id: organizationId });
-	} catch (err) {
-		Sentry.setUser(null);
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to send organization invite'
-		});
-	}
 
-	return res.status(200).send({
+  if (organization) {
-		message: `Sent an invite link to ${req.body.inviteeEmail}`,
+    const token = await TokenService.createToken({
-		completeInviteLink
+      type: TOKEN_EMAIL_ORG_INVITATION,
-	});
+      email: inviteeEmail,
+      organizationId: organization._id
+    });
+
+    await sendMail({
+      template: "organizationInvitation.handlebars",
+      subjectLine: "Infisical organization invitation",
+      recipients: [inviteeEmail],
+      substitutions: {
+        inviterFirstName: req.user.firstName,
+        inviterEmail: req.user.email,
+        organizationName: organization.name,
+        email: inviteeEmail,
+        organizationId: organization._id.toString(),
+        token,
+        callback_url: (await getSiteURL()) + "/signupinvite"
+      }
+    });
+
+    if (!(await getSmtpConfigured())) {
+      completeInviteLink = `${
+        siteUrl + "/signupinvite"
+      }?token=${token}&to=${inviteeEmail}&organization_id=${organization._id}`;
+    }
+  }
+
+  await updateSubscriptionOrgQuantity({ organizationId });
+
+  return res.status(200).send({
+    message: `Sent an invite link to ${req.body.inviteeEmail}`,
+    completeInviteLink
+  });
 };
 
 /**
@@ -216,74 +223,64 @@ export const inviteUserToOrganization = async (req: Request, res: Response) => {
  * @returns
  */
 export const verifyUserToOrganization = async (req: Request, res: Response) => {
-	let user, token;
+  let user;
-	try {
-		const {
-			email,
-			organizationId,
-			code
-		} = req.body;
 
-		user = await User.findOne({ email }).select('+publicKey');
+  const {
+    body: { organizationId, email, code }
+  } = await validateRequest(reqValidator.VerifyUserToOrgv1, req);
 
-		const membershipOrg = await MembershipOrg.findOne({
+  user = await User.findOne({ email }).select("+publicKey");
-			inviteEmail: email,
-			status: INVITED,
-			organization: new Types.ObjectId(organizationId)
-		});
 
-		if (!membershipOrg)
+  const membershipOrg = await MembershipOrg.findOne({
-			throw new Error('Failed to find any invitations for email');
+    inviteEmail: email,
+    status: INVITED,
+    organization: new Types.ObjectId(organizationId)
+  });
 
-		await TokenService.validateToken({
+  if (!membershipOrg) throw new Error("Failed to find any invitations for email");
-			type: TOKEN_EMAIL_ORG_INVITATION,
-			email,
-			organizationId: membershipOrg.organization,
-			token: code
-		});
 
-		if (user && user?.publicKey) {
+  await TokenService.validateToken({
-			// case: user has already completed account
+    type: TOKEN_EMAIL_ORG_INVITATION,
-			// membership can be approved and redirected to login/dashboard
+    email,
-			membershipOrg.status = ACCEPTED;
+    organizationId: membershipOrg.organization,
-			await membershipOrg.save();
+    token: code
-			
+  });
-			await updateSubscriptionOrgQuantity({
-				organizationId
-			});
 
-			return res.status(200).send({
+  if (user && user?.publicKey) {
-				message: 'Successfully verified email',
+    // case: user has already completed account
-				user,
+    // membership can be approved and redirected to login/dashboard
-			});
+    membershipOrg.status = ACCEPTED;
-		}
+    await membershipOrg.save();
 
-		if (!user) {
+    await updateSubscriptionOrgQuantity({
-			// initialize user account
+      organizationId
-			user = await new User({
+    });
-				email
-			}).save();
-		}
 
-		// generate temporary signup token
+    return res.status(200).send({
-		token = createToken({
+      message: "Successfully verified email",
-			payload: {
+      user
-				userId: user._id.toString()
+    });
-			},
+  }
-			expiresIn: await getJwtSignupLifetime(),
-			secret: await getJwtSignupSecret()
-		});
-	} catch (err) {
-		Sentry.setUser(null);
-		Sentry.captureException(err);
-		return res.status(400).send({
-			error: 'Failed email magic link verification for organization invitation'
-		});
-	}
 
-	return res.status(200).send({
+  if (!user) {
-		message: 'Successfully verified email',
+    // initialize user account
-		user,
+    user = await new User({
-		token
+      email
-	});
+    }).save();
+  }
+
+  // generate temporary signup token
+  const token = createToken({
+    payload: {
+      userId: user._id.toString()
+    },
+    expiresIn: await getJwtSignupLifetime(),
+    secret: await getJwtSignupSecret()
+  });
+
+  return res.status(200).send({
+    message: "Successfully verified email",
+    user,
+    token
+  });
 };

backend/src/controllers/v1/organizationController.ts

@@ -1,39 +1,37 @@
-import * as Sentry from '@sentry/node';
+import { Request, Response } from "express";
-import { Request, Response } from 'express';
-import Stripe from 'stripe';
 import {
-	Membership,
+  IncidentContactOrg,
-	MembershipOrg,
+  Membership,
-	Organization,
+  MembershipOrg,
-	Workspace,
+  Organization,
-	IncidentContactOrg
+  Workspace
-} from '../../models';
+} from "../../models";
-import { createOrganization as create } from '../../helpers/organization';
+import { createOrganization as create } from "../../helpers/organization";
-import { addMembershipsOrg } from '../../helpers/membershipOrg';
+import { addMembershipsOrg } from "../../helpers/membershipOrg";
-import { OWNER, ACCEPTED } from '../../variables';
+import { ACCEPTED, ADMIN } from "../../variables";
-import _ from 'lodash';
+import { getLicenseServerUrl, getSiteURL } from "../../config";
-import { getStripeSecretKey, getSiteURL } from '../../config';
+import { licenseServerKeyRequest } from "../../config/request";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/organization";
+import {
+  OrgPermissionActions,
+  OrgPermissionSubjects,
+  getUserOrgPermissions
+} from "../../ee/services/RoleService";
+import { OrganizationNotFoundError } from "../../utils/errors";
+import { ForbiddenError } from "@casl/ability";
 
 export const getOrganizations = async (req: Request, res: Response) => {
-	let organizations;
+  const organizations = (
-	try {
+    await MembershipOrg.find({
-		organizations = (
+      user: req.user._id,
-			await MembershipOrg.find({
+      status: ACCEPTED
-				user: req.user._id,
+    }).populate("organization")
-				status: ACCEPTED
+  ).map((m) => m.organization);
-			}).populate('organization')
-		).map((m) => m.organization);
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get organizations'
-		});
-	}
 
-	return res.status(200).send({
+  return res.status(200).send({
-		organizations
+    organizations
-	});
+  });
 };
 
 /**
@@ -44,37 +42,26 @@ export const getOrganizations = async (req: Request, res: Response) => {
  * @returns
  */
 export const createOrganization = async (req: Request, res: Response) => {
-	let organization;
+  const {
-	try {
+    body: { organizationName }
-		const { organizationName } = req.body;
+  } = await validateRequest(reqValidator.CreateOrgv1, req);
 
-		if (organizationName.length < 1) {
+  // create organization and add user as member
-			throw new Error('Organization names must be at least 1-character long');
+  const organization = await create({
-		}
+    email: req.user.email,
+    name: organizationName
+  });
 
-		// create organization and add user as member
+  await addMembershipsOrg({
-		organization = await create({
+    userIds: [req.user._id.toString()],
-			email: req.user.email,
+    organizationId: organization._id.toString(),
-			name: organizationName
+    roles: [ADMIN],
-		});
+    statuses: [ACCEPTED]
+  });
 
-		await addMembershipsOrg({
+  return res.status(200).send({
-			userIds: [req.user._id.toString()],
+    organization
-			organizationId: organization._id.toString(),
+  });
-			roles: [OWNER],
-			statuses: [ACCEPTED]
-		});
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to create organization'
-		});
-	}
-
-	return res.status(200).send({
-		organization
-	});
 };
 
 /**
@@ -84,20 +71,23 @@ export const createOrganization = async (req: Request, res: Response) => {
  * @returns
  */
 export const getOrganization = async (req: Request, res: Response) => {
-	let organization;
+  const {
-	try {
+    params: { organizationId }
-		organization = req.organization
+  } = await validateRequest(reqValidator.GetOrgv1, req);
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to find organization'
-		});
-	}
 
-	return res.status(200).send({
+  // ensure user has membership
-		organization
+  await getUserOrgPermissions(req.user._id, organizationId);
-	});
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  return res.status(200).send({
+    organization
+  });
 };
 
 /**
@@ -107,24 +97,23 @@ export const getOrganization = async (req: Request, res: Response) => {
  * @returns
  */
 export const getOrganizationMembers = async (req: Request, res: Response) => {
-	let users;
+  const {
-	try {
+    params: { organizationId }
-		const { organizationId } = req.params;
+  } = await validateRequest(reqValidator.GetOrgMembersv1, req);
 
-		users = await MembershipOrg.find({
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-			organization: organizationId
+  ForbiddenError.from(permission).throwUnlessCan(
-		}).populate('user', '+publicKey');
+    OrgPermissionActions.Read,
-	} catch (err) {
+    OrgPermissionSubjects.Member
-		Sentry.setUser({ email: req.user.email });
+  );
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get organization members'
-		});
-	}
 
-	return res.status(200).send({
+  const users = await MembershipOrg.find({
-		users
+    organization: organizationId
-	});
+  }).populate("user", "+publicKey");
+
+  return res.status(200).send({
+    users
+  });
 };
 
 /**
@@ -133,43 +122,39 @@ export const getOrganizationMembers = async (req: Request, res: Response) => {
  * @param res
  * @returns
  */
-export const getOrganizationWorkspaces = async (
+export const getOrganizationWorkspaces = async (req: Request, res: Response) => {
-	req: Request,
+  const {
-	res: Response
+    params: { organizationId }
-) => {
+  } = await validateRequest(reqValidator.GetOrgWorkspacesv1, req);
-	let workspaces;
-	try {
-		const { organizationId } = req.params;
 
-		const workspacesSet = new Set(
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-			(
+  ForbiddenError.from(permission).throwUnlessCan(
-				await Workspace.find(
+    OrgPermissionActions.Read,
-					{
+    OrgPermissionSubjects.Workspace
-						organization: organizationId
+  );
-					},
-					'_id'
-				)
-			).map((w) => w._id.toString())
-		);
 
-		workspaces = (
+  const workspacesSet = new Set(
-			await Membership.find({
+    (
-				user: req.user._id
+      await Workspace.find(
-			}).populate('workspace')
+        {
-		)
+          organization: organizationId
-			.filter((m) => workspacesSet.has(m.workspace._id.toString()))
+        },
-			.map((m) => m.workspace);
+        "_id"
-	} catch (err) {
+      )
-		Sentry.setUser({ email: req.user.email });
+    ).map((w) => w._id.toString())
-		Sentry.captureException(err);
+  );
-		return res.status(400).send({
-			message: 'Failed to get my workspaces'
-		});
-	}
 
-	return res.status(200).send({
+  const workspaces = (
-		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
+  });
 };
 
 /**
@@ -179,34 +164,33 @@ export const getOrganizationWorkspaces = async (
  * @returns
  */
 export const changeOrganizationName = async (req: Request, res: Response) => {
-	let organization;
+  const {
-	try {
+    params: { organizationId },
-		const { organizationId } = req.params;
+    body: { name }
-		const { name } = req.body;
+  } = await validateRequest(reqValidator.ChangeOrgNamev1, req);
 
-		organization = await Organization.findOneAndUpdate(
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-			{
+  ForbiddenError.from(permission).throwUnlessCan(
-				_id: organizationId
+    OrgPermissionActions.Edit,
-			},
+    OrgPermissionSubjects.Settings
-			{
+  );
-				name
-			},
-			{
-				new: true
-			}
-		);
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to change organization name'
-		});
-	}
 
-	return res.status(200).send({
+  const organization = await Organization.findOneAndUpdate(
-		message: 'Successfully changed organization name',
+    {
-		organization
+      _id: organizationId
-	});
+    },
+    {
+      name
+    },
+    {
+      new: true
+    }
+  );
+
+  return res.status(200).send({
+    message: "Successfully changed organization name",
+    organization
+  });
 };
 
 /**
@@ -215,28 +199,24 @@ export const changeOrganizationName = async (req: Request, res: Response) => {
  * @param res
  * @returns
  */
-export const getOrganizationIncidentContacts = async (
+export const getOrganizationIncidentContacts = async (req: Request, res: Response) => {
-	req: Request,
+  const {
-	res: Response
+    params: { organizationId }
-) => {
+  } = await validateRequest(reqValidator.GetOrgIncidentContactv1, req);
-	let incidentContactsOrg;
-	try {
-		const { organizationId } = req.params;
 
-		incidentContactsOrg = await IncidentContactOrg.find({
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-			organization: organizationId
+  ForbiddenError.from(permission).throwUnlessCan(
-		});
+    OrgPermissionActions.Read,
-	} catch (err) {
+    OrgPermissionSubjects.IncidentAccount
-		Sentry.setUser({ email: req.user.email });
+  );
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get organization incident contacts'
-		});
-	}
 
-	return res.status(200).send({
+  const incidentContactsOrg = await IncidentContactOrg.find({
-		incidentContactsOrg
+    organization: organizationId
-	});
+  });
+
+  return res.status(200).send({
+    incidentContactsOrg
+  });
 };
 
 /**
@@ -245,31 +225,27 @@ export const getOrganizationIncidentContacts = async (
  * @param res
  * @returns
  */
-export const addOrganizationIncidentContact = async (
+export const addOrganizationIncidentContact = async (req: Request, res: Response) => {
-	req: Request,
+  const {
-	res: Response
+    params: { organizationId },
-) => {
+    body: { email }
-	let incidentContactOrg;
+  } = await validateRequest(reqValidator.CreateOrgIncideContact, req);
-	try {
-		const { organizationId } = req.params;
-		const { email } = req.body;
 
-		incidentContactOrg = await IncidentContactOrg.findOneAndUpdate(
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-			{ email, organization: organizationId },
+  ForbiddenError.from(permission).throwUnlessCan(
-			{ email, organization: organizationId },
+    OrgPermissionActions.Create,
-			{ upsert: true, new: true }
+    OrgPermissionSubjects.IncidentAccount
-		);
+  );
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to add incident contact for organization'
-		});
-	}
 
-	return res.status(200).send({
+  const incidentContactOrg = await IncidentContactOrg.findOneAndUpdate(
-		incidentContactOrg
+    { email, organization: organizationId },
-	});
+    { email, organization: organizationId },
+    { upsert: true, new: true }
+  );
+
+  return res.status(200).send({
+    incidentContactOrg
+  });
 };
 
 /**
@@ -278,151 +254,137 @@ export const addOrganizationIncidentContact = async (
  * @param res
  * @returns
  */
-export const deleteOrganizationIncidentContact = async (
+export const deleteOrganizationIncidentContact = async (req: Request, res: Response) => {
-	req: Request,
+  const {
-	res: Response
+    params: { organizationId },
-) => {
+    body: { email }
-	let incidentContactOrg;
+  } = await validateRequest(reqValidator.DelOrgIncideContact, req);
-	try {
-		const { organizationId } = req.params;
-		const { email } = req.body;
 
-		incidentContactOrg = await IncidentContactOrg.findOneAndDelete({
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-			email,
+  ForbiddenError.from(permission).throwUnlessCan(
-			organization: organizationId
+    OrgPermissionActions.Delete,
-		});
+    OrgPermissionSubjects.IncidentAccount
-	} catch (err) {
+  );
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to delete organization incident contact'
-		});
-	}
 
-	return res.status(200).send({
+  const incidentContactOrg = await IncidentContactOrg.findOneAndDelete({
-		message: 'Successfully deleted organization incident contact',
+    email,
-		incidentContactOrg
+    organization: organizationId
-	});
+  });
+
+  return res.status(200).send({
+    message: "Successfully deleted organization incident contact",
+    incidentContactOrg
+  });
 };
 
 /**
- * Redirect user to (stripe) billing portal or add card page depending on
+ * Redirect user to billing portal or add card page depending on
  * if there is a card on file
  * @param req
  * @param res
  * @returns
  */
-export const createOrganizationPortalSession = async (
+export const createOrganizationPortalSession = async (req: Request, res: Response) => {
-	req: Request,
+  const {
-	res: Response
+    params: { organizationId }
-) => {
+  } = await validateRequest(reqValidator.GetOrgPlanBillingInfov1, req);
-	let session;
-	try {
-		const stripe = new Stripe(await getStripeSecretKey(), {
-			apiVersion: '2022-08-01'
-		});
 
-		// check if there is a payment method on file
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-		const paymentMethods = await stripe.paymentMethods.list({
+  ForbiddenError.from(permission).throwUnlessCan(
-			customer: req.organization.customerId,
+    OrgPermissionActions.Edit,
-			type: 'card'
+    OrgPermissionSubjects.Billing
-		});
+  );
-		
-		if (paymentMethods.data.length < 1) {
-			// case: no payment method on file
-			session = await stripe.checkout.sessions.create({
-				customer: req.organization.customerId,
-				mode: 'setup',
-				payment_method_types: ['card'],
-				success_url: (await getSiteURL()) + '/dashboard',
-				cancel_url: (await getSiteURL()) + '/dashboard'
-			});
-		} else {
-			session = await stripe.billingPortal.sessions.create({
-				customer: req.organization.customerId,
-				return_url: (await getSiteURL()) + '/dashboard'
-			});
-		}
 
-		return res.status(200).send({ url: session.url });
+  const organization = await Organization.findById(organizationId);
-	} catch (err) {
+  if (!organization) {
-		Sentry.setUser({ email: req.user.email });
+    throw OrganizationNotFoundError({
-		Sentry.captureException(err);
+      message: "Failed to find organization"
-		return res.status(400).send({
+    });
-			message: 'Failed to redirect to organization billing portal'
+  }
-		});
+
-	}
+  const {
+    data: { pmtMethods }
+  } = await licenseServerKeyRequest.get(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/billing-details/payment-methods`
+  );
+
+  if (pmtMethods.length < 1) {
+    // case: organization has no payment method on file
+    // -> redirect to add payment method portal
+    const {
+      data: { url }
+    } = await licenseServerKeyRequest.post(
+      `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+        organization.customerId
+      }/billing-details/payment-methods`,
+      {
+        success_url: (await getSiteURL()) + "/dashboard",
+        cancel_url: (await getSiteURL()) + "/dashboard"
+      }
+    );
+    return res.status(200).send({ url });
+  } else {
+    // case: organization has payment method on file
+    // -> redirect to billing portal
+    const {
+      data: { url }
+    } = await licenseServerKeyRequest.post(
+      `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+        organization.customerId
+      }/billing-details/billing-portal`,
+      {
+        return_url: (await getSiteURL()) + "/dashboard"
+      }
+    );
+    return res.status(200).send({ url });
+  }
 };
 
-/**
- * Return organization subscriptions
- * @param req
- * @param res
- * @returns
- */
-export const getOrganizationSubscriptions = async (
-	req: Request,
-	res: Response
-) => {
-	let subscriptions;
-	try {
-		const stripe = new Stripe(await getStripeSecretKey(), {
-			apiVersion: '2022-08-01'
-		});
-		
-		subscriptions = await stripe.subscriptions.list({
-			customer: req.organization.customerId
-		});
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get organization subscriptions'
-		});
-	}
-
-	return res.status(200).send({
-		subscriptions
-	});
-};
-
-
 /**
  * Given a org id, return the projects each member of the org belongs to
  * @param req
  * @param res
  * @returns
  */
-export const getOrganizationMembersAndTheirWorkspaces = async (
+export const getOrganizationMembersAndTheirWorkspaces = async (req: Request, res: Response) => {
-	req: Request,
+  const {
-	res: Response
+    params: { organizationId }
-) => {
+  } = await validateRequest(reqValidator.GetOrgMembersv1, req);
-	const { organizationId } = req.params;
 
-	const workspacesSet = (
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-			await Workspace.find(
+  ForbiddenError.from(permission).throwUnlessCan(
-				{
+    OrgPermissionActions.Read,
-					organization: organizationId
+    OrgPermissionSubjects.Member
-				},
+  );
-				'_id'
+  ForbiddenError.from(permission).throwUnlessCan(
-			)
+    OrgPermissionActions.Read,
-		).map((w) => w._id.toString());
+    OrgPermissionSubjects.Workspace
+  );
 
-	const memberships = (
+  const workspacesSet = (
-		await Membership.find({
+    await Workspace.find(
-			workspace: { $in: workspacesSet }
+      {
-		}).populate('workspace')
+        organization: organizationId
-	);
+      },
-	const userToWorkspaceIds: any = {};
+      "_id"
+    )
+  ).map((w) => w._id.toString());
 
-	memberships.forEach(membership => {
+  const memberships = await Membership.find({
-		const user = membership.user.toString();
+    workspace: { $in: workspacesSet }
-		if (userToWorkspaceIds[user]) {
+  }).populate("workspace");
-			userToWorkspaceIds[user].push(membership.workspace);
+  const userToWorkspaceIds: any = {};
-		} else {
-			userToWorkspaceIds[user] = [membership.workspace];
-		}
-	});
 
-	return res.json(userToWorkspaceIds);
+  memberships.forEach((membership) => {
-};
+    const user = membership.user.toString();
+    if (userToWorkspaceIds[user]) {
+      userToWorkspaceIds[user].push(membership.workspace);
+    } else {
+      userToWorkspaceIds[user] = [membership.workspace];
+    }
+  });
+
+  return res.json(userToWorkspaceIds);
+};

backend/src/controllers/v1/passwordController.ts

@@ -1,113 +1,105 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
 // eslint-disable-next-line @typescript-eslint/no-var-requires
-const jsrp = require('jsrp');
+const jsrp = require("jsrp");
-import * as bigintConversion from 'bigint-conversion';
+import * as bigintConversion from "bigint-conversion";
-import { User, BackupPrivateKey, LoginSRPDetail } from '../../models';
+import { BackupPrivateKey, LoginSRPDetail, User } from "../../models";
-import { createToken } from '../../helpers/auth';
+import { clearTokens, createToken, sendMail } from "../../helpers";
-import { sendMail } from '../../helpers/nodemailer';
+import { TokenService } from "../../services";
-import { TokenService } from '../../services';
+import { TOKEN_EMAIL_PASSWORD_RESET } from "../../variables";
-import { TOKEN_EMAIL_PASSWORD_RESET } from '../../variables';
+import { BadRequestError } from "../../utils/errors";
-import { BadRequestError } from '../../utils/errors';
+import {
-import { getSiteURL, getJwtSignupLifetime, getJwtSignupSecret } from '../../config';
+  getHttpsEnabled,
+  getJwtSignupLifetime,
+  getJwtSignupSecret,
+  getSiteURL
+} from "../../config";
+import { ActorType } from "../../ee/models";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/auth";
 
 /**
- * Password reset step 1: Send email verification link to email [email] 
+ * Password reset step 1: Send email verification link to email [email]
  * for account recovery.
  * @param req
  * @param res
  * @returns
  */
 export const emailPasswordReset = async (req: Request, res: Response) => {
-	let email: string;
+  const {
-	try {
+    body: { email }
-		email = req.body.email;
+  } = await validateRequest(reqValidator.EmailPasswordResetV1, req);
 
-		const user = await User.findOne({ email }).select('+publicKey');
+  const user = await User.findOne({ email }).select("+publicKey");
-		if (!user || !user?.publicKey) {
+  if (!user || !user?.publicKey) {
-			// case: user has already completed account
+    // case: user has already completed account
 
-			return res.status(403).send({
+    return res.status(200).send({
-				error: 'Failed to send email verification for password reset'
+      message: "If an account exists with this email, a password reset link has been sent"
-			});
+    });
-		}
+  }
-		
-		const token = await TokenService.createToken({
-			type: TOKEN_EMAIL_PASSWORD_RESET,
-			email
-		});
-		
-		await sendMail({
-			template: 'passwordReset.handlebars',
-			subjectLine: 'Infisical password reset',
-			recipients: [email],
-			substitutions: {
-				email,
-				token,
-				callback_url: (await getSiteURL()) + '/password-reset'
-			}
-		});
-	} catch (err) {
-		Sentry.setUser(null);
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to send email for account recovery'
-		});
-	}
 
-	return res.status(200).send({
+  const token = await TokenService.createToken({
-		message: `Sent an email for account recovery to ${email}`
+    type: TOKEN_EMAIL_PASSWORD_RESET,
-	});
+    email
-}
+  });
+
+  await sendMail({
+    template: "passwordReset.handlebars",
+    subjectLine: "Infisical password reset",
+    recipients: [email],
+    substitutions: {
+      email,
+      token,
+      callback_url: (await getSiteURL()) + "/password-reset"
+    }
+  });
+
+  return res.status(200).send({
+    message: "If an account exists with this email, a password reset link has been sent"
+  });
+};
 
 /**
  * Password reset step 2: Verify email verification link sent to email [email]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const emailPasswordResetVerify = async (req: Request, res: Response) => {
-	let user, token;
+  const {
-	try {
+    body: { email, code }
-		const { email, code } = req.body;
+  } = await validateRequest(reqValidator.EmailPasswordResetVerifyV1, req);
 
-		user = await User.findOne({ email }).select('+publicKey');
+  const user = await User.findOne({ email }).select("+publicKey");
-		if (!user || !user?.publicKey) {
+  if (!user || !user?.publicKey) {
-			// case: user doesn't exist with email [email] or 
+    // case: user doesn't exist with email [email] or
-			// hasn't even completed their account
+    // hasn't even completed their account
-			return res.status(403).send({
+    return res.status(403).send({
-				error: 'Failed email verification for password reset'
+      error: "Failed email verification for password reset"
-			});
+    });
-		}
+  }
-		
-		await TokenService.validateToken({
-			type: TOKEN_EMAIL_PASSWORD_RESET,
-			email,
-			token: code
-		});
 
-		// generate temporary password-reset token
+  await TokenService.validateToken({
-		token = createToken({
+    type: TOKEN_EMAIL_PASSWORD_RESET,
-			payload: {
+    email,
-				userId: user._id.toString()
+    token: code
-			},
+  });
-			expiresIn: await getJwtSignupLifetime(),
-			secret: await getJwtSignupSecret()
-		});
-	} catch (err) {
-		Sentry.setUser(null);
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed email verification for password reset'
-		});
-	}
 
-	return res.status(200).send({
+  // generate temporary password-reset token
-		message: 'Successfully verified email',
+  const token = createToken({
-		user,
+    payload: {
-		token
+      userId: user._id.toString()
-	});
+    },
-}
+    expiresIn: await getJwtSignupLifetime(),
+    secret: await getJwtSignupSecret()
+  });
+
+  return res.status(200).send({
+    message: "Successfully verified email",
+    user,
+    token
+  });
+};
 
 /**
  * Return [salt] and [serverPublicKey] as part of step 1 of SRP protocol
@@ -116,44 +108,43 @@ export const emailPasswordResetVerify = async (req: Request, res: Response) => {
  * @returns
  */
 export const srp1 = async (req: Request, res: Response) => {
-	// return salt, serverPublicKey as part of first step of SRP protocol
+  // return salt, serverPublicKey as part of first step of SRP protocol
-	try {
+  const {
-		const { clientPublicKey } = req.body;
+    body: { clientPublicKey }
-		const user = await User.findOne({
+  } = await validateRequest(reqValidator.Srp1V1, req);
-			email: req.user.email
-		}).select('+salt +verifier');
 
-		if (!user) throw new Error('Failed to find user');
+  const user = await User.findOne({
+    email: req.user.email
+  }).select("+salt +verifier");
 
-		const server = new jsrp.server();
+  if (!user) throw new Error("Failed to find user");
-		server.init(
-			{
-				salt: user.salt,
-				verifier: user.verifier
-			},
-			async () => {
-				// generate server-side public key
-				const serverPublicKey = server.getPublicKey();
 
-				await LoginSRPDetail.findOneAndReplace({ email: req.user.email }, {
+  const server = new jsrp.server();
-					email: req.user.email,
+  server.init(
-					clientPublicKey: clientPublicKey,
+    {
-					serverBInt: bigintConversion.bigintToBuf(server.bInt),
+      salt: user.salt,
-				}, { upsert: true, returnNewDocument: false })
+      verifier: user.verifier
+    },
+    async () => {
+      // generate server-side public key
+      const serverPublicKey = server.getPublicKey();
 
-				return res.status(200).send({
+      await LoginSRPDetail.findOneAndReplace(
-					serverPublicKey,
+        { email: req.user.email },
-					salt: user.salt
+        {
-				});
+          email: req.user.email,
-			}
+          clientPublicKey: clientPublicKey,
-		);
+          serverBInt: bigintConversion.bigintToBuf(server.bInt)
-	} catch (err) {
+        },
-		Sentry.setUser({ email: req.user.email });
+        { upsert: true, returnNewDocument: false }
-		Sentry.captureException(err);
+      );
-		return res.status(400).send({
+
-			error: 'Failed to start change password process'
+      return res.status(200).send({
-		});
+        serverPublicKey,
-	}
+        salt: user.salt
+      });
+    }
+  );
 };
 
 /**
@@ -165,80 +156,91 @@ export const srp1 = async (req: Request, res: Response) => {
  * @returns
  */
 export const changePassword = async (req: Request, res: Response) => {
-	try {
+  const {
-		const { 
+    body: {
-			clientProof, 
+      clientProof,
-			protectedKey,
+      protectedKey,
-			protectedKeyIV,
+      protectedKeyIV,
-			protectedKeyTag,
+      protectedKeyTag,
-			encryptedPrivateKey,
+      encryptedPrivateKey,
-			encryptedPrivateKeyIV,
+      encryptedPrivateKeyIV,
-			encryptedPrivateKeyTag,
+      encryptedPrivateKeyTag,
-			salt,
+      salt,
-			verifier
+      verifier
-		} = req.body;
+    }
+  } = await validateRequest(reqValidator.ChangePasswordV1, req);
 
-		const user = await User.findOne({
+  const user = await User.findOne({
-			email: req.user.email
+    email: req.user.email
-		}).select('+salt +verifier');
+  }).select("+salt +verifier");
 
-		if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
-		const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: req.user.email })
+  const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: req.user.email });
 
-		if (!loginSRPDetailFromDB) {
+  if (!loginSRPDetailFromDB) {
-			return BadRequestError(Error("It looks like some details from the first login are not found. Please try login one again"))
+    return BadRequestError(
-		}
+      Error(
+        "It looks like some details from the first login are not found. Please try login one again"
+      )
+    );
+  }
 
-		const server = new jsrp.server();
+  const server = new jsrp.server();
-		server.init(
+  server.init(
-			{
+    {
-				salt: user.salt,
+      salt: user.salt,
-				verifier: user.verifier,
+      verifier: user.verifier,
-				b: loginSRPDetailFromDB.serverBInt
+      b: loginSRPDetailFromDB.serverBInt
-			},
+    },
-			async () => {
+    async () => {
-				server.setClientPublicKey(loginSRPDetailFromDB.clientPublicKey);
+      server.setClientPublicKey(loginSRPDetailFromDB.clientPublicKey);
 
-				// compare server and client shared keys
+      // compare server and client shared keys
-				if (server.checkClientProof(clientProof)) {
+      if (server.checkClientProof(clientProof)) {
-					// change password
+        // change password
 
-					await User.findByIdAndUpdate(
+        await User.findByIdAndUpdate(
-						req.user._id.toString(),
+          req.user._id.toString(),
-						{
+          {
-							encryptionVersion: 2,
+            encryptionVersion: 2,
-							protectedKey,
+            protectedKey,
-							protectedKeyIV,
+            protectedKeyIV,
-							protectedKeyTag,
+            protectedKeyTag,
-							encryptedPrivateKey,
+            encryptedPrivateKey,
-							iv: encryptedPrivateKeyIV,
+            iv: encryptedPrivateKeyIV,
-							tag: encryptedPrivateKeyTag,
+            tag: encryptedPrivateKeyTag,
-							salt,
+            salt,
-							verifier
+            verifier
-						},
+          },
-						{
+          {
-							new: true
+            new: true
-						}
+          }
-					);
+        );
 
-					return res.status(200).send({
+        if (req.authData.actor.type === ActorType.USER && req.authData.tokenVersionId) {
-						message: 'Successfully changed password'
+          await clearTokens(req.authData.tokenVersionId);
-					});
+        }
-				}
 
-				return res.status(400).send({
+        // clear httpOnly cookie
-					error: 'Failed to change password. Try again?'
+
-				});
+        res.cookie("jid", "", {
-			}
+          httpOnly: true,
-		);
+          path: "/",
-	} catch (err) {
+          sameSite: "strict",
-		Sentry.setUser({ email: req.user.email });
+          secure: (await getHttpsEnabled()) as boolean
-		Sentry.captureException(err);
+        });
-		return res.status(400).send({
+
-			error: 'Failed to change password. Try again?'
+        return res.status(200).send({
-		});
+          message: "Successfully changed password"
-	}
+        });
+      }
+
+      return res.status(400).send({
+        error: "Failed to change password. Try again?"
+      });
+    }
+  );
 };
 
 /**
@@ -248,141 +250,120 @@ export const changePassword = async (req: Request, res: Response) => {
  * @returns
  */
 export const createBackupPrivateKey = async (req: Request, res: Response) => {
-	// create/change backup private key
+  // create/change backup private key
-	// requires verifying [clientProof] as part of second step of SRP protocol
+  // requires verifying [clientProof] as part of second step of SRP protocol
-	// as initiated in /srp1
+  // as initiated in /srp1
+  const {
+    body: { clientProof, encryptedPrivateKey, salt, verifier, iv, tag }
+  } = await validateRequest(reqValidator.CreateBackupPrivateKeyV1, req);
+  const user = await User.findOne({
+    email: req.user.email
+  }).select("+salt +verifier");
 
-	try {
+  if (!user) throw new Error("Failed to find user");
-		const { clientProof, encryptedPrivateKey, iv, tag, salt, verifier } =
-			req.body;
-		const user = await User.findOne({
-			email: req.user.email
-		}).select('+salt +verifier');
 
-		if (!user) throw new Error('Failed to find user');
+  const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: req.user.email });
 
-		const loginSRPDetailFromDB = await LoginSRPDetail.findOneAndDelete({ email: req.user.email })
+  if (!loginSRPDetailFromDB) {
+    return BadRequestError(
+      Error(
+        "It looks like some details from the first login are not found. Please try login one again"
+      )
+    );
+  }
 
-		if (!loginSRPDetailFromDB) {
+  const server = new jsrp.server();
-			return BadRequestError(Error("It looks like some details from the first login are not found. Please try login one again"))
+  server.init(
-		}
+    {
+      salt: user.salt,
+      verifier: user.verifier,
+      b: loginSRPDetailFromDB.serverBInt
+    },
+    async () => {
+      server.setClientPublicKey(loginSRPDetailFromDB.clientPublicKey);
 
-		const server = new jsrp.server();
+      // compare server and client shared keys
-		server.init(
+      if (server.checkClientProof(clientProof)) {
-			{
+        // create new or replace backup private key
-				salt: user.salt,
-				verifier: user.verifier,
-				b: loginSRPDetailFromDB.serverBInt
-			},
-			async () => {
-				server.setClientPublicKey(
-					loginSRPDetailFromDB.clientPublicKey
-				);
 
-				// compare server and client shared keys
+        const backupPrivateKey = await BackupPrivateKey.findOneAndUpdate(
-				if (server.checkClientProof(clientProof)) {
+          { user: req.user._id },
-					// create new or replace backup private key
+          {
+            user: req.user._id,
+            encryptedPrivateKey,
+            iv,
+            tag,
+            salt,
+            verifier
+          },
+          { upsert: true, new: true }
+        ).select("+user, encryptedPrivateKey");
 
-					const backupPrivateKey = await BackupPrivateKey.findOneAndUpdate(
+        // issue tokens
-						{ user: req.user._id },
+        return res.status(200).send({
-						{
+          message: "Successfully updated backup private key",
-							user: req.user._id,
+          backupPrivateKey
-							encryptedPrivateKey,
+        });
-							iv,
+      }
-							tag,
-							salt,
-							verifier
-						},
-						{ upsert: true, new: true }
-					).select('+user, encryptedPrivateKey');
 
-					// issue tokens
+      return res.status(400).send({
-					return res.status(200).send({
+        message: "Failed to update backup private key"
-						message: 'Successfully updated backup private key',
+      });
-						backupPrivateKey
+    }
-					});
+  );
-				}
-
-				return res.status(400).send({
-					message: 'Failed to update backup private key'
-				});
-			}
-		);
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to update backup private key'
-		});
-	}
 };
 
 /**
  * Return backup private key for user
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const getBackupPrivateKey = async (req: Request, res: Response) => {
-	let backupPrivateKey;
+  const backupPrivateKey = await BackupPrivateKey.findOne({
-	try {
+    user: req.user._id
-		backupPrivateKey = await BackupPrivateKey.findOne({
+  }).select("+encryptedPrivateKey +iv +tag");
-			user: req.user._id
-		}).select('+encryptedPrivateKey +iv +tag');
 
-		if (!backupPrivateKey) throw new Error('Failed to find backup private key');
+  if (!backupPrivateKey) throw new Error("Failed to find backup private key");
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get backup private key'
-		});
-	}
 
-	return res.status(200).send({
+  return res.status(200).send({
-		backupPrivateKey
+    backupPrivateKey
-	});
+  });
-}
+};
 
 export const resetPassword = async (req: Request, res: Response) => {
-	try {
+  const {
-		const {
+    body: {
-			protectedKey,
+      encryptedPrivateKey,
-			protectedKeyIV,
+      protectedKeyTag,
-			protectedKeyTag,
+      protectedKey,
-			encryptedPrivateKey,
+      protectedKeyIV,
-			encryptedPrivateKeyIV,
+      salt,
-			encryptedPrivateKeyTag,
+      verifier,
-			salt,
+      encryptedPrivateKeyIV,
-			verifier,
+      encryptedPrivateKeyTag
-		} = req.body;
+    }
+  } = await validateRequest(reqValidator.ResetPasswordV1, req);
 
-		await User.findByIdAndUpdate(
+  await User.findByIdAndUpdate(
-			req.user._id.toString(),
+    req.user._id.toString(),
-			{
+    {
-				encryptionVersion: 2,
+      encryptionVersion: 2,
-				protectedKey,
+      protectedKey,
-				protectedKeyIV,
+      protectedKeyIV,
-				protectedKeyTag,	
+      protectedKeyTag,
-				encryptedPrivateKey,
+      encryptedPrivateKey,
-				iv: encryptedPrivateKeyIV,
+      iv: encryptedPrivateKeyIV,
-				tag: encryptedPrivateKeyTag,
+      tag: encryptedPrivateKeyTag,
-				salt,
+      salt,
-				verifier
+      verifier
-			},
+    },
-			{
+    {
-				new: true
+      new: true
-			}
+    }
-		);
+  );
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get backup private key'
-		});
-	}
 
-	return res.status(200).send({
+  return res.status(200).send({
-		message: 'Successfully reset password'
+    message: "Successfully reset password"
-	});
+  });
-}
+};

backend/src/controllers/v1/secretController.ts

@@ -1,31 +1,30 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
+import { Types } from "mongoose";
-import { Types } from 'mongoose';
+import { Key } from "../../models";
-import { Key, Secret } from '../../models';
 import {
-	v1PushSecrets as push,
+  pullSecrets as pull,
-	pullSecrets as pull,
+  v1PushSecrets as push,
-	reformatPullSecrets
+  reformatPullSecrets
-} from '../../helpers/secret';
+} from "../../helpers/secret";
-import { pushKeys } from '../../helpers/key';
+import { pushKeys } from "../../helpers/key";
-import { eventPushSecrets } from '../../events';
+import { eventPushSecrets } from "../../events";
-import { EventService } from '../../services';
+import { EventService } from "../../services";
-import { TelemetryService } from '../../services';
+import { TelemetryService } from "../../services";
 
 interface PushSecret {
-	ciphertextKey: string;
+  ciphertextKey: string;
-	ivKey: string;
+  ivKey: string;
-	tagKey: string;
+  tagKey: string;
-	hashKey: string;
+  hashKey: string;
-	ciphertextValue: string;
+  ciphertextValue: string;
-	ivValue: string;
+  ivValue: string;
-	tagValue: string;
+  tagValue: string;
-	hashValue: string;
+  hashValue: string;
-	ciphertextComment: string;
+  ciphertextComment: string;
-	ivComment: string;
+  ivComment: string;
-	tagComment: string;
+  tagComment: string;
-	hashComment: string;
+  hashComment: string;
-	type: 'shared' | 'personal';
+  type: "shared" | "personal";
 }
 
 /**
@@ -36,71 +35,59 @@ interface PushSecret {
  * @returns
  */
 export const pushSecrets = async (req: Request, res: Response) => {
-	// upload (encrypted) secrets to workspace with id [workspaceId]
+  // upload (encrypted) secrets to workspace with id [workspaceId]
+  const postHogClient = await TelemetryService.getPostHogClient();
+  let { secrets }: { secrets: PushSecret[] } = req.body;
+  const { keys, environment, channel } = req.body;
+  const { workspaceId } = req.params;
 
-	try {
+  // validate environment
-		const postHogClient = await TelemetryService.getPostHogClient();
+  const workspaceEnvs = req.membership.workspace.environments;
-		let { secrets }: { secrets: PushSecret[] } = req.body;
+  if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-		const { keys, environment, channel } = req.body;
+    throw new Error("Failed to validate environment");
-		const { workspaceId } = req.params;
+  }
 
-		// validate environment
+  // sanitize secrets
-		const workspaceEnvs = req.membership.workspace.environments;
+  secrets = secrets.filter((s: PushSecret) => s.ciphertextKey !== "" && s.ciphertextValue !== "");
-		if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-			throw new Error('Failed to validate environment');
-		}
 
-		// sanitize secrets
+  await push({
-		secrets = secrets.filter(
+    userId: req.user._id,
-			(s: PushSecret) => s.ciphertextKey !== '' && s.ciphertextValue !== ''
+    workspaceId,
-		);
+    environment,
+    secrets
+  });
 
-		await push({
+  await pushKeys({
-			userId: req.user._id,
+    userId: req.user._id,
-			workspaceId,
+    workspaceId,
-			environment,
+    keys
-			secrets
+  });
-		});
 
-		await pushKeys({
+  if (postHogClient) {
-			userId: req.user._id,
+    postHogClient.capture({
-			workspaceId,
+      event: "secrets pushed",
-			keys
+      distinctId: req.user.email,
-		});
+      properties: {
-		
+        numberOfSecrets: secrets.length,
-		
+        environment,
-		if (postHogClient) {
+        workspaceId,
-			postHogClient.capture({
+        channel: channel ? channel : "cli"
-				event: 'secrets pushed',
+      }
-				distinctId: req.user.email,
+    });
-				properties: {
+  }
-					numberOfSecrets: secrets.length,
-					environment,
-					workspaceId,
-					channel: channel ? channel : 'cli'
-				}
-			});
-		}
 
-		// trigger event - push secrets
+  // trigger event - push secrets
-		EventService.handleEvent({
+  EventService.handleEvent({
-			event: eventPushSecrets({
+    event: eventPushSecrets({
-				workspaceId: new Types.ObjectId(workspaceId),
+      workspaceId: new Types.ObjectId(workspaceId),
-				environment
+      environment,
-			})
+      secretPath: "/"
-		});
+    })
+  });
 
-	} catch (err) {
+  return res.status(200).send({
-		Sentry.setUser({ email: req.user.email });
+    message: "Successfully uploaded workspace secrets"
-		Sentry.captureException(err);
+  });
-		return res.status(400).send({
-			message: 'Failed to upload workspace secrets'
-		});
-	}
-
-	return res.status(200).send({
-		message: 'Successfully uploaded workspace secrets'
-	});
 };
 
 /**
@@ -111,64 +98,56 @@ export const pushSecrets = async (req: Request, res: Response) => {
  * @returns
  */
 export const pullSecrets = async (req: Request, res: Response) => {
-	let secrets;
+  let secrets;
-	let key;
-	try {
-		const postHogClient = await TelemetryService.getPostHogClient();
-		const environment: string = req.query.environment as string;
-		const channel: string = req.query.channel as string;
-		const { workspaceId } = req.params;
 
-		// validate environment
+  const postHogClient = await TelemetryService.getPostHogClient();
-		const workspaceEnvs = req.membership.workspace.environments;
+  const environment: string = req.query.environment as string;
-		if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
+  const channel: string = req.query.channel as string;
-			throw new Error('Failed to validate environment');
+  const { workspaceId } = req.params;
-		}
 
-		secrets = await pull({
+  // validate environment
-			userId: req.user._id.toString(),
+  const workspaceEnvs = req.membership.workspace.environments;
-			workspaceId,
+  if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-			environment,
+    throw new Error("Failed to validate environment");
-			channel: channel ? channel : 'cli',
+  }
-			ipAddress: req.ip
-		});
 
-		key = await Key.findOne({
+  secrets = await pull({
-			workspace: workspaceId,
+    userId: req.user._id.toString(),
-			receiver: req.user._id
+    workspaceId,
-		})
+    environment,
-			.sort({ createdAt: -1 })
+    channel: channel ? channel : "cli",
-			.populate('sender', '+publicKey');
+    ipAddress: req.realIP
-		
+  });
-		if (channel !== 'cli') {
-			secrets = reformatPullSecrets({ secrets });
-		}
 
-		if (postHogClient) {
+  const key = await Key.findOne({
-			// capture secrets pushed event in production
+    workspace: workspaceId,
-			postHogClient.capture({
+    receiver: req.user._id
-				distinctId: req.user.email,
+  })
-				event: 'secrets pulled',
+    .sort({ createdAt: -1 })
-				properties: {
+    .populate("sender", "+publicKey");
-					numberOfSecrets: secrets.length,
-					environment,
-					workspaceId,
-					channel: channel ? channel : 'cli'
-				}
-			});
-		}
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to pull workspace secrets'
-		});
-	}
 
-	return res.status(200).send({
+  if (channel !== "cli") {
-		secrets,
+    secrets = reformatPullSecrets({ secrets });
-		key
+  }
-	});
+
+  if (postHogClient) {
+    // capture secrets pushed event in production
+    postHogClient.capture({
+      distinctId: req.user.email,
+      event: "secrets pulled",
+      properties: {
+        numberOfSecrets: secrets.length,
+        environment,
+        workspaceId,
+        channel: channel ? channel : "cli"
+      }
+    });
+  }
+
+  return res.status(200).send({
+    secrets,
+    key
+  });
 };
 
 /**
@@ -180,61 +159,51 @@ export const pullSecrets = async (req: Request, res: Response) => {
  * @returns
  */
 export const pullSecretsServiceToken = async (req: Request, res: Response) => {
-	let secrets;
+  const postHogClient = await TelemetryService.getPostHogClient();
-	let key;
+  const environment: string = req.query.environment as string;
-	try {
+  const channel: string = req.query.channel as string;
-		const postHogClient = await TelemetryService.getPostHogClient();
+  const { workspaceId } = req.params;
-		const environment: string = req.query.environment as string;
-		const channel: string = req.query.channel as string;
-		const { workspaceId } = req.params;
 
-		// validate environment
+  // validate environment
-		const workspaceEnvs = req.membership.workspace.environments;
+  const workspaceEnvs = req.membership.workspace.environments;
-		if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
+  if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-			throw new Error('Failed to validate environment');
+    throw new Error("Failed to validate environment");
-		}
+  }
 
-		secrets = await pull({
+  const secrets = await pull({
-			userId: req.serviceToken.user._id.toString(),
+    userId: req.serviceToken.user._id.toString(),
-			workspaceId,
+    workspaceId,
-			environment,
+    environment,
-			channel: 'cli',
+    channel: "cli",
-			ipAddress: req.ip
+    ipAddress: req.realIP
-		});
+  });
 
-		key = {
+  const key = {
-			encryptedKey: req.serviceToken.encryptedKey,
+    encryptedKey: req.serviceToken.encryptedKey,
-			nonce: req.serviceToken.nonce,
+    nonce: req.serviceToken.nonce,
-			sender: {
+    sender: {
-				publicKey: req.serviceToken.publicKey
+      publicKey: req.serviceToken.publicKey
-			},
+    },
-			receiver: req.serviceToken.user,
+    receiver: req.serviceToken.user,
-			workspace: req.serviceToken.workspace
+    workspace: req.serviceToken.workspace
-		};
+  };
 
-		if (postHogClient) {
+  if (postHogClient) {
-			// capture secrets pulled event in production
+    // capture secrets pulled event in production
-			postHogClient.capture({
+    postHogClient.capture({
-				distinctId: req.serviceToken.user.email,
+      distinctId: req.serviceToken.user.email,
-				event: 'secrets pulled',
+      event: "secrets pulled",
-				properties: {
+      properties: {
-					numberOfSecrets: secrets.length,
+        numberOfSecrets: secrets.length,
-					environment,
+        environment,
-					workspaceId,
+        workspaceId,
-					channel: channel ? channel : 'cli'
+        channel: channel ? channel : "cli"
-				}
+      }
-			});
+    });
-		}
+  }
-	} catch (err) {
-		Sentry.setUser({ email: req.serviceToken.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to pull workspace secrets'
-		});
-	}
 
-	return res.status(200).send({
+  return res.status(200).send({
-		secrets: reformatPullSecrets({ secrets }),
+    secrets: reformatPullSecrets({ secrets }),
-		key
+    key
-	});
+  });
-};
+};

backend/src/controllers/v1/secretImpsController.ts

@@ -0,0 +1,706 @@
+import { Request, Response } from "express";
+import { isValidScope } from "../../helpers";
+import { Folder, IServiceTokenData, SecretImport, ServiceTokenData } from "../../models";
+import { getAllImportedSecrets } from "../../services/SecretImportService";
+import { getFolderWithPathFromId } from "../../services/FolderService";
+import {
+  BadRequestError,
+  ResourceNotFoundError,
+  UnauthorizedRequestError
+} from "../../utils/errors";
+import { EEAuditLogService } from "../../ee/services";
+import { EventType } from "../../ee/models";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/secretImports";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  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 a new secret import for a specified workspace and environment'
+
+    #swagger.requestBody = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "workspaceId": {
+                            "type": "string",
+                            "description": "ID of the workspace where the secret import will be created",
+                            "example": "someWorkspaceId"
+                        },
+                        "environment": {
+                            "type": "string",
+                            "description": "Environment to import to",
+                            "example": "production"
+                        },
+                        "folderId": {
+                            "type": "string",
+                            "description": "Folder ID. Use root for the root folder.",
+                            "example": "my_folder"
+                        },
+                        "secretImport": {
+                            "type": "object",
+                            "properties": {
+                              "environment": {
+                                "type": "string",
+                                "description": "Import from environment",
+                                "example": "development"
+                              },
+                              "secretPath": {
+                                "type": "string",
+                                "description": "Import from secret path",
+                                "example": "/user/oauth"
+                              }
+                            }
+                        }
+                    },
+                    "required": ["workspaceId", "environment", "folderName"]
+                }
+            }
+        }
+    }
+
+    #swagger.responses[200] = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "message": {
+                            "type": "string",
+                            "example": "successfully created secret import"
+                        }
+                    },
+                    "description": "Confirmation of secret import creation"
+                }
+            }
+        }
+    }
+    #swagger.responses[400] = {
+        description: "Bad Request. For example, 'Secret import already exist'"
+    }
+    #swagger.responses[401] = {
+        description: "Unauthorized request. For example, 'Folder Permission Denied'"
+    }
+    #swagger.responses[404] = {
+        description: "Resource Not Found. For example, 'Failed to find folder'"
+    }   
+  */
+
+  const {
+    body: { workspaceId, environment, folderId, secretImport }
+  } = await validateRequest(reqValidator.CreateSecretImportV1, req);
+
+  const folders = await Folder.findOne({
+    workspace: workspaceId,
+    environment
+  }).lean();
+
+  if (!folders && folderId !== "root") {
+    throw ResourceNotFoundError({
+      message: "Failed to find folder"
+    });
+  }
+
+  let secretPath = "/";
+  if (folders) {
+    const { folderPath } = getFolderWithPathFromId(folders.nodes, folderId);
+    secretPath = folderPath;
+  }
+
+  if (req.authData.authPayload instanceof ServiceTokenData) {
+    // root check
+    let isValidScopeAccess = isValidScope(req.authData.authPayload, environment, secretPath);
+    if (!isValidScopeAccess) {
+      throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+    }
+    isValidScopeAccess = isValidScope(
+      req.authData.authPayload,
+      secretImport.environment,
+      secretImport.secretPath
+    );
+    if (!isValidScopeAccess) {
+      throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+    }
+  } else {
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Create,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Read,
+      subject(ProjectPermissionSub.Secrets, {
+        environment: secretImport.environment,
+        secretPath: secretImport.secretPath
+      })
+    );
+  }
+
+  const importSecDoc = await SecretImport.findOne({
+    workspace: workspaceId,
+    environment,
+    folderId
+  });
+
+  const importToSecretPath = folders
+    ? getFolderWithPathFromId(folders.nodes, folderId).folderPath
+    : "/";
+
+  if (!importSecDoc) {
+    const doc = new SecretImport({
+      workspace: workspaceId,
+      environment,
+      folderId,
+      imports: [{ environment: secretImport.environment, secretPath: secretImport.secretPath }]
+    });
+
+    await doc.save();
+    await EEAuditLogService.createAuditLog(
+      req.authData,
+      {
+        type: EventType.CREATE_SECRET_IMPORT,
+        metadata: {
+          secretImportId: doc._id.toString(),
+          folderId: doc.folderId.toString(),
+          importFromEnvironment: secretImport.environment,
+          importFromSecretPath: secretImport.secretPath,
+          importToEnvironment: environment,
+          importToSecretPath
+        }
+      },
+      {
+        workspaceId: doc.workspace
+      }
+    );
+    return res.status(200).json({ message: "successfully created secret import" });
+  }
+
+  const doesImportExist = importSecDoc.imports.find(
+    (el) => el.environment === secretImport.environment && el.secretPath === secretImport.secretPath
+  );
+  if (doesImportExist) {
+    throw BadRequestError({ message: "Secret import already exist" });
+  }
+
+  importSecDoc.imports.push({
+    environment: secretImport.environment,
+    secretPath: secretImport.secretPath
+  });
+  await importSecDoc.save();
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.CREATE_SECRET_IMPORT,
+      metadata: {
+        secretImportId: importSecDoc._id.toString(),
+        folderId: importSecDoc.folderId.toString(),
+        importFromEnvironment: secretImport.environment,
+        importFromSecretPath: secretImport.secretPath,
+        importToEnvironment: environment,
+        importToSecretPath
+      }
+    },
+    {
+      workspaceId: importSecDoc.workspace
+    }
+  );
+  return res.status(200).json({ message: "successfully created secret import" });
+};
+
+// to keep the ordering, you must pass all the imports in here not the only updated one
+// this is because the order decide which import gets overriden
+
+/**
+ * Update secret import
+ * @param req
+ * @param res
+ * @returns
+ */
+export const updateSecretImport = async (req: Request, res: Response) => {
+  /*
+    #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 the secret import to be updated',
+        required: true,
+        type: 'string',
+        example: 'import12345'
+    }
+
+    #swagger.requestBody = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "secretImports": {
+                            "type": "array",
+                            "description": "List of new secret imports",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "environment": {
+                                        "type": "string",
+                                        "description": "Environment of the secret import",
+                                        "example": "production"
+                                    },
+                                    "secretPath": {
+                                        "type": "string",
+                                        "description": "Path of the secret import",
+                                        "example": "/path/to/secret"
+                                    }
+                                },
+                                "required": ["environment", "secretPath"]
+                            }
+                        }
+                    },
+                    "required": ["secretImports"]
+                }
+            }
+        }
+    }
+
+    #swagger.responses[200] = {
+        description: 'Successfully updated the secret import',
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "message": {
+                            "type": "string",
+                            "example": "successfully updated secret import"
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #swagger.responses[400] = {
+        description: 'Bad Request - Import not found',
+    }
+
+    #swagger.responses[403] = {
+        description: 'Forbidden access due to insufficient permissions',
+    }
+
+    #swagger.responses[401] = {
+        description: 'Unauthorized access due to invalid token or scope',
+    }
+  */
+  const {
+    body: { secretImports },
+    params: { id }
+  } = await validateRequest(reqValidator.UpdateSecretImportV1, req);
+
+  const importSecDoc = await SecretImport.findById(id);
+  if (!importSecDoc) {
+    throw BadRequestError({ message: "Import not found" });
+  }
+
+  // check for service token validity
+  const folders = await Folder.findOne({
+    workspace: importSecDoc.workspace,
+    environment: importSecDoc.environment
+  }).lean();
+
+  let secretPath = "/";
+  if (folders) {
+    const { folderPath } = getFolderWithPathFromId(folders.nodes, importSecDoc.folderId);
+    secretPath = folderPath;
+  }
+
+  if (req.authData.authPayload instanceof ServiceTokenData) {
+    // token permission check
+    const isValidScopeAccess = isValidScope(
+      req.authData.authPayload,
+      importSecDoc.environment,
+      secretPath
+    );
+    if (!isValidScopeAccess) {
+      throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+    }
+  } else {
+    // non token entry check
+    const { permission } = await getUserProjectPermissions(
+      req.user._id,
+      importSecDoc.workspace.toString()
+    );
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Edit,
+      subject(ProjectPermissionSub.Secrets, {
+        environment: importSecDoc.environment,
+        secretPath
+      })
+    );
+  }
+
+  const orderBefore = importSecDoc.imports;
+  importSecDoc.imports = secretImports;
+
+  await importSecDoc.save();
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.UPDATE_SECRET_IMPORT,
+      metadata: {
+        importToEnvironment: importSecDoc.environment,
+        importToSecretPath: secretPath,
+        secretImportId: importSecDoc._id.toString(),
+        folderId: importSecDoc.folderId.toString(),
+        orderBefore,
+        orderAfter: secretImports
+      }
+    },
+    {
+      workspaceId: importSecDoc.workspace
+    }
+  );
+  return res.status(200).json({ message: "successfully updated secret import" });
+};
+
+/**
+ * Delete secret import
+ * @param req
+ * @param res
+ * @returns
+ */
+export const deleteSecretImport = async (req: Request, res: Response) => {
+  /* 
+    #swagger.summary = 'Delete secret import'
+    #swagger.description = 'Delete secret import'
+
+    #swagger.parameters['id'] = {
+        in: 'path',
+        description: 'ID of the secret import',
+        required: true,
+        type: 'string',
+        example: '12345abcde'
+    }
+
+    #swagger.requestBody = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "secretImportEnv": {
+                            "type": "string",
+                            "description": "Import from environment",
+                            "example": "someWorkspaceId"
+                        },
+                        "secretImportPath": {
+                            "type": "string",
+                            "description": "Import from secret path",
+                            "example": "production"
+                        }
+                    },
+                    "required": ["id", "secretImportEnv", "secretImportPath"]
+                }
+            }
+        }
+    }
+
+    #swagger.responses[200] = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "message": {
+                            "type": "string",
+                            "example": "successfully delete secret import"
+                        }
+                    },
+                    "description": "Confirmation of secret import deletion"
+                }
+            }
+        }
+    }
+  */
+  const {
+    params: { id },
+    body: { secretImportEnv, secretImportPath }
+  } = await validateRequest(reqValidator.DeleteSecretImportV1, req);
+
+  const importSecDoc = await SecretImport.findById(id);
+  if (!importSecDoc) {
+    throw BadRequestError({ message: "Import not found" });
+  }
+
+  // check for service token validity
+  const folders = await Folder.findOne({
+    workspace: importSecDoc.workspace,
+    environment: importSecDoc.environment
+  }).lean();
+
+  let secretPath = "/";
+  if (folders) {
+    const { folderPath } = getFolderWithPathFromId(folders.nodes, importSecDoc.folderId);
+    secretPath = folderPath;
+  }
+
+  if (req.authData.authPayload instanceof ServiceTokenData) {
+    const isValidScopeAccess = isValidScope(
+      req.authData.authPayload,
+      importSecDoc.environment,
+      secretPath
+    );
+    if (!isValidScopeAccess) {
+      throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+    }
+  } else {
+    const { permission } = await getUserProjectPermissions(
+      req.user._id,
+      importSecDoc.workspace.toString()
+    );
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Delete,
+      subject(ProjectPermissionSub.Secrets, {
+        environment: importSecDoc.environment,
+        secretPath
+      })
+    );
+  }
+  importSecDoc.imports = importSecDoc.imports.filter(
+    ({ environment, secretPath }) =>
+      !(environment === secretImportEnv && secretPath === secretImportPath)
+  );
+  await importSecDoc.save();
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.DELETE_SECRET_IMPORT,
+      metadata: {
+        secretImportId: importSecDoc._id.toString(),
+        folderId: importSecDoc.folderId.toString(),
+        importFromEnvironment: secretImportEnv,
+        importFromSecretPath: secretImportPath,
+        importToEnvironment: importSecDoc.environment,
+        importToSecretPath: secretPath
+      }
+    },
+    {
+      workspaceId: importSecDoc.workspace
+    }
+  );
+
+  return res.status(200).json({ message: "successfully delete secret import" });
+};
+
+/**
+ * Get secret imports
+ * @param req
+ * @param res
+ * @returns
+ */
+export const getSecretImports = async (req: Request, res: Response) => {
+  /*
+    #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 the workspace of secret imports to get',
+        required: true,
+        type: 'string',
+        example: 'workspace12345'
+    }
+
+    #swagger.parameters['environment'] = {
+        in: 'query',
+        description: 'Environment of secret imports to get',
+        required: true,
+        type: 'string',
+        example: 'production'
+    }
+
+    #swagger.parameters['folderId'] = {
+        in: 'query',
+        description: 'ID of the folder containing the secret imports. Default: root',
+        required: false,
+        type: 'string',
+        example: 'folder12345'
+    }
+
+    #swagger.responses[200] = {
+        description: 'Successfully retrieved secret import',
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "secretImport": {
+                            "type": "object",
+                            "description": "Details of a secret import"
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #swagger.responses[403] = {
+        description: 'Forbidden access due to insufficient permissions',
+    }
+
+    #swagger.responses[401] = {
+        description: 'Unauthorized access due to invalid token or scope',
+    }
+  */
+  const {
+    query: { workspaceId, environment, folderId }
+  } = await validateRequest(reqValidator.GetSecretImportsV1, req);
+  const importSecDoc = await SecretImport.findOne({
+    workspace: workspaceId,
+    environment,
+    folderId
+  });
+
+  if (!importSecDoc) {
+    return res.status(200).json({ secretImport: {} });
+  }
+
+  // check for service token validity
+  const folders = await Folder.findOne({
+    workspace: importSecDoc.workspace,
+    environment: importSecDoc.environment
+  }).lean();
+
+  let secretPath = "/";
+  if (folders) {
+    const { folderPath } = getFolderWithPathFromId(folders.nodes, importSecDoc.folderId);
+    secretPath = folderPath;
+  }
+
+  if (req.authData.authPayload instanceof ServiceTokenData) {
+    const isValidScopeAccess = isValidScope(
+      req.authData.authPayload,
+      importSecDoc.environment,
+      secretPath
+    );
+    if (!isValidScopeAccess) {
+      throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+    }
+  } else {
+    const { permission } = await getUserProjectPermissions(
+      req.user._id,
+      importSecDoc.workspace.toString()
+    );
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Read,
+      subject(ProjectPermissionSub.Secrets, {
+        environment: importSecDoc.environment,
+        secretPath
+      })
+    );
+  }
+
+  return res.status(200).json({ secretImport: importSecDoc });
+};
+
+/**
+ * Get all secret imports
+ * @param req
+ * @param res
+ * @returns
+ */
+export const getAllSecretsFromImport = async (req: Request, res: Response) => {
+  const {
+    query: { workspaceId, environment, folderId }
+  } = await validateRequest(reqValidator.GetAllSecretsFromImportV1, req);
+
+  const importSecDoc = await SecretImport.findOne({
+    workspace: workspaceId,
+    environment,
+    folderId
+  });
+
+  if (!importSecDoc) {
+    return res.status(200).json({ secrets: [] });
+  }
+
+  const folders = await Folder.findOne({
+    workspace: importSecDoc.workspace,
+    environment: importSecDoc.environment
+  }).lean();
+
+  let secretPath = "/";
+  if (folders) {
+    const { folderPath } = getFolderWithPathFromId(folders.nodes, importSecDoc.folderId);
+    secretPath = folderPath;
+  }
+
+  let permissionCheckFn: (env: string, secPath: string) => boolean; // used to pass as callback function to import secret
+  if (req.authData.authPayload instanceof ServiceTokenData) {
+    // check for service token validity
+    const isValidScopeAccess = isValidScope(
+      req.authData.authPayload,
+      importSecDoc.environment,
+      secretPath
+    );
+    if (!isValidScopeAccess) {
+      throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+    }
+    permissionCheckFn = (env: string, secPath: string) =>
+      isValidScope(req.authData.authPayload as IServiceTokenData, env, secPath);
+  } else {
+    const { permission } = await getUserProjectPermissions(
+      req.user._id,
+      importSecDoc.workspace.toString()
+    );
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Read,
+      subject(ProjectPermissionSub.Secrets, {
+        environment: importSecDoc.environment,
+        secretPath
+      })
+    );
+    permissionCheckFn = (env: string, secPath: string) =>
+      permission.can(
+        ProjectPermissionActions.Read,
+        subject(ProjectPermissionSub.Secrets, {
+          environment: env,
+          secretPath: secPath
+        })
+      );
+  }
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.GET_SECRET_IMPORTS,
+      metadata: {
+        environment,
+        secretImportId: importSecDoc._id.toString(),
+        folderId,
+        numberOfImports: importSecDoc.imports.length
+      }
+    },
+    {
+      workspaceId: importSecDoc.workspace
+    }
+  );
+
+  const secrets = await getAllImportedSecrets(
+    workspaceId,
+    environment,
+    folderId,
+    permissionCheckFn
+  );
+  return res.status(200).json({ secrets });
+};

backend/src/controllers/v1/secretScanningController.ts

@@ -0,0 +1,180 @@
+import { Request, Response } from "express";
+import GitAppInstallationSession from "../../ee/models/gitAppInstallationSession";
+import crypto from "crypto";
+import { Types } from "mongoose";
+import { OrganizationNotFoundError, UnauthorizedRequestError } from "../../utils/errors";
+import GitAppOrganizationInstallation from "../../ee/models/gitAppOrganizationInstallation";
+import { scanGithubFullRepoForSecretLeaks } from "../../queues/secret-scanning/githubScanFullRepository";
+import { getSecretScanningGitAppId, getSecretScanningPrivateKey } from "../../config";
+import GitRisks, {
+  STATUS_RESOLVED_FALSE_POSITIVE,
+  STATUS_RESOLVED_NOT_REVOKED,
+  STATUS_RESOLVED_REVOKED
+} from "../../ee/models/gitRisks";
+import { ProbotOctokit } from "probot";
+import { Organization } from "../../models";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/secretScanning";
+import {
+  OrgPermissionActions,
+  OrgPermissionSubjects,
+  getUserOrgPermissions
+} from "../../ee/services/RoleService";
+import { ForbiddenError } from "@casl/ability";
+
+export const createInstallationSession = async (req: Request, res: Response) => {
+  const sessionId = crypto.randomBytes(16).toString("hex");
+  const {
+    params: { organizationId }
+  } = await validateRequest(reqValidator.CreateInstalLSessionv1, req);
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Create,
+    OrgPermissionSubjects.SecretScanning
+  );
+
+  await GitAppInstallationSession.findByIdAndUpdate(
+    organization,
+    {
+      organization: organization.id,
+      sessionId: sessionId,
+      user: new Types.ObjectId(req.user._id)
+    },
+    { upsert: true }
+  ).lean();
+
+  res.send({
+    sessionId: sessionId
+  });
+};
+
+export const linkInstallationToOrganization = async (req: Request, res: Response) => {
+  const {
+    body: { sessionId, installationId }
+  } = await validateRequest(reqValidator.LinkInstallationToOrgv1, req);
+
+  const installationSession = await GitAppInstallationSession.findOneAndDelete({
+    sessionId: sessionId
+  });
+  if (!installationSession) {
+    throw UnauthorizedRequestError();
+  }
+
+  const { permission } = await getUserOrgPermissions(
+    req.user._id,
+    installationSession.organization.toString()
+  );
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Edit,
+    OrgPermissionSubjects.SecretScanning
+  );
+
+  const installationLink = await GitAppOrganizationInstallation.findOneAndUpdate(
+    {
+      organizationId: installationSession.organization
+    },
+    {
+      installationId: installationId,
+      organizationId: installationSession.organization,
+      user: installationSession.user
+    },
+    {
+      upsert: true
+    }
+  ).lean();
+
+  const octokit = new ProbotOctokit({
+    auth: {
+      appId: await getSecretScanningGitAppId(),
+      privateKey: await getSecretScanningPrivateKey(),
+      installationId: installationId.toString()
+    }
+  });
+
+  const {
+    data: { repositories }
+  } = await octokit.apps.listReposAccessibleToInstallation();
+  for (const repository of repositories) {
+    scanGithubFullRepoForSecretLeaks({
+      organizationId: installationSession.organization.toString(),
+      installationId,
+      repository: { id: repository.id, fullName: repository.full_name }
+    });
+  }
+  res.json(installationLink);
+};
+
+export const getCurrentOrganizationInstallationStatus = async (req: Request, res: Response) => {
+  const { organizationId } = req.params;
+  try {
+    const appInstallation = await GitAppOrganizationInstallation.findOne({
+      organizationId: organizationId
+    }).lean();
+    if (!appInstallation) {
+      res.json({
+        appInstallationComplete: false
+      });
+    }
+
+    res.json({
+      appInstallationComplete: true
+    });
+  } catch {
+    res.json({
+      appInstallationComplete: false
+    });
+  }
+};
+
+export const getRisksForOrganization = async (req: Request, res: Response) => {
+  const {
+    params: { organizationId }
+  } = await validateRequest(reqValidator.GetOrgRisksv1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Read,
+    OrgPermissionSubjects.SecretScanning
+  );
+
+  const risks = await GitRisks.find({ organization: organizationId })
+    .sort({ createdAt: -1 })
+    .lean();
+  res.json({
+    risks: risks
+  });
+};
+
+export const updateRisksStatus = async (req: Request, res: Response) => {
+  const {
+    params: { organizationId, riskId },
+    body: { status }
+  } = await validateRequest(reqValidator.UpdateRiskStatusv1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Edit,
+    OrgPermissionSubjects.SecretScanning
+  );
+
+  const isRiskResolved =
+    status == STATUS_RESOLVED_FALSE_POSITIVE ||
+    status == STATUS_RESOLVED_REVOKED ||
+    status == STATUS_RESOLVED_NOT_REVOKED
+      ? true
+      : false;
+  const risk = await GitRisks.findByIdAndUpdate(riskId, {
+    status: status,
+    isResolved: isRiskResolved
+  }).lean();
+
+  res.json(risk);
+};

backend/src/controllers/v1/secretsFolderController.ts

@@ -1,107 +1,745 @@
-import { Request, Response } from 'express';
+import { ForbiddenError, subject } from "@casl/ability";
-import { Secret } from '../../models';
+import { Request, Response } from "express";
-import Folder from '../../models/folder';
+import { Types } from "mongoose";
-import { BadRequestError } from '../../utils/errors';
+import { EventType, FolderVersion } from "../../ee/models";
-import { ROOT_FOLDER_PATH, getFolderPath, getParentPath, normalizePath, validateFolderName } from '../../utils/folder';
+import { EEAuditLogService, EESecretService } from "../../ee/services";
-import { ADMIN, MEMBER } from '../../variables';
+import { isValidScope } from "../../helpers/secrets";
-import { validateMembership } from '../../helpers/membership';
+import { validateRequest } from "../../helpers/validation";
+import { Secret, ServiceTokenData } from "../../models";
+import { Folder } from "../../models/folder";
+import {
+  appendFolder,
+  deleteFolderById,
+  generateFolderId,
+  getAllFolderIds,
+  getFolderByPath,
+  getFolderWithPathFromId,
+  getParentFromFolderId,
+  validateFolderName
+} from "../../services/FolderService";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  getUserProjectPermissions
+} from "../../ee/services/ProjectRoleService";
+import { BadRequestError, UnauthorizedRequestError } from "../../utils/errors";
+import * as reqValidator from "../../validation/folders";
 
-// TODO
+/**
-// verify workspace id/environment
+ * Create folder with name [folderName] for workspace with id [workspaceId]
+ * and environment [environment]
+ * @param req
+ * @param res
+ * @returns
+ */
 export const createFolder = async (req: Request, res: Response) => {
-  const { workspaceId, environment, folderName, parentFolderId } = req.body
+  /* 
+    #swagger.summary = 'Create a folder'
+    #swagger.description = 'Create a new folder in a specified workspace and environment'
+    
+    #swagger.security = [{
+        "apiKeyAuth": []
+    }]
+
+    #swagger.requestBody = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "workspaceId": {
+                            "type": "string",
+                            "description": "ID of the workspace where the folder will be created",
+                            "example": "someWorkspaceId"
+                        },
+                        "environment": {
+                            "type": "string",
+                            "description": "Environment where the folder will reside",
+                            "example": "production"
+                        },
+                        "folderName": {
+                            "type": "string",
+                            "description": "Name of the folder to be created",
+                            "example": "my_folder"
+                        },
+                        "parentFolderId": {
+                            "type": "string",
+                            "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"]
+                }
+            }
+        }
+    }
+
+    #swagger.responses[200] = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "folder": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "string",
+                                    "example": "someFolderId"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "example": "my_folder"
+                                }
+                            },
+                            "description": "Details of the created folder"
+                        }
+                    }
+                }
+            }
+        }
+    }
+    #swagger.responses[400] = {
+        description: "Bad Request. For example, 'Folder name cannot contain spaces. Only underscore and dashes'"
+    }
+    #swagger.responses[401] = {
+        description: "Unauthorized request. For example, 'Folder Permission Denied'"
+    }
+  */
+  const {
+    body: { workspaceId, environment, folderName, parentFolderId }
+  } = await validateRequest(reqValidator.CreateFolderV1, req);
+
   if (!validateFolderName(folderName)) {
-    throw BadRequestError({ message: "Folder name cannot contain spaces. Only underscore and dashes" })
+    throw BadRequestError({
+      message: "Folder name cannot contain spaces. Only underscore and dashes"
+    });
   }
 
-  if (parentFolderId) {
+  const folders = await Folder.findOne({
-    const parentFolder = await Folder.find({ environment: environment, workspace: workspaceId, id: parentFolderId });
+    workspace: workspaceId,
-    if (!parentFolder) {
+    environment
-      throw BadRequestError({ message: "The parent folder doesn't exist" })
+  }).lean();
+
+  if (req.user) {
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    const secretPath =
+      folders && parentFolderId
+        ? getFolderWithPathFromId(folders.nodes, parentFolderId).folderPath
+        : "/";
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Create,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+  }
+
+  // space has no folders initialized
+
+  if (!folders) {
+    if (req.authData.authPayload instanceof ServiceTokenData) {
+      // root check
+      const isValidScopeAccess = isValidScope(req.authData.authPayload, environment, "/");
+      if (!isValidScopeAccess) {
+        throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+      }
+    }
+
+    const id = generateFolderId();
+    const folder = new Folder({
+      workspace: workspaceId,
+      environment,
+      nodes: {
+        id: "root",
+        name: "root",
+        version: 1,
+        children: [{ id, name: folderName, children: [], version: 1 }]
+      }
+    });
+    await folder.save();
+    const folderVersion = new FolderVersion({
+      workspace: workspaceId,
+      environment,
+      nodes: folder.nodes
+    });
+    await folderVersion.save();
+    await EESecretService.takeSecretSnapshot({
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment
+    });
+
+    await EEAuditLogService.createAuditLog(
+      req.authData,
+      {
+        type: EventType.CREATE_FOLDER,
+        metadata: {
+          environment,
+          folderId: id,
+          folderName,
+          folderPath: `root/${folderName}`
+        }
+      },
+      {
+        workspaceId: new Types.ObjectId(workspaceId)
+      }
+    );
+
+    return res.json({ folder: { id, name: folderName } });
+  }
+
+  const folder = appendFolder(folders.nodes, { folderName, parentFolderId });
+
+  await Folder.findByIdAndUpdate(folders._id, folders);
+
+  const { folder: parentFolder, folderPath: parentFolderPath } = getFolderWithPathFromId(
+    folders.nodes,
+    parentFolderId || "root"
+  );
+
+  if (req.authData.authPayload instanceof ServiceTokenData) {
+    // root check
+    const isValidScopeAccess = isValidScope(
+      req.authData.authPayload,
+      environment,
+      parentFolderPath
+    );
+    if (!isValidScopeAccess) {
+      throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
     }
   }
 
-  let completePath = await getFolderPath(parentFolderId)
+  await Folder.findByIdAndUpdate(folders._id, folders);
-  if (completePath == ROOT_FOLDER_PATH) {
-    completePath = ""
-  }
 
-  const currentFolderPath = completePath + "/" + folderName // construct new path with current folder to be created
+  const folderVersion = new FolderVersion({
-  const normalizedCurrentPath = normalizePath(currentFolderPath)
-  const normalizedParentPath = getParentPath(normalizedCurrentPath)
-
-  const existingFolder = await Folder.findOne({
-    name: folderName,
     workspace: workspaceId,
-    environment: environment,
+    environment,
-    parent: parentFolderId,
+    nodes: parentFolder
-    path: normalizedCurrentPath
+  });
+  await folderVersion.save();
+
+  await EESecretService.takeSecretSnapshot({
+    workspaceId: new Types.ObjectId(workspaceId),
+    environment,
+    folderId: parentFolderId
   });
 
-  if (existingFolder) {
+  const { folderPath } = getFolderWithPathFromId(folders.nodes, folder.id);
-    return res.json(existingFolder)
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.CREATE_FOLDER,
+      metadata: {
+        environment,
+        folderId: folder.id,
+        folderName,
+        folderPath
+      }
+    },
+    {
+      workspaceId: new Types.ObjectId(workspaceId)
+    }
+  );
+
+  return res.json({ folder });
+};
+
+/**
+ * Update folder with id [folderId]
+ * @param req
+ * @param res
+ * @returns
+ */
+export const updateFolderById = async (req: Request, res: Response) => {
+  /* 
+    #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": []
+    }]
+
+    #swagger.parameters['folderId'] = {
+        "description": "ID of the folder to be updated",
+        "required": true,
+        "type": "string",
+        "in": "path"
+    }
+
+    #swagger.requestBody = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "workspaceId": {
+                            "type": "string",
+                            "description": "ID of the workspace where the folder is located",
+                            "example": "someWorkspaceId"
+                        },
+                        "environment": {
+                            "type": "string",
+                            "description": "Environment where the folder is located",
+                            "example": "production"
+                        },
+                        "name": {
+                            "type": "string",
+                            "description": "New name for the folder",
+                            "example": "updated_folder_name"
+                        }
+                    },
+                    "required": ["workspaceId", "environment", "name"]
+                }
+            }
+        }
+    }
+
+    #swagger.responses[200] = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "message": {
+                            "type": "string",
+                            "example": "Successfully updated folder"
+                        },
+                        "folder": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                    "example": "updated_folder_name"
+                                },
+                                "id": {
+                                    "type": "string",
+                                    "example": "someFolderId"
+                                }
+                            },
+                            "description": "Details of the updated folder"
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #swagger.responses[400] = {
+        description: "Bad Request. Reasons can include 'The folder doesn't exist' or 'Folder name cannot contain spaces. Only underscore and dashes'"
+    }
+
+    #swagger.responses[401] = {
+        description: "Unauthorized request. For example, 'Folder Permission Denied'"
+    }
+  */
+  const {
+    body: { workspaceId, environment, name },
+    params: { folderId }
+  } = await validateRequest(reqValidator.UpdateFolderV1, req);
+
+  if (!validateFolderName(name)) {
+    throw BadRequestError({
+      message: "Folder name cannot contain spaces. Only underscore and dashes"
+    });
   }
 
-  const newFolder = new Folder({
+  const folders = await Folder.findOne({ workspace: workspaceId, environment });
-    name: folderName,
+  if (!folders) {
+    throw BadRequestError({ message: "The folder doesn't exist" });
+  }
+
+  const parentFolder = getParentFromFolderId(folders.nodes, folderId);
+  if (!parentFolder) {
+    throw BadRequestError({ message: "The folder doesn't exist" });
+  }
+
+  if (req.user) {
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    const secretPath = getFolderWithPathFromId(folders.nodes, parentFolder.id).folderPath;
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Edit,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+  }
+
+  const folder = parentFolder.children.find(({ id }) => id === folderId);
+  if (!folder) {
+    throw BadRequestError({ message: "The folder doesn't exist" });
+  }
+
+  if (req.authData.authPayload instanceof ServiceTokenData) {
+    const { folderPath: secretPath } = getFolderWithPathFromId(folders.nodes, parentFolder.id);
+    // root check
+    const isValidScopeAccess = isValidScope(req.authData.authPayload, environment, secretPath);
+    if (!isValidScopeAccess) {
+      throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+    }
+  }
+
+  const oldFolderName = folder.name;
+  parentFolder.version += 1;
+  folder.name = name;
+
+  await Folder.findByIdAndUpdate(folders._id, folders);
+  const folderVersion = new FolderVersion({
     workspace: workspaceId,
-    environment: environment,
+    environment,
-    parent: parentFolderId,
+    nodes: parentFolder
-    path: normalizedCurrentPath,
+  });
-    parentPath: normalizedParentPath
+  await folderVersion.save();
+
+  await EESecretService.takeSecretSnapshot({
+    workspaceId: new Types.ObjectId(workspaceId),
+    environment,
+    folderId: parentFolder.id
   });
 
-  await newFolder.save();
+  const { folderPath } = getFolderWithPathFromId(folders.nodes, folder.id);
 
-  return res.json(newFolder)
+  await EEAuditLogService.createAuditLog(
-}
+    req.authData,
+    {
+      type: EventType.UPDATE_FOLDER,
+      metadata: {
+        environment,
+        folderId: folder.id,
+        oldFolderName,
+        newFolderName: name,
+        folderPath
+      }
+    },
+    {
+      workspaceId: new Types.ObjectId(workspaceId)
+    }
+  );
 
+  return res.json({
+    message: "Successfully updated folder",
+    folder: { name: folder.name, id: folder.id }
+  });
+};
+
+/**
+ * Delete folder with id [folderId]
+ * @param req
+ * @param res
+ * @returns
+ */
 export const deleteFolder = async (req: Request, res: Response) => {
-  const { folderId } = req.params
+  /* 
-  const queue: any[] = [folderId];
+    #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": []
+    }]
 
-  const folder = await Folder.findById(folderId);
+    #swagger.parameters['folderId'] = {
-  if (!folder) {
+        "description": "ID of the folder to be deleted",
-    throw BadRequestError({ message: "The folder doesn't exist" })
+        "required": true,
-  }
+        "type": "string",
-
+        "in": "path"
-  // check that user is a member of the workspace
-  await validateMembership({
-    userId: req.user._id.toString(),
-    workspaceId: folder.workspace as any,
-    acceptedRoles: [ADMIN, MEMBER]
-  });
-
-  while (queue.length > 0) {
-    const currentFolderId = queue.shift();
-
-    const childFolders = await Folder.find({ parent: currentFolderId });
-    for (const childFolder of childFolders) {
-      queue.push(childFolder._id);
     }
 
-    await Secret.deleteMany({ folder: currentFolderId });
+    #swagger.requestBody = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "workspaceId": {
+                            "type": "string",
+                            "description": "ID of the workspace where the folder is located",
+                            "example": "someWorkspaceId"
+                        },
+                        "environment": {
+                            "type": "string",
+                            "description": "Environment where the folder is located",
+                            "example": "production"
+                        }
+                    },
+                    "required": ["workspaceId", "environment"]
+                }
+            }
+        }
+    }
 
-    await Folder.deleteOne({ _id: currentFolderId });
+    #swagger.responses[200] = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "message": {
+                            "type": "string",
+                            "example": "successfully deleted folders"
+                        },
+                        "folders": {
+                            "type": "array",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "id": {
+                                        "type": "string",
+                                        "example": "someFolderId"
+                                    },
+                                    "name": {
+                                        "type": "string",
+                                        "example": "someFolderName"
+                                    }
+                                }
+                            },
+                            "description": "List of IDs and names of the deleted folders"
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #swagger.responses[400] = {
+        description: "Bad Request. Reasons can include 'The folder doesn't exist'"
+    }
+
+    #swagger.responses[401] = {
+        description: "Unauthorized request. For example, 'Folder Permission Denied'"
+    }
+  */
+  const {
+    params: { folderId },
+    body: { environment, workspaceId }
+  } = await validateRequest(reqValidator.DeleteFolderV1, req);
+
+  const folders = await Folder.findOne({ workspace: workspaceId, environment });
+  if (!folders) {
+    throw BadRequestError({ message: "The folder doesn't exist" });
   }
 
-  res.send()
+  const delOp = deleteFolderById(folders.nodes, folderId);
-}
+  if (!delOp) {
-
+    throw BadRequestError({ message: "The folder doesn't exist" });
-// TODO: validate workspace
-export const getFolderById = async (req: Request, res: Response) => {
-  const { folderId } = req.params
-
-  const folder = await Folder.findById(folderId);
-  if (!folder) {
-    throw BadRequestError({ message: "The folder doesn't exist" })
   }
-  // check that user is a member of the workspace
+  const { deletedNode: delFolder, parent: parentFolder } = delOp;
-  await validateMembership({
+  const { folderPath: secretPath } = getFolderWithPathFromId(folders.nodes, parentFolder.id);
-    userId: req.user._id.toString(),
+
-    workspaceId: folder.workspace as any,
+  if (req.authData.authPayload instanceof ServiceTokenData) {
-    acceptedRoles: [ADMIN, MEMBER]
+    const isValidScopeAccess = isValidScope(req.authData.authPayload, environment, secretPath);
+    if (!isValidScopeAccess) {
+      throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+    }
+  } else {
+    // check that user is a member of the workspace
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Delete,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+  }
+
+  parentFolder.version += 1;
+  const delFolderIds = getAllFolderIds(delFolder);
+
+  await Folder.findByIdAndUpdate(folders._id, folders);
+  const folderVersion = new FolderVersion({
+    workspace: workspaceId,
+    environment,
+    nodes: parentFolder
+  });
+  await folderVersion.save();
+  if (delFolderIds.length) {
+    await Secret.deleteMany({
+      folder: { $in: delFolderIds.map(({ id }) => id) },
+      workspace: workspaceId,
+      environment
+    });
+  }
+
+  await EESecretService.takeSecretSnapshot({
+    workspaceId: new Types.ObjectId(workspaceId),
+    environment,
+    folderId: parentFolder.id
   });
 
-  res.send({ folder })
+  await EEAuditLogService.createAuditLog(
-}
+    req.authData,
+    {
+      type: EventType.DELETE_FOLDER,
+      metadata: {
+        environment,
+        folderId,
+        folderName: delFolder.name,
+        folderPath: secretPath
+      }
+    },
+    {
+      workspaceId: new Types.ObjectId(workspaceId)
+    }
+  );
+
+  res.send({ message: "successfully deleted folders", folders: delFolderIds });
+};
+
+/**
+ * Get folders for workspace with id [workspaceId] and environment [environment]
+ * considering [parentFolderId] and [parentFolderPath]
+ * @param req
+ * @param res
+ * @returns
+ */
+export const getFolders = async (req: Request, res: Response) => {
+  /*
+    #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": []
+    }]
+
+    #swagger.parameters['workspaceId'] = {
+        "description": "ID of the workspace from which the folders are to be fetched",
+        "required": true,
+        "type": "string",
+        "in": "query"
+    }
+
+    #swagger.parameters['environment'] = {
+        "description": "Environment where the folder is located",
+        "required": true,
+        "type": "string",
+        "in": "query"
+    }
+
+    #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"
+    }
+
+    #swagger.responses[200] = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "folders": {
+                            "type": "array",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "id": {
+                                        "type": "string",
+                                        "example": "someFolderId"
+                                    },
+                                    "name": {
+                                        "type": "string",
+                                        "example": "someFolderName"
+                                    }
+                                }
+                            },
+                            "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"
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #swagger.responses[400] = {
+        description: "Bad Request. For instance, 'The folder doesn't exist'"
+    }
+
+    #swagger.responses[401] = {
+        description: "Unauthorized request. For example, 'Folder Permission Denied'"
+    }
+  */
+  const {
+    query: { workspaceId, environment, parentFolderId, parentFolderPath }
+  } = await validateRequest(reqValidator.GetFoldersV1, req);
+
+  const folders = await Folder.findOne({ workspace: workspaceId, environment });
+
+  if (req.user) await getUserProjectPermissions(req.user._id, workspaceId);
+
+  if (!folders) {
+    res.send({ folders: [], dir: [] });
+    return;
+  }
+
+  // if instead of parentFolderId given a path like /folder1/folder2
+  if (parentFolderPath) {
+    if (req.authData.authPayload instanceof ServiceTokenData) {
+      const isValidScopeAccess = isValidScope(
+        req.authData.authPayload,
+        environment,
+        parentFolderPath
+      );
+      if (!isValidScopeAccess) {
+        throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+      }
+    }
+    const folder = getFolderByPath(folders.nodes, parentFolderPath);
+
+    if (!folder) {
+      res.send({ folders: [], dir: [] });
+      return;
+    }
+    // dir is not needed at present as this is only used in overview section of secrets
+    res.send({
+      folders: folder.children.map(({ id, name }) => ({ id, name })),
+      dir: [{ name: folder.name, id: folder.id }]
+    });
+  }
+
+  if (!parentFolderId) {
+    if (req.authData.authPayload instanceof ServiceTokenData) {
+      const isValidScopeAccess = isValidScope(req.authData.authPayload, environment, "/");
+      if (!isValidScopeAccess) {
+        throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+      }
+    }
+
+    const rootFolders = folders.nodes.children.map(({ id, name }) => ({
+      id,
+      name
+    }));
+    res.send({ folders: rootFolders });
+    return;
+  }
+
+  const { folder, folderPath, dir } = getFolderWithPathFromId(folders.nodes, parentFolderId);
+  if (req.authData.authPayload instanceof ServiceTokenData) {
+    const isValidScopeAccess = isValidScope(req.authData.authPayload, environment, folderPath);
+    if (!isValidScopeAccess) {
+      throw UnauthorizedRequestError({ message: "Folder Permission Denied" });
+    }
+  }
+
+  res.send({
+    folders: folder.children.map(({ id, name }) => ({ id, name })),
+    dir
+  });
+};

backend/src/controllers/v1/serviceTokenController.ts

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

backend/src/controllers/v1/signupController.ts

@@ -1,13 +1,17 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
+import { AuthMethod, User } from "../../models";
-import { User } from '../../models';
+import { checkEmailVerification, sendEmailVerification } from "../../helpers/signup";
+import { createToken } from "../../helpers/auth";
+import { BadRequestError } from "../../utils/errors";
 import {
-	sendEmailVerification,
+  getInviteOnlySignup,
-	checkEmailVerification,
+  getJwtSignupLifetime,
-} from '../../helpers/signup';
+  getJwtSignupSecret,
-import { createToken } from '../../helpers/auth';
+  getSmtpConfigured
-import { BadRequestError } from '../../utils/errors';
+} from "../../config";
-import { getInviteOnlySignup, getJwtSignupLifetime, getJwtSignupSecret, getSmtpConfigured } from '../../config';
+import { validateUserEmail } from "../../validation";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/auth";
 
 /**
  * Signup step 1: Initialize account for user under email [email] and send a verification code
@@ -17,32 +21,28 @@ import { getInviteOnlySignup, getJwtSignupLifetime, getJwtSignupSecret, getSmtpC
  * @returns
  */
 export const beginEmailSignup = async (req: Request, res: Response) => {
-	let email: string;
+  const {
-	try {
+    body: { email }
-		email = req.body.email;
+  } = await validateRequest(reqValidator.BeginEmailSignUpV1, req);
 
-		const user = await User.findOne({ email }).select('+publicKey');
+  // validate that email is not disposable
-		if (user && user?.publicKey) {
+  validateUserEmail(email);
-			// case: user has already completed account
 
-			return res.status(403).send({
+  const user = await User.findOne({ email }).select("+publicKey");
-				error: 'Failed to send email verification code for complete account'
+  if (user && user?.publicKey) {
-			});
+    // case: user has already completed account
-		}
 
-		// send send verification email
+    return res.status(403).send({
-		await sendEmailVerification({ email });
+      error: "Failed to send email verification code for complete account"
-	} catch (err) {
+    });
-		Sentry.setUser(null);
+  }
-		Sentry.captureException(err);
+
-		return res.status(400).send({
+  // send send verification email
-			error: 'Failed to send email verification code'
+  await sendEmailVerification({ email });
-		});
+
-	}
+  return res.status(200).send({
-	
+    message: `Sent an email verification code to ${email}`
-	return res.status(200).send({
+  });
-		message: `Sent an email verification code to ${email}`
-	});
 };
 
 /**
@@ -53,60 +53,57 @@ export const beginEmailSignup = async (req: Request, res: Response) => {
  * @returns
  */
 export const verifyEmailSignup = async (req: Request, res: Response) => {
-	let user, token;
+  let user;
-	try {
+  const {
-		const { email, code } = req.body;
+    body: { email, code }
+  } = await validateRequest(reqValidator.VerifyEmailSignUpV1, req);
 
-		// initialize user account
+  // initialize user account
-		user = await User.findOne({ email }).select('+publicKey');
+  user = await User.findOne({ email }).select("+publicKey");
-		if (user && user?.publicKey) {
+  if (user && user?.publicKey) {
-			// case: user has already completed account
+    // case: user has already completed account
-			return res.status(403).send({
+    return res.status(403).send({
-				error: 'Failed email verification for complete user'
+      error: "Failed email verification for complete user"
-			});
+    });
-		}
+  }
 
-		if (await getInviteOnlySignup()) {
+  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
+    // Only one user can create an account without being invited. The rest need to be invited in order to make an account
-			const userCount = await User.countDocuments({})
+    const userCount = await User.countDocuments({});
-			if (userCount != 0) {
+    if (userCount != 0) {
-				throw BadRequestError({ message: "New user sign ups are not allowed at this time. You must be invited to sign up." })
+      throw BadRequestError({
-			}
+        message: "New user sign ups are not allowed at this time. You must be invited to sign up."
-		}
+      });
+    }
+  }
 
-		// verify email
+  // verify email
-		if (await getSmtpConfigured()) {
+  if (await getSmtpConfigured()) {
-			await checkEmailVerification({
+    await checkEmailVerification({
-				email,
+      email,
-				code
+      code
-			});
+    });
-		}
+  }
 
-		if (!user) {
+  if (!user) {
-			user = await new User({
+    user = await new User({
-				email
+      email,
-			}).save();
+      authMethods: [AuthMethod.EMAIL]
-		}
+    }).save();
+  }
 
-		// generate temporary signup token
+  // generate temporary signup token
-		token = createToken({
+  const token = createToken({
-			payload: {
+    payload: {
-				userId: user._id.toString()
+      userId: user._id.toString()
-			},
+    },
-			expiresIn: await getJwtSignupLifetime(),
+    expiresIn: await getJwtSignupLifetime(),
-			secret: await getJwtSignupSecret()
+    secret: await getJwtSignupSecret()
-		});
+  });
-	} catch (err) {
-		Sentry.setUser(null);
-		Sentry.captureException(err);
-		return res.status(400).send({
-			error: 'Failed email verification'
-		});
-	}
 
-	return res.status(200).send({
+  return res.status(200).send({
-		message: 'Successfuly verified email',
+    message: "Successfuly verified email",
-		user,
+    user,
-		token
+    token
-	});
+  });
 };

backend/src/controllers/v1/stripeController.ts

@@ -1,41 +0,0 @@
-import { Request, Response } from 'express';
-import * as Sentry from '@sentry/node';
-import Stripe from 'stripe';
-import { getStripeSecretKey, getStripeWebhookSecret } from '../../config';
-
-/**
- * Handle service provisioning/un-provisioning via Stripe
- * @param req
- * @param res
- * @returns
- */
-export const handleWebhook = async (req: Request, res: Response) => {
-	let event;
-	try {
-		// check request for valid stripe signature
-		const stripe = new Stripe(await getStripeSecretKey(), {
-			apiVersion: '2022-08-01'
-		});
-
-		const sig = req.headers['stripe-signature'] as string;
-		event = stripe.webhooks.constructEvent(
-			req.body,
-			sig,
-			await getStripeWebhookSecret()
-		);
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			error: 'Failed to process webhook'
-		});
-	}
-
-	switch (event.type) {
-		case '':
-			break;
-		default:
-	}
-
-	return res.json({ received: true });
-};

backend/src/controllers/v1/userActionController.ts

@@ -1,6 +1,7 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
+import { validateRequest } from "../../helpers/validation";
-import { UserAction } from '../../models';
+import { UserAction } from "../../models";
+import * as reqValidator from "../../validation/action";
 
 /**
  * Add user action [action]
@@ -9,35 +10,27 @@ import { UserAction } from '../../models';
  * @returns
  */
 export const addUserAction = async (req: Request, res: Response) => {
-	// add/record new action [action] for user with id [req.user._id]
+  // add/record new action [action] for user with id [req.user._id]
+  const {
+    body: { action }
+  } = await validateRequest(reqValidator.AddUserActionV1, req);
 
-	let userAction;
+  const userAction = await UserAction.findOneAndUpdate(
-	try {
+    {
-		const { action } = req.body;
+      user: req.user._id,
+      action
+    },
+    { user: req.user._id, action },
+    {
+      new: true,
+      upsert: true
+    }
+  );
 
-		userAction = await UserAction.findOneAndUpdate(
+  return res.status(200).send({
-			{
+    message: "Successfully recorded user action",
-				user: req.user._id,
+    userAction
-				action
+  });
-			},
-			{ user: req.user._id, action },
-			{
-				new: true,
-				upsert: true
-			}
-		);
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to record user action'
-		});
-	}
-
-	return res.status(200).send({
-		message: 'Successfully recorded user action',
-		userAction
-	});
 };
 
 /**
@@ -47,24 +40,17 @@ export const addUserAction = async (req: Request, res: Response) => {
  * @returns
  */
 export const getUserAction = async (req: Request, res: Response) => {
-	// get user action [action] for user with id [req.user._id]
+  // get user action [action] for user with id [req.user._id]
-	let userAction;
+  const {
-	try {
+    query: { action }
-		const action: string = req.query.action as string;
+  } = await validateRequest(reqValidator.GetUserActionV1, req);
 
-		userAction = await UserAction.findOne({
+  const userAction = await UserAction.findOne({
-			user: req.user._id,
+    user: req.user._id,
-			action
+    action
-		});
+  });
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get user action'
-		});
-	}
 
-	return res.status(200).send({
+  return res.status(200).send({
-		userAction
+    userAction
-	});
+  });
 };

backend/src/controllers/v1/userController.ts

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

backend/src/controllers/v1/webhookController.ts

@@ -0,0 +1,239 @@
+import { Request, Response } from "express";
+import { Types } from "mongoose";
+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 } from "../../variables";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/webhooks";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  getUserProjectPermissions
+} from "../../ee/services/ProjectRoleService";
+import { ForbiddenError } from "@casl/ability";
+
+export const createWebhook = async (req: Request, res: Response) => {
+  const {
+    body: { webhookUrl, webhookSecretKey, environment, workspaceId, secretPath }
+  } = await validateRequest(reqValidator.CreateWebhookV1, req);
+
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Create,
+    ProjectPermissionSub.Webhooks
+  );
+
+  const webhook = new Webhook({
+    workspace: workspaceId,
+    environment,
+    secretPath,
+    url: webhookUrl,
+    algorithm: ALGORITHM_AES_256_GCM,
+    keyEncoding: ENCODING_SCHEME_BASE64
+  });
+
+  if (webhookSecretKey) {
+    const rootEncryptionKey = await getRootEncryptionKey();
+    const { ciphertext, iv, tag } = client.encryptSymmetric(webhookSecretKey, rootEncryptionKey);
+    webhook.iv = iv;
+    webhook.tag = tag;
+    webhook.encryptedSecretKey = ciphertext;
+  }
+
+  await webhook.save();
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.CREATE_WEBHOOK,
+      metadata: {
+        webhookId: webhook._id.toString(),
+        environment,
+        secretPath,
+        webhookUrl,
+        isDisabled: false
+      }
+    },
+    {
+      workspaceId: new Types.ObjectId(workspaceId)
+    }
+  );
+
+  return res.status(200).send({
+    webhook,
+    message: "successfully created webhook"
+  });
+};
+
+export const updateWebhook = async (req: Request, res: Response) => {
+  const {
+    body: { isDisabled },
+    params: { webhookId }
+  } = await validateRequest(reqValidator.UpdateWebhookV1, req);
+
+  const webhook = await Webhook.findById(webhookId);
+  if (!webhook) {
+    throw BadRequestError({ message: "Webhook not found!!" });
+  }
+
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    webhook.workspace.toString()
+  );
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Edit,
+    ProjectPermissionSub.Webhooks
+  );
+
+  if (typeof isDisabled !== undefined) {
+    webhook.isDisabled = isDisabled;
+  }
+  await webhook.save();
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.UPDATE_WEBHOOK_STATUS,
+      metadata: {
+        webhookId: webhook._id.toString(),
+        environment: webhook.environment,
+        secretPath: webhook.secretPath,
+        webhookUrl: webhook.url,
+        isDisabled
+      }
+    },
+    {
+      workspaceId: webhook.workspace
+    }
+  );
+
+  return res.status(200).send({
+    webhook,
+    message: "successfully updated webhook"
+  });
+};
+
+export const deleteWebhook = async (req: Request, res: Response) => {
+  const {
+    params: { webhookId }
+  } = await validateRequest(reqValidator.DeleteWebhookV1, req);
+  let webhook = await Webhook.findById(webhookId);
+
+  if (!webhook) {
+    throw ResourceNotFoundError({ message: "Webhook not found!!" });
+  }
+
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    webhook.workspace.toString()
+  );
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Delete,
+    ProjectPermissionSub.Webhooks
+  );
+
+  webhook = await Webhook.findByIdAndDelete(webhookId);
+
+  if (!webhook) {
+    throw ResourceNotFoundError({ message: "Webhook not found!!" });
+  }
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.DELETE_WEBHOOK,
+      metadata: {
+        webhookId: webhook._id.toString(),
+        environment: webhook.environment,
+        secretPath: webhook.secretPath,
+        webhookUrl: webhook.url,
+        isDisabled: webhook.isDisabled
+      }
+    },
+    {
+      workspaceId: webhook.workspace
+    }
+  );
+
+  return res.status(200).send({
+    message: "successfully removed webhook"
+  });
+};
+
+export const testWebhook = async (req: Request, res: Response) => {
+  const {
+    params: { webhookId }
+  } = await validateRequest(reqValidator.TestWebhookV1, req);
+
+  const webhook = await Webhook.findById(webhookId);
+  if (!webhook) {
+    throw BadRequestError({ message: "Webhook not found!!" });
+  }
+
+  const { permission } = await getUserProjectPermissions(
+    req.user._id,
+    webhook.workspace.toString()
+  );
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Read,
+    ProjectPermissionSub.Webhooks
+  );
+
+  try {
+    await triggerWebhookRequest(
+      webhook,
+      getWebhookPayload(
+        "test",
+        webhook.workspace.toString(),
+        webhook.environment,
+        webhook.secretPath
+      )
+    );
+    await Webhook.findByIdAndUpdate(webhookId, {
+      lastStatus: "success",
+      lastRunErrorMessage: null
+    });
+  } catch (err) {
+    await Webhook.findByIdAndUpdate(webhookId, {
+      lastStatus: "failed",
+      lastRunErrorMessage: (err as Error).message
+    });
+    return res.status(400).send({
+      message: "Failed to receive response",
+      error: (err as Error).message
+    });
+  }
+
+  return res.status(200).send({
+    message: "Successfully received response"
+  });
+};
+
+export const listWebhooks = async (req: Request, res: Response) => {
+  const {
+    query: { environment, workspaceId, secretPath }
+  } = await validateRequest(reqValidator.ListWebhooksV1, req);
+
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Read,
+    ProjectPermissionSub.Webhooks
+  );
+
+  const optionalFilters: Record<string, string> = {};
+  if (environment) optionalFilters.environment = environment as string;
+  if (secretPath) optionalFilters.secretPath = secretPath as string;
+
+  const webhooks = await Webhook.find({
+    workspace: new Types.ObjectId(workspaceId as string),
+    ...optionalFilters
+  });
+
+  return res.status(200).send({
+    webhooks
+  });
+};

backend/src/controllers/v1/workspaceController.ts

@@ -1,21 +1,32 @@
+import { Types } from "mongoose";
 import { Request, Response } from "express";
-import * as Sentry from "@sentry/node";
 import {
-  Workspace,
+  IUser,
-  Membership,
-  MembershipOrg,
   Integration,
   IntegrationAuth,
-  IUser,
+  Membership,
+  Organization,
   ServiceToken,
-  ServiceTokenData,
+  Workspace
 } from "../../models";
-import {
+import { createWorkspace as create, deleteWorkspace as deleteWork } from "../../helpers/workspace";
-  createWorkspace as create,
+import { EELicenseService } from "../../ee/services";
-  deleteWorkspace as deleteWork,
-} from "../../helpers/workspace";
 import { addMemberships } from "../../helpers/membership";
 import { ADMIN } from "../../variables";
+import { OrganizationNotFoundError } from "../../utils/errors";
+import {
+  OrgPermissionActions,
+  OrgPermissionSubjects,
+  getUserOrgPermissions
+} from "../../ee/services/RoleService";
+import { ForbiddenError } from "@casl/ability";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  getUserProjectPermissions
+} from "../../ee/services/ProjectRoleService";
 
 /**
  * Return public keys of members of workspace with id [workspaceId]
@@ -24,30 +35,29 @@ import { ADMIN } from "../../variables";
  * @returns
  */
 export const getWorkspacePublicKeys = async (req: Request, res: Response) => {
-  let publicKeys;
+  const {
-  try {
+    params: { workspaceId }
-    const { workspaceId } = req.params;
+  } = await validateRequest(reqValidator.GetWorkspacePublicKeysV1, req);
 
-    publicKeys = (
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-      await Membership.find({
+  ForbiddenError.from(permission).throwUnlessCan(
-        workspace: workspaceId,
+    ProjectPermissionActions.Read,
-      }).populate<{ user: IUser }>("user", "publicKey")
+    ProjectPermissionSub.Member
-    ).map((member) => {
+  );
-      return {
+
-        publicKey: member.user.publicKey,
+  const publicKeys = (
-        userId: member.user._id,
+    await Membership.find({
-      };
+      workspace: workspaceId
-    });
+    }).populate<{ user: IUser }>("user", "publicKey")
-  } catch (err) {
+  ).map((member) => {
-    Sentry.setUser({ email: req.user.email });
+    return {
-    Sentry.captureException(err);
+      publicKey: member.user.publicKey,
-    return res.status(400).send({
+      userId: member.user._id
-      message: "Failed to get workspace member public keys",
+    };
-    });
+  });
-  }
 
   return res.status(200).send({
-    publicKeys,
+    publicKeys
   });
 };
 
@@ -58,23 +68,22 @@ export const getWorkspacePublicKeys = async (req: Request, res: Response) => {
  * @returns
  */
 export const getWorkspaceMemberships = async (req: Request, res: Response) => {
-  let users;
+  const {
-  try {
+    params: { workspaceId }
-    const { workspaceId } = req.params;
+  } = await validateRequest(reqValidator.GetWorkspaceMembershipsV1, req);
 
-    users = await Membership.find({
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-      workspace: workspaceId,
+  ForbiddenError.from(permission).throwUnlessCan(
-    }).populate("user", "+publicKey");
+    ProjectPermissionActions.Read,
-  } catch (err) {
+    ProjectPermissionSub.Member
-    Sentry.setUser({ email: req.user.email });
+  );
-    Sentry.captureException(err);
+
-    return res.status(400).send({
+  const users = await Membership.find({
-      message: "Failed to get workspace members",
+    workspace: workspaceId
-    });
+  }).populate("user", "+publicKey");
-  }
 
   return res.status(200).send({
-    users,
+    users
   });
 };
 
@@ -85,23 +94,14 @@ export const getWorkspaceMemberships = async (req: Request, res: Response) => {
  * @returns
  */
 export const getWorkspaces = async (req: Request, res: Response) => {
-  let workspaces;
+  const workspaces = (
-  try {
+    await Membership.find({
-    workspaces = (
+      user: req.user._id
-      await Membership.find({
+    }).populate("workspace")
-        user: req.user._id,
+  ).map((m) => m.workspace);
-      }).populate("workspace")
-    ).map((m) => m.workspace);
-  } catch (err) {
-    Sentry.setUser({ email: req.user.email });
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: "Failed to get workspaces",
-    });
-  }
 
   return res.status(200).send({
-    workspaces,
+    workspaces
   });
 };
 
@@ -112,23 +112,16 @@ export const getWorkspaces = async (req: Request, res: Response) => {
  * @returns
  */
 export const getWorkspace = async (req: Request, res: Response) => {
-  let workspace;
+  const {
-  try {
+    params: { workspaceId }
-    const { workspaceId } = req.params;
+  } = await validateRequest(reqValidator.GetWorkspaceV1, req);
 
-    workspace = await Workspace.findOne({
+  const workspace = await Workspace.findOne({
-      _id: workspaceId,
+    _id: workspaceId
-    });
+  });
-  } catch (err) {
-    Sentry.setUser({ email: req.user.email });
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: "Failed to get workspace",
-    });
-  }
 
   return res.status(200).send({
-    workspace,
+    workspace
   });
 };
 
@@ -140,45 +133,54 @@ export const getWorkspace = async (req: Request, res: Response) => {
  * @returns
  */
 export const createWorkspace = async (req: Request, res: Response) => {
-  let workspace;
+  const {
-  try {
+    body: { organizationId, workspaceName }
-    const { workspaceName, organizationId } = req.body;
+  } = await validateRequest(reqValidator.CreateWorkspaceV1, req);
 
-    // validate organization membership
+  const organization = await Organization.findById(organizationId);
-    const membershipOrg = await MembershipOrg.findOne({
+  if (!organization) {
-      user: req.user._id,
+    throw OrganizationNotFoundError({
-      organization: organizationId,
+      message: "Failed to find organization"
-    });
-
-    if (!membershipOrg) {
-      throw new Error("Failed to validate organization membership");
-    }
-
-    if (workspaceName.length < 1) {
-      throw new Error("Workspace names must be at least 1-character long");
-    }
-
-    // create workspace and add user as member
-    workspace = await create({
-      name: workspaceName,
-      organizationId,
-    });
-
-    await addMemberships({
-      userIds: [req.user._id],
-      workspaceId: workspace._id.toString(),
-      roles: [ADMIN],
-    });
-  } catch (err) {
-    Sentry.setUser({ email: req.user.email });
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: "Failed to create workspace",
     });
   }
 
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Create,
+    OrgPermissionSubjects.Workspace
+  );
+
+  const plan = await EELicenseService.getPlan(new Types.ObjectId(organizationId));
+
+  if (plan.workspaceLimit !== null) {
+    // case: limit imposed on number of workspaces allowed
+    if (plan.workspacesUsed >= plan.workspaceLimit) {
+      // case: number of workspaces used exceeds the number of workspaces allowed
+      return res.status(400).send({
+        message:
+          "Failed to create workspace due to plan limit reached. Upgrade plan to add more workspaces."
+      });
+    }
+  }
+
+  if (workspaceName.length < 1) {
+    throw new Error("Workspace names must be at least 1-character long");
+  }
+
+  // create workspace and add user as member
+  const workspace = await create({
+    name: workspaceName,
+    organizationId: new Types.ObjectId(organizationId)
+  });
+
+  await addMemberships({
+    userIds: [req.user._id],
+    workspaceId: workspace._id.toString(),
+    roles: [ADMIN]
+  });
+
   return res.status(200).send({
-    workspace,
+    workspace
   });
 };
 
@@ -189,23 +191,23 @@ export const createWorkspace = async (req: Request, res: Response) => {
  * @returns
  */
 export const deleteWorkspace = async (req: Request, res: Response) => {
-  try {
+  const {
-    const { workspaceId } = req.params;
+    params: { workspaceId }
+  } = await validateRequest(reqValidator.DeleteWorkspaceV1, req);
 
-    // delete workspace
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-    await deleteWork({
+  ForbiddenError.from(permission).throwUnlessCan(
-      id: workspaceId,
+    ProjectPermissionActions.Delete,
-    });
+    ProjectPermissionSub.Workspace
-  } catch (err) {
+  );
-    Sentry.setUser({ email: req.user.email });
+
-    Sentry.captureException(err);
+  // delete workspace
-    return res.status(400).send({
+  await deleteWork({
-      message: "Failed to delete workspace",
+    id: workspaceId
-    });
+  });
-  }
 
   return res.status(200).send({
-    message: "Successfully deleted workspace",
+    message: "Successfully deleted workspace"
   });
 };
 
@@ -216,33 +218,32 @@ export const deleteWorkspace = async (req: Request, res: Response) => {
  * @returns
  */
 export const changeWorkspaceName = async (req: Request, res: Response) => {
-  let workspace;
+  const {
-  try {
+    params: { workspaceId },
-    const { workspaceId } = req.params;
+    body: { name }
-    const { name } = req.body;
+  } = await validateRequest(reqValidator.ChangeWorkspaceNameV1, req);
 
-    workspace = await Workspace.findOneAndUpdate(
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-      {
+  ForbiddenError.from(permission).throwUnlessCan(
-        _id: workspaceId,
+    ProjectPermissionActions.Edit,
-      },
+    ProjectPermissionSub.Workspace
-      {
+  );
-        name,
+
-      },
+  const workspace = await Workspace.findOneAndUpdate(
-      {
+    {
-        new: true,
+      _id: workspaceId
-      }
+    },
-    );
+    {
-  } catch (err) {
+      name
-    Sentry.setUser({ email: req.user.email });
+    },
-    Sentry.captureException(err);
+    {
-    return res.status(400).send({
+      new: true
-      message: "Failed to change workspace name",
+    }
-    });
+  );
-  }
 
   return res.status(200).send({
     message: "Successfully changed workspace name",
-    workspace,
+    workspace
   });
 };
 
@@ -253,23 +254,21 @@ export const changeWorkspaceName = async (req: Request, res: Response) => {
  * @returns
  */
 export const getWorkspaceIntegrations = async (req: Request, res: Response) => {
-  let integrations;
+  const {
-  try {
+    params: { workspaceId }
-    const { workspaceId } = req.params;
+  } = await validateRequest(reqValidator.GetWorkspaceIntegrationsV1, req);
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Read,
+    ProjectPermissionSub.Integrations
+  );
 
-    integrations = await Integration.find({
+  const integrations = await Integration.find({
-      workspace: workspaceId,
+    workspace: workspaceId
-    });
+  });
-  } catch (err) {
-    Sentry.setUser({ email: req.user.email });
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: "Failed to get workspace integrations",
-    });
-  }
 
   return res.status(200).send({
-    integrations,
+    integrations
   });
 };
 
@@ -279,27 +278,23 @@ export const getWorkspaceIntegrations = async (req: Request, res: Response) => {
  * @param res
  * @returns
  */
-export const getWorkspaceIntegrationAuthorizations = async (
+export const getWorkspaceIntegrationAuthorizations = async (req: Request, res: Response) => {
-  req: Request,
+  const {
-  res: Response
+    params: { workspaceId }
-) => {
+  } = await validateRequest(reqValidator.GetWorkspaceIntegrationAuthorizationsV1, req);
-  let authorizations;
-  try {
-    const { workspaceId } = req.params;
 
-    authorizations = await IntegrationAuth.find({
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-      workspace: workspaceId,
+  ForbiddenError.from(permission).throwUnlessCan(
-    });
+    ProjectPermissionActions.Read,
-  } catch (err) {
+    ProjectPermissionSub.Integrations
-    Sentry.setUser({ email: req.user.email });
+  );
-    Sentry.captureException(err);
+
-    return res.status(400).send({
+  const authorizations = await IntegrationAuth.find({
-      message: "Failed to get workspace integration authorizations",
+    workspace: workspaceId
-    });
+  });
-  }
 
   return res.status(200).send({
-    authorizations,
+    authorizations
   });
 };
 
@@ -309,27 +304,24 @@ export const getWorkspaceIntegrationAuthorizations = async (
  * @param res
  * @returns
  */
-export const getWorkspaceServiceTokens = async (
+export const getWorkspaceServiceTokens = async (req: Request, res: Response) => {
-  req: Request,
+  const {
-  res: Response
+    params: { workspaceId }
-) => {
+  } = await validateRequest(reqValidator.GetWorkspaceServiceTokensV1, req);
-  let serviceTokens;
+
-  try {
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-    const { workspaceId } = req.params;
+  ForbiddenError.from(permission).throwUnlessCan(
-    // ?? FIX.
+    ProjectPermissionActions.Read,
-    serviceTokens = await ServiceToken.find({
+    ProjectPermissionSub.ServiceTokens
-      user: req.user._id,
+  );
-      workspace: workspaceId,
+
-    });
+  // ?? FIX.
-  } catch (err) {
+  const serviceTokens = await ServiceToken.find({
-    Sentry.setUser({ email: req.user.email });
+    user: req.user._id,
-    Sentry.captureException(err);
+    workspace: workspaceId
-    return res.status(400).send({
+  });
-      message: "Failed to get workspace service tokens",
-    });
-  }
 
   return res.status(200).send({
-    serviceTokens,
+    serviceTokens
   });
 };

backend/src/controllers/v2/apiKeyDataController.ts

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

backend/src/controllers/v2/authController.ts

@@ -1,28 +1,22 @@
 /* eslint-disable @typescript-eslint/no-var-requires */
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import jwt from 'jsonwebtoken';
+import jwt from "jsonwebtoken";
-import * as Sentry from '@sentry/node';
+import * as bigintConversion from "bigint-conversion";
-import * as bigintConversion from 'bigint-conversion';
+const jsrp = require("jsrp");
-const jsrp = require('jsrp');
+import { LoginSRPDetail, User } from "../../models";
-import { User, LoginSRPDetail } from '../../models';
+import { createToken, issueAuthTokens } from "../../helpers/auth";
-import { issueAuthTokens, createToken } from '../../helpers/auth';
+import { checkUserDevice } from "../../helpers/user";
-import { checkUserDevice } from '../../helpers/user';
+import { sendMail } from "../../helpers/nodemailer";
-import { sendMail } from '../../helpers/nodemailer';
+import { TokenService } from "../../services";
-import { TokenService } from '../../services';
+import { EELogService } from "../../ee/services";
-import { EELogService } from '../../ee/services';
+import { BadRequestError, InternalServerError } from "../../utils/errors";
-import { BadRequestError, InternalServerError } from '../../utils/errors';
+import { ACTION_LOGIN, TOKEN_EMAIL_MFA } from "../../variables";
-import {
+import { getUserAgentType } from "../../utils/posthog"; // TODO: move this
-  TOKEN_EMAIL_MFA,
+import { getHttpsEnabled, getJwtMfaLifetime, getJwtMfaSecret } from "../../config";
-  ACTION_LOGIN
+import { validateRequest } from "../../helpers/validation";
-} from '../../variables';
+import * as reqValidator from "../../validation/auth";
-import { getChannelFromUserAgent } from '../../utils/posthog'; // TODO: move this
-import {
-  getJwtMfaLifetime,
-  getJwtMfaSecret,
-  getHttpsEnabled
-} from '../../config';
 
-declare module 'jsonwebtoken' {
+declare module "jsonwebtoken" {
   export interface UserIDJwtPayload extends jwt.JwtPayload {
     userId: string;
   }
@@ -35,47 +29,40 @@ declare module 'jsonwebtoken' {
  * @returns
  */
 export const login1 = async (req: Request, res: Response) => {
-  try {
+  const { email, clientPublicKey }: { email: string; clientPublicKey: string } = req.body;
-    const {
-      email,
-      clientPublicKey
-    }: { email: string; clientPublicKey: string } = req.body;
 
-    const user = await User.findOne({
+  const user = await User.findOne({
-      email
+    email
-    }).select('+salt +verifier');
+  }).select("+salt +verifier");
 
-    if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
 
-    const server = new jsrp.server();
+  const server = new jsrp.server();
-    server.init(
+  server.init(
-      {
+    {
-        salt: user.salt,
+      salt: user.salt,
-        verifier: user.verifier
+      verifier: user.verifier
-      },
+    },
-      async () => {
+    async () => {
-        // generate server-side public key
+      // generate server-side public key
-        const serverPublicKey = server.getPublicKey();
+      const serverPublicKey = server.getPublicKey();
 
-        await LoginSRPDetail.findOneAndReplace({ email: email }, {
+      await LoginSRPDetail.findOneAndReplace(
+        { email: email },
+        {
           email: email,
           clientPublicKey: clientPublicKey,
-          serverBInt: bigintConversion.bigintToBuf(server.bInt),
+          serverBInt: bigintConversion.bigintToBuf(server.bInt)
-        }, { upsert: true, returnNewDocument: false });
+        },
+        { upsert: true, returnNewDocument: false }
+      );
 
-        return res.status(200).send({
+      return res.status(200).send({
-          serverPublicKey,
+        serverPublicKey,
-          salt: user.salt
+        salt: user.salt
-        });
+      });
-      }
+    }
-    );
+  );
-  } catch (err) {
-    Sentry.setUser(null);
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: 'Failed to start authentication process'
-    });
-  }
 };
 
 /**
@@ -86,195 +73,185 @@ export const login1 = async (req: Request, res: Response) => {
  * @returns
  */
 export const login2 = async (req: Request, res: Response) => {
-  try {
+  if (!req.headers["user-agent"])
+    throw InternalServerError({ message: "User-Agent header is required" });
 
-    if (!req.headers['user-agent']) throw InternalServerError({ message: 'User-Agent header is required' });
+  const { email, clientProof } = req.body;
+  const user = await User.findOne({
+    email
+  }).select(
+    "+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag +devices"
+  );
 
-    const { email, clientProof } = req.body;
+  if (!user) throw new Error("Failed to find user");
-    const user = await User.findOne({
-      email
-    }).select('+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag');
 
-    if (!user) throw new Error('Failed to find user');
+  const loginSRPDetail = await LoginSRPDetail.findOneAndDelete({ email: email });
 
-    const loginSRPDetail = await LoginSRPDetail.findOneAndDelete({ email: email })
+  if (!loginSRPDetail) {
+    return BadRequestError(Error("Failed to find login details for SRP"));
+  }
 
-    if (!loginSRPDetail) {
+  const server = new jsrp.server();
-      return BadRequestError(Error("Failed to find login details for SRP"))
+  server.init(
-    }
+    {
+      salt: user.salt,
+      verifier: user.verifier,
+      b: loginSRPDetail.serverBInt
+    },
+    async () => {
+      server.setClientPublicKey(loginSRPDetail.clientPublicKey);
 
-    const server = new jsrp.server();
+      // compare server and client shared keys
-    server.init(
+      if (server.checkClientProof(clientProof)) {
-      {
+        if (user.isMfaEnabled) {
-        salt: user.salt,
+          // case: user has MFA enabled
-        verifier: user.verifier,
-        b: loginSRPDetail.serverBInt
-      },
-      async () => {
-        server.setClientPublicKey(loginSRPDetail.clientPublicKey);
 
-        // compare server and client shared keys
+          // generate temporary MFA token
-        if (server.checkClientProof(clientProof)) {
+          const token = createToken({
-
+            payload: {
-          if (user.isMfaEnabled) {
+              userId: user._id.toString()
-            // case: user has MFA enabled
+            },
-
+            expiresIn: await getJwtMfaLifetime(),
-            // generate temporary MFA token
+            secret: await getJwtMfaSecret()
-            const token = createToken({
-              payload: {
-                userId: user._id.toString()
-              },
-              expiresIn: await getJwtMfaLifetime(),
-              secret: await getJwtMfaSecret()
-            });
-
-            const code = await TokenService.createToken({
-              type: TOKEN_EMAIL_MFA,
-              email
-            });
-
-            // send MFA code [code] to [email]
-            await sendMail({
-              template: 'emailMfa.handlebars',
-              subjectLine: 'Infisical MFA code',
-              recipients: [email],
-              substitutions: {
-                code
-              }
-            });
-
-            return res.status(200).send({
-              mfaEnabled: true,
-              token
-            });
-          }
-
-          await checkUserDevice({
-            user,
-            ip: req.ip,
-            userAgent: req.headers['user-agent'] ?? ''
           });
 
-          // issue tokens
+          const code = await TokenService.createToken({
-          const tokens = await issueAuthTokens({ userId: user._id.toString() });
+            type: TOKEN_EMAIL_MFA,
-
+            email
-          // store (refresh) token in httpOnly cookie
-          res.cookie('jid', tokens.refreshToken, {
-            httpOnly: true,
-            path: '/',
-            sameSite: 'strict',
-            secure: await getHttpsEnabled()
           });
 
-          // case: user does not have MFA enablgged
+          // send MFA code [code] to [email]
-          // return (access) token in response
+          await sendMail({
-
+            template: "emailMfa.handlebars",
-          interface ResponseData {
+            subjectLine: "Infisical MFA code",
-            mfaEnabled: boolean;
+            recipients: [email],
-            encryptionVersion: any;
+            substitutions: {
-            protectedKey?: string;
+              code
-            protectedKeyIV?: string;
+            }
-            protectedKeyTag?: string;
-            token: string;
-            publicKey?: string;
-            encryptedPrivateKey?: string;
-            iv?: string;
-            tag?: string;
-          }
-
-          const response: ResponseData = {
-            mfaEnabled: false,
-            encryptionVersion: user.encryptionVersion,
-            token: tokens.token,
-            publicKey: user.publicKey,
-            encryptedPrivateKey: user.encryptedPrivateKey,
-            iv: user.iv,
-            tag: user.tag
-          }
-
-          if (
-            user?.protectedKey &&
-            user?.protectedKeyIV &&
-            user?.protectedKeyTag
-          ) {
-            response.protectedKey = user.protectedKey;
-            response.protectedKeyIV = user.protectedKeyIV
-            response.protectedKeyTag = user.protectedKeyTag;
-          }
-
-          const loginAction = await EELogService.createAction({
-            name: ACTION_LOGIN,
-            userId: user._id
           });
 
-          loginAction && await EELogService.createLog({
+          return res.status(200).send({
-            userId: user._id,
+            mfaEnabled: true,
-            actions: [loginAction],
+            token
-            channel: getChannelFromUserAgent(req.headers['user-agent']),
-            ipAddress: req.ip
           });
-
-          return res.status(200).send(response);
         }
 
-        return res.status(400).send({
+        await checkUserDevice({
-          message: 'Failed to authenticate. Try again?'
+          user,
+          ip: req.realIP,
+          userAgent: req.headers["user-agent"] ?? ""
         });
+
+        // issue tokens
+        const tokens = await issueAuthTokens({
+          userId: user._id,
+          ip: req.realIP,
+          userAgent: req.headers["user-agent"] ?? ""
+        });
+
+        // store (refresh) token in httpOnly cookie
+        res.cookie("jid", tokens.refreshToken, {
+          httpOnly: true,
+          path: "/",
+          sameSite: "strict",
+          secure: await getHttpsEnabled()
+        });
+
+        // case: user does not have MFA enabled
+        // return (access) token in response
+
+        interface ResponseData {
+          mfaEnabled: boolean;
+          encryptionVersion: any;
+          protectedKey?: string;
+          protectedKeyIV?: string;
+          protectedKeyTag?: string;
+          token: string;
+          publicKey?: string;
+          encryptedPrivateKey?: string;
+          iv?: string;
+          tag?: string;
+        }
+
+        const response: ResponseData = {
+          mfaEnabled: false,
+          encryptionVersion: user.encryptionVersion,
+          token: tokens.token,
+          publicKey: user.publicKey,
+          encryptedPrivateKey: user.encryptedPrivateKey,
+          iv: user.iv,
+          tag: user.tag
+        };
+
+        if (user?.protectedKey && user?.protectedKeyIV && user?.protectedKeyTag) {
+          response.protectedKey = user.protectedKey;
+          response.protectedKeyIV = user.protectedKeyIV;
+          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);
       }
-    );
+
-  } catch (err) {
+      return res.status(400).send({
-    Sentry.setUser(null);
+        message: "Failed to authenticate. Try again?"
-    Sentry.captureException(err);
+      });
-    return res.status(400).send({
+    }
-      message: 'Failed to authenticate. Try again?'
+  );
-    });
-  }
 };
 
 /**
  * Send MFA token to email [email]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
  */
 export const sendMfaToken = async (req: Request, res: Response) => {
-  try {
+  const {
-    const { email } = req.body;
+    body: { email }
+  } = await validateRequest(reqValidator.SendMfaTokenV2, req);
 
-    const code = await TokenService.createToken({
+  const code = await TokenService.createToken({
-      type: TOKEN_EMAIL_MFA,
+    type: TOKEN_EMAIL_MFA,
-      email
+    email
-    });
+  });
 
-    // send MFA code [code] to [email]
+  // send MFA code [code] to [email]
-    await sendMail({
+  await sendMail({
-      template: 'emailMfa.handlebars',
+    template: "emailMfa.handlebars",
-      subjectLine: 'Infisical MFA code',
+    subjectLine: "Infisical MFA code",
-      recipients: [email],
+    recipients: [email],
-      substitutions: {
+    substitutions: {
-        code
+      code
-      }
+    }
-    });
+  });
-  } catch (err) {
-    Sentry.setUser(null);
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: 'Failed to send MFA code'
-    });
-  }
 
   return res.status(200).send({
-    message: 'Successfully sent new MFA code'
+    message: "Successfully sent new MFA code"
   });
-}
+};
 
 /**
  * Verify MFA token [mfaToken] and issue JWT and refresh tokens if the
  * MFA token [mfaToken] is valid
- * @param req 
+ * @param req
- * @param res 
+ * @param res
  */
 export const verifyMfaToken = async (req: Request, res: Response) => {
-  const { email, mfaToken } = req.body;
+  const {
+    body: { email, mfaToken }
+  } = await validateRequest(reqValidator.VerifyMfaTokenV2, req);
 
   await TokenService.validateToken({
     type: TOKEN_EMAIL_MFA,
@@ -284,24 +261,32 @@ export const verifyMfaToken = async (req: Request, res: Response) => {
 
   const user = await User.findOne({
     email
-  }).select('+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag');
+  }).select(
+    "+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag +devices"
+  );
 
-  if (!user) throw new Error('Failed to find user');
+  if (!user) throw new Error("Failed to find user");
+
+  await LoginSRPDetail.deleteOne({ userId: user.id });
 
   await checkUserDevice({
     user,
-    ip: req.ip,
+    ip: req.realIP,
-    userAgent: req.headers['user-agent'] ?? ''
+    userAgent: req.headers["user-agent"] ?? ""
   });
 
   // issue tokens
-  const tokens = await issueAuthTokens({ userId: user._id.toString() });
+  const tokens = await issueAuthTokens({
+    userId: user._id,
+    ip: req.realIP,
+    userAgent: req.headers["user-agent"] ?? ""
+  });
 
   // store (refresh) token in httpOnly cookie
-  res.cookie('jid', tokens.refreshToken, {
+  res.cookie("jid", tokens.refreshToken, {
     httpOnly: true,
-    path: '/',
+    path: "/",
-    sameSite: 'strict',
+    sameSite: "strict",
     secure: await getHttpsEnabled()
   });
 
@@ -336,7 +321,7 @@ export const verifyMfaToken = async (req: Request, res: Response) => {
     encryptedPrivateKey: user.encryptedPrivateKey as string,
     iv: user.iv as string,
     tag: user.tag as string
-  }
+  };
 
   if (user?.protectedKey && user?.protectedKeyIV && user?.protectedKeyTag) {
     resObj.protectedKey = user.protectedKey;
@@ -349,12 +334,13 @@ export const verifyMfaToken = async (req: Request, res: Response) => {
     userId: user._id
   });
 
-  loginAction && await EELogService.createLog({
+  loginAction &&
-    userId: user._id,
+    (await EELogService.createLog({
-    actions: [loginAction],
+      userId: user._id,
-    channel: getChannelFromUserAgent(req.headers['user-agent']),
+      actions: [loginAction],
-    ipAddress: req.ip
+      channel: getUserAgentType(req.headers["user-agent"]),
-  });
+      ipAddress: req.realIP
+    }));
 
   return res.status(200).send(resObj);
-}
+};

backend/src/controllers/v2/environmentController.ts

@@ -1,61 +1,236 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
+import { Types } from "mongoose";
 import {
+  Integration,
+  Membership,
   Secret,
   ServiceToken,
-  Workspace,
-  Integration,
   ServiceTokenData,
-  Membership,
+  Workspace
-} from '../../models';
+} from "../../models";
-import { SecretVersion } from '../../ee/models';
+import { EventType, SecretVersion } from "../../ee/models";
-import { BadRequestError } from '../../utils/errors';
+import { EEAuditLogService, EELicenseService } from "../../ee/services";
-import _ from 'lodash';
+import { BadRequestError, WorkspaceNotFoundError } from "../../utils/errors";
-import { PERMISSION_READ_SECRETS, PERMISSION_WRITE_SECRETS } from '../../variables';
+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,
+  getUserProjectPermissions
+} from "../../ee/services/ProjectRoleService";
+import { ForbiddenError } from "@casl/ability";
 
 /**
- * Create new workspace environment named [environmentName] under workspace with id
+ * Create new workspace environment named [environmentName] 
+ * with slug [environmentSlug] under workspace with id
  * @param req
  * @param res
  * @returns
  */
-export const createWorkspaceEnvironment = async (
+export const createWorkspaceEnvironment = async (req: Request, res: Response) => {
-  req: Request,
+  /* 
-  res: Response
+    #swagger.summary = 'Create environment'
-) => {
+    #swagger.description = 'Create environment'
-  const { workspaceId } = req.params;
+    
-  const { environmentName, environmentSlug } = req.body;
+    #swagger.security = [{
-  try {
+        "apiKeyAuth": []
-    const workspace = await Workspace.findById(workspaceId).exec();
+    }]
-    if (
-      !workspace ||
-      workspace?.environments.find(
-        ({ name, slug }) => slug === environmentSlug || environmentName === name
-      )
-    ) {
-      throw new Error('Failed to create workspace environment');
-    }
 
-    workspace?.environments.push({
+	#swagger.parameters['workspaceId'] = {
-      name: environmentName,
+		"description": "ID of project",
-      slug: environmentSlug.toLowerCase(),
+		"required": true,
-    });
+		"type": "string"
-    await workspace.save();
+	} 
-  } catch (err) {
+
-    Sentry.setUser({ email: req.user.email });
+  /* 
-    Sentry.captureException(err);
+    #swagger.summary = 'Create environment'
-    return res.status(400).send({
+    #swagger.description = 'Create environment'
-      message: 'Failed to create new workspace environment',
+    
-    });
+    #swagger.security = [{
+        "apiKeyAuth": []
+    }]
+
+	#swagger.parameters['workspaceId'] = {
+		"description": "ID of project",
+		"required": true,
+		"type": "string"
+	} 
+
+  #swagger.requestBody = {
+      content: {
+          "application/json": {
+              "schema": {
+                  "type": "object",
+                  "properties": {
+                      "environmentName": {
+                          "type": "string",
+                          "description": "Name of the environment",
+                          "example": "development"
+                      },
+                      "environmentSlug": {
+                          "type": "string",
+                          "description": "Slug of the environment",
+                          "example": "dev-environment"
+                      }
+                  },
+                  "required": ["environmentName", "environmentSlug"]
+              }
+          }
+      }
   }
 
+  #swagger.responses[200] = {
+      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 getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Create,
+    ProjectPermissionSub.Environments
+  );
+
+  const workspace = await Workspace.findById(workspaceId).exec();
+
+  if (!workspace) throw WorkspaceNotFoundError();
+
+  const plan = await EELicenseService.getPlan(workspace.organization);
+
+  if (plan.environmentLimit !== null) {
+    // case: limit imposed on number of environments allowed
+    if (workspace.environments.length >= plan.environmentLimit) {
+      // case: number of environments used exceeds the number of environments allowed
+
+      return res.status(400).send({
+        message:
+          "Failed to create environment due to environment limit reached. Upgrade plan to create more environments."
+      });
+    }
+  }
+
+  if (
+    !workspace ||
+    workspace?.environments.find(
+      ({ name, slug }) => slug === environmentSlug || environmentName === name
+    )
+  ) {
+    throw new Error("Failed to create workspace environment");
+  }
+
+  workspace?.environments.push({
+    name: environmentName,
+    slug: environmentSlug.toLowerCase()
+  });
+  await workspace.save();
+
+  await EELicenseService.refreshPlan(workspace.organization, new Types.ObjectId(workspaceId));
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.CREATE_ENVIRONMENT,
+      metadata: {
+        name: environmentName,
+        slug: environmentSlug
+      }
+    },
+    {
+      workspaceId: workspace._id
+    }
+  );
+
   return res.status(200).send({
-    message: 'Successfully created new environment',
+    message: "Successfully created new environment",
     workspace: workspaceId,
     environment: {
       name: environmentName,
-      slug: environmentSlug,
+      slug: environmentSlug
-    },
+    }
+  });
+};
+
+/**
+ * Swaps the ordering of two environments in the database. This is purely for aesthetic purposes.
+ * @param req
+ * @param res
+ * @returns
+ */
+export const reorderWorkspaceEnvironments = async (req: Request, res: Response) => {
+  const {
+    params: { workspaceId },
+    body: { environmentName, environmentSlug, otherEnvironmentSlug, otherEnvironmentName }
+  } = await validateRequest(reqValidator.ReorderWorkspaceEnvironmentsV2, req);
+
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Edit,
+    ProjectPermissionSub.Environments
+  );
+
+  // atomic update the env to avoid conflict
+  const workspace = await Workspace.findById(workspaceId).exec();
+  if (!workspace) {
+    throw BadRequestError({ message: "Couldn't load workspace" });
+  }
+
+  const environmentIndex = workspace.environments.findIndex(
+    (env) => env.name === environmentName && env.slug === environmentSlug
+  );
+  const otherEnvironmentIndex = workspace.environments.findIndex(
+    (env) => env.name === otherEnvironmentName && env.slug === otherEnvironmentSlug
+  );
+
+  if (environmentIndex === -1 || otherEnvironmentIndex === -1) {
+    throw BadRequestError({ message: "environment or otherEnvironment couldn't be found" });
+  }
+
+  // swap the order of the environments
+  [workspace.environments[environmentIndex], workspace.environments[otherEnvironmentIndex]] = [
+    workspace.environments[otherEnvironmentIndex],
+    workspace.environments[environmentIndex]
+  ];
+
+  await workspace.save();
+
+  return res.status(200).send({
+    message: "Successfully reordered environments",
+    workspace: workspaceId
   });
 };
 
@@ -66,88 +241,173 @@ export const createWorkspaceEnvironment = async (
  * @param res
  * @returns
  */
-export const renameWorkspaceEnvironment = async (
+export const renameWorkspaceEnvironment = async (req: Request, res: Response) => {
-  req: Request,
+  /* 
-  res: Response
+    #swagger.summary = 'Rename workspace environment'
-) => {
+    #swagger.description = 'Rename a specific environment within a workspace'
-  const { workspaceId } = req.params;
-  const { environmentName, environmentSlug, oldEnvironmentSlug } = req.body;
-  try {
-    // user should pass both new slug and env name
-    if (!environmentSlug || !environmentName) {
-      throw new Error('Invalid environment given.');
-    }
 
-    // atomic update the env to avoid conflict
+    #swagger.parameters['workspaceId'] = {
-    const workspace = await Workspace.findById(workspaceId).exec();
+    "description": "ID of the workspace",
-    if (!workspace) {
+    "required": true,
-      throw new Error('Failed to create workspace environment');
+    "type": "string",
-    }
+        "in": "path"
-
-    const isEnvExist = workspace.environments.some(
-      ({ name, slug }) =>
-        slug !== oldEnvironmentSlug &&
-        (name === environmentName || slug === environmentSlug)
-    );
-    if (isEnvExist) {
-      throw new Error('Invalid environment given');
-    }
-
-    const envIndex = workspace?.environments.findIndex(
-      ({ slug }) => slug === oldEnvironmentSlug
-    );
-    if (envIndex === -1) {
-      throw new Error('Invalid environment given');
-    }
-
-    workspace.environments[envIndex].name = environmentName;
-    workspace.environments[envIndex].slug = environmentSlug.toLowerCase();
-
-    await workspace.save();
-    await Secret.updateMany(
-      { workspace: workspaceId, environment: oldEnvironmentSlug },
-      { environment: environmentSlug }
-    );
-    await SecretVersion.updateMany(
-      { workspace: workspaceId, environment: oldEnvironmentSlug },
-      { environment: environmentSlug }
-    );
-    await ServiceToken.updateMany(
-      { workspace: workspaceId, environment: oldEnvironmentSlug },
-      { environment: environmentSlug }
-    );
-    await ServiceTokenData.updateMany(
-      { workspace: workspaceId, environment: oldEnvironmentSlug },
-      { environment: environmentSlug }
-    );
-    await Integration.updateMany(
-      { workspace: workspaceId, environment: oldEnvironmentSlug },
-      { environment: environmentSlug }
-    );
-    await Membership.updateMany(
-      {
-        workspace: workspaceId,
-        "deniedPermissions.environmentSlug": oldEnvironmentSlug
-      },
-      { $set: { "deniedPermissions.$[element].environmentSlug": environmentSlug } },
-      { arrayFilters: [{ "element.environmentSlug": oldEnvironmentSlug }] }
-    )
-
-  } catch (err) {
-    Sentry.setUser({ email: req.user.email });
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: 'Failed to update workspace environment',
-    });
   }
 
+    #swagger.requestBody = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "environmentName": {
+                            "type": "string",
+                            "description": "New name for the environment",
+                            "example": "Staging-Renamed"
+                        },
+                        "environmentSlug": {
+                            "type": "string",
+                            "description": "New slug for the environment",
+                            "example": "staging-renamed"
+                        },
+                        "oldEnvironmentSlug": {
+                            "type": "string",
+                            "description": "Current slug of the environment to rename",
+                            "example": "staging-old"
+                        }
+                    },
+                    "required": ["environmentName", "environmentSlug", "oldEnvironmentSlug"]
+                }
+            }
+        }
+    }
+
+    #swagger.responses[200] = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "message": {
+                            "type": "string",
+                            "example": "Successfully update environment"
+                        },
+                        "workspace": {
+                            "type": "string",
+                            "example": "someWorkspaceId"
+                        },
+                        "environment": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                    "example": "Staging-Renamed"
+                                },
+                                "slug": {
+                                    "type": "string",
+                                    "example": "staging-renamed"
+                                }
+                            }
+                        }
+                    },
+                    "description": "Details of the renamed environment"
+                }
+            }
+        }
+    }   
+  */
+  const {
+    params: { workspaceId },
+    body: { environmentName, environmentSlug, oldEnvironmentSlug }
+  } = await validateRequest(reqValidator.UpdateWorkspaceEnvironmentV2, req);
+
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Edit,
+    ProjectPermissionSub.Environments
+  );
+
+  // user should pass both new slug and env name
+  if (!environmentSlug || !environmentName) {
+    throw new Error("Invalid environment given.");
+  }
+
+  // atomic update the env to avoid conflict
+  const workspace = await Workspace.findById(workspaceId).exec();
+  if (!workspace) {
+    throw new Error("Failed to create workspace environment");
+  }
+
+  const isEnvExist = workspace.environments.some(
+    ({ name, slug }) =>
+      slug !== oldEnvironmentSlug && (name === environmentName || slug === environmentSlug)
+  );
+  if (isEnvExist) {
+    throw new Error("Invalid environment given");
+  }
+
+  const envIndex = workspace?.environments.findIndex(({ slug }) => slug === oldEnvironmentSlug);
+  if (envIndex === -1) {
+    throw new Error("Invalid environment given");
+  }
+
+  const oldEnvironment = workspace.environments[envIndex];
+
+  workspace.environments[envIndex].name = environmentName;
+  workspace.environments[envIndex].slug = environmentSlug.toLowerCase();
+
+  await workspace.save();
+  await Secret.updateMany(
+    { workspace: workspaceId, environment: oldEnvironmentSlug },
+    { environment: environmentSlug }
+  );
+  await SecretVersion.updateMany(
+    { workspace: workspaceId, environment: oldEnvironmentSlug },
+    { environment: environmentSlug }
+  );
+  await ServiceToken.updateMany(
+    { workspace: workspaceId, environment: oldEnvironmentSlug },
+    { environment: environmentSlug }
+  );
+  await ServiceTokenData.updateMany(
+    { workspace: workspaceId, environment: oldEnvironmentSlug },
+    { environment: environmentSlug }
+  );
+  await Integration.updateMany(
+    { workspace: workspaceId, environment: oldEnvironmentSlug },
+    { environment: environmentSlug }
+  );
+  await Membership.updateMany(
+    {
+      workspace: workspaceId,
+      "deniedPermissions.environmentSlug": oldEnvironmentSlug
+    },
+    { $set: { "deniedPermissions.$[element].environmentSlug": environmentSlug } },
+    { arrayFilters: [{ "element.environmentSlug": oldEnvironmentSlug }] }
+  );
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.UPDATE_ENVIRONMENT,
+      metadata: {
+        oldName: oldEnvironment.name,
+        newName: environmentName,
+        oldSlug: oldEnvironment.slug,
+        newSlug: environmentSlug.toLowerCase()
+      }
+    },
+    {
+      workspaceId: workspace._id
+    }
+  );
+
   return res.status(200).send({
-    message: 'Successfully update environment',
+    message: "Successfully update environment",
     workspace: workspaceId,
     environment: {
       name: environmentName,
-      slug: environmentSlug,
+      slug: environmentSlug
-    },
+    }
   });
 };
 
@@ -157,106 +417,238 @@ export const renameWorkspaceEnvironment = async (
  * @param res
  * @returns
  */
-export const deleteWorkspaceEnvironment = async (
+export const deleteWorkspaceEnvironment = async (req: Request, res: Response) => {
-  req: Request,
+  /* 
-  res: Response
+    #swagger.summary = 'Delete workspace environment'
-) => {
+    #swagger.description = 'Delete a specific environment from a workspace'
-  const { workspaceId } = req.params;
+    
-  const { environmentSlug } = req.body;
+    #swagger.security = [{
-  try {
+        "apiKeyAuth": []
-    // atomic update the env to avoid conflict
+    }]
-    const workspace = await Workspace.findById(workspaceId).exec();
+
-    if (!workspace) {
+    #swagger.parameters['workspaceId'] = {
-      throw new Error('Failed to create workspace environment');
+		"description": "ID of the workspace",
+		"required": true,
+		"type": "string",
+        "in": "path"
+	}
+
+    #swagger.requestBody = {
+        content: {
+            "application/json": {
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "environmentSlug": {
+                            "type": "string",
+                            "description": "Slug of the environment to delete",
+                            "example": "dev-environment"
+                        }
+                    },
+                    "required": ["environmentSlug"]
+                }
+            }
+        }
     }
 
-    const envIndex = workspace?.environments.findIndex(
+    #swagger.responses[200] = {
-      ({ slug }) => slug === environmentSlug
+        content: {
-    );
+            "application/json": {
-    if (envIndex === -1) {
+                "schema": { 
-      throw new Error('Invalid environment given');
+                    "type": "object",
-    }
+                    "properties": {
+                        "message": {
+                            "type": "string",
+                            "example": "Successfully deleted environment"
+                        },
+                        "workspace": {
+                            "type": "string",
+                            "example": "someWorkspaceId"
+                        },
+                        "environment": {
+                            "type": "string",
+                            "example": "dev-environment"
+                        }
+                    },
+                    "description": "Response after deleting an environment from a workspace"
+                }
+            }           
+        }
+    }   
+*/
+  const {
+    params: { workspaceId },
+    body: { environmentSlug }
+  } = await validateRequest(reqValidator.DeleteWorkspaceEnvironmentV2, req);
 
-    workspace.environments.splice(envIndex, 1);
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-    await workspace.save();
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Delete,
+    ProjectPermissionSub.Environments
+  );
 
-    // clean up
+  // atomic update the env to avoid conflict
-    await Secret.deleteMany({
+  const workspace = await Workspace.findById(workspaceId).exec();
-      workspace: workspaceId,
+  if (!workspace) {
-      environment: environmentSlug,
+    throw new Error("Failed to create workspace environment");
-    });
-    await SecretVersion.deleteMany({
-      workspace: workspaceId,
-      environment: environmentSlug,
-    });
-    await ServiceToken.deleteMany({
-      workspace: workspaceId,
-      environment: environmentSlug,
-    });
-    await ServiceTokenData.deleteMany({
-      workspace: workspaceId,
-      environment: environmentSlug,
-    });
-    await Integration.deleteMany({
-      workspace: workspaceId,
-      environment: environmentSlug,
-    });
-    await Membership.updateMany(
-      { workspace: workspaceId },
-      { $pull: { deniedPermissions: { environmentSlug: environmentSlug } } }
-    )
-
-  } catch (err) {
-    Sentry.setUser({ email: req.user.email });
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: 'Failed to delete workspace environment',
-    });
   }
 
-  return res.status(200).send({
+  const envIndex = workspace?.environments.findIndex(({ slug }) => slug === environmentSlug);
-    message: 'Successfully deleted environment',
+  if (envIndex === -1) {
+    throw new Error("Invalid environment given");
+  }
+
+  const oldEnvironment = workspace.environments[envIndex];
+
+  workspace.environments.splice(envIndex, 1);
+  await workspace.save();
+
+  // clean up
+  await Secret.deleteMany({
     workspace: workspaceId,
-    environment: environmentSlug,
+    environment: environmentSlug
+  });
+  await SecretVersion.deleteMany({
+    workspace: workspaceId,
+    environment: environmentSlug
+  });
+
+  // await ServiceToken.deleteMany({
+  //   workspace: workspaceId,
+  //   environment: environmentSlug,
+  // });
+
+  const result = await ServiceTokenData.updateMany(
+    { workspace: workspaceId },
+    { $pull: { scopes: { environment: environmentSlug } } }
+  );
+
+  if (result.modifiedCount > 0) {
+    await ServiceTokenData.deleteMany({ workspace: workspaceId, scopes: { $size: 0 } });
+  }
+
+  await Integration.deleteMany({
+    workspace: workspaceId,
+    environment: environmentSlug
+  });
+  await Membership.updateMany(
+    { workspace: workspaceId },
+    { $pull: { deniedPermissions: { environmentSlug: environmentSlug } } }
+  );
+
+  await EELicenseService.refreshPlan(workspace.organization, new Types.ObjectId(workspaceId));
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.DELETE_ENVIRONMENT,
+      metadata: {
+        name: oldEnvironment.name,
+        slug: oldEnvironment.slug
+      }
+    },
+    {
+      workspaceId: workspace._id
+    }
+  );
+
+  return res.status(200).send({
+    message: "Successfully deleted environment",
+    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": []
+    }]
 
-export const getAllAccessibleEnvironmentsOfWorkspace = async (
+    #swagger.parameters['workspaceId'] = {
-  req: Request,
+		"description": "ID of the workspace",
-  res: Response
+		"required": true,
-) => {
+		"type": "string",
-  const { workspaceId } = req.params;
+        "in": "path"
-  const workspacesUserIsMemberOf = await Membership.findOne({
+	}
-    workspace: workspaceId,
-    user: req.user
-  })
 
-  if (!workspacesUserIsMemberOf) {
+    #swagger.responses[200] = {
-    throw BadRequestError()
+        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 accessibleEnvironments: any = []
+  const { membership: workspacesUserIsMemberOf } = await getUserProjectPermissions(
-  const deniedPermission = workspacesUserIsMemberOf.deniedPermissions
+    req.user._id,
+    workspaceId
+  );
 
-  const relatedWorkspace = await Workspace.findById(workspaceId)
+  const accessibleEnvironments: any = [];
+  const deniedPermission = workspacesUserIsMemberOf.deniedPermissions;
+
+  const relatedWorkspace = await Workspace.findById(workspaceId);
   if (!relatedWorkspace) {
-    throw BadRequestError()
+    throw BadRequestError();
   }
-  relatedWorkspace.environments.forEach(environment => {
+  relatedWorkspace.environments.forEach((environment) => {
-    const isReadBlocked = _.some(deniedPermission, { environmentSlug: environment.slug, ability: PERMISSION_READ_SECRETS })
+    const isReadBlocked = _.some(deniedPermission, {
-    const isWriteBlocked = _.some(deniedPermission, { environmentSlug: environment.slug, ability: PERMISSION_WRITE_SECRETS })
+      environmentSlug: environment.slug,
+      ability: PERMISSION_READ_SECRETS
+    });
+    const isWriteBlocked = _.some(deniedPermission, {
+      environmentSlug: environment.slug,
+      ability: PERMISSION_WRITE_SECRETS
+    });
     if (isReadBlocked && isWriteBlocked) {
-      return
+      return;
     } else {
       accessibleEnvironments.push({
         name: environment.name,
         slug: environment.slug,
         isWriteDenied: isWriteBlocked,
         isReadDenied: isReadBlocked
-      })
+      });
     }
-  })
+  });
 
-  res.json({ accessibleEnvironments })
+  res.json({ accessibleEnvironments });
 };

backend/src/controllers/v2/index.ts

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

backend/src/controllers/v2/organizationsController.ts

@@ -1,22 +1,27 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
+import { Types } from "mongoose";
-import { Types } from 'mongoose';
+import { Membership, MembershipOrg, ServiceAccount, Workspace } from "../../models";
-import { 
+import { deleteMembershipOrg } from "../../helpers/membershipOrg";
-    MembershipOrg,
+import { updateSubscriptionOrgQuantity } from "../../helpers/organization";
-    Membership,
+import Role from "../../ee/models/role";
-    Workspace,
+import { BadRequestError } from "../../utils/errors";
-    ServiceAccount
+import { CUSTOM } from "../../variables";
-} from '../../models';
+import * as reqValidator from "../../validation/organization";
-import { deleteMembershipOrg } from '../../helpers/membershipOrg';
+import { validateRequest } from "../../helpers/validation";
-import { updateSubscriptionOrgQuantity } from '../../helpers/organization';
+import {
+  OrgPermissionActions,
+  OrgPermissionSubjects,
+  getUserOrgPermissions
+} from "../../ee/services/RoleService";
+import { ForbiddenError } from "@casl/ability";
 
 /**
  * Return memberships for organization with id [organizationId]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
  */
 export const getOrganizationMemberships = async (req: Request, res: Response) => {
-    /* 
+  /* 
     #swagger.summary = 'Return organization memberships'
     #swagger.description = 'Return organization memberships'
     
@@ -49,33 +54,32 @@ export const getOrganizationMemberships = async (req: Request, res: Response) =>
         }
     }   
     */
-    let memberships;
+  const {
-    try {
+    params: { organizationId }
-        const { organizationId } = req.params;
+  } = await validateRequest(reqValidator.GetOrgMembersv2, req);
 
-		memberships = await MembershipOrg.find({
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-			organization: organizationId
+  ForbiddenError.from(permission).throwUnlessCan(
-		}).populate('user', '+publicKey');
+    OrgPermissionActions.Read,
-    } catch (err) {
+    OrgPermissionSubjects.Member
-        Sentry.setUser({ email: req.user.email });
+  );
-		Sentry.captureException(err);
+
-		return res.status(400).send({
+  const memberships = await MembershipOrg.find({
-			message: 'Failed to get organization memberships'
+    organization: organizationId
-		});
+  }).populate("user", "+publicKey");
-    }
+
-    
+  return res.status(200).send({
-    return res.status(200).send({
+    memberships
-        memberships
+  });
-    });
+};
-}
 
 /**
  * Update role of membership with id [membershipId] to role [role]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
  */
 export const updateOrganizationMembership = async (req: Request, res: Response) => {
-    /* 
+  /* 
     #swagger.summary = 'Update organization membership'
     #swagger.description = 'Update organization membership'
     
@@ -128,40 +132,58 @@ export const updateOrganizationMembership = async (req: Request, res: Response)
         }
     }   
     */
-    let membership;
+  const {
-    try {
+    params: { organizationId, membershipId },
-        const { membershipId } = req.params;
+    body: { role }
-        const { role } = req.body;
+  } = await validateRequest(reqValidator.UpdateOrgMemberv2, req);
-        
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-        membership = await MembershipOrg.findByIdAndUpdate(
+  ForbiddenError.from(permission).throwUnlessCan(
-            membershipId,
+    OrgPermissionActions.Edit,
-            {
+    OrgPermissionSubjects.Member
-                role
+  );
-            }, {
+
-                new: true
+  const isCustomRole = !["admin", "member", "owner"].includes(role);
-            }
+  if (isCustomRole) {
-        );
+    const orgRole = await Role.findOne({ slug: role, isOrgRole: true });
-    } catch (err) {
+    if (!orgRole) throw BadRequestError({ message: "Role not found" });
-        Sentry.setUser({ email: req.user.email });
+
-		Sentry.captureException(err);
+    const membership = await MembershipOrg.findByIdAndUpdate(membershipId, {
-		return res.status(400).send({
+      role: CUSTOM,
-			message: 'Failed to update organization membership'
+      customRole: orgRole
-		});
-    }
-    
-    return res.status(200).send({
-        membership
     });
-}
+    return res.status(200).send({
+      membership
+    });
+  }
+
+  const membership = await MembershipOrg.findByIdAndUpdate(
+    membershipId,
+    {
+      $set: {
+        role
+      },
+      $unset: {
+        customRole: 1
+      }
+    },
+    {
+      new: true
+    }
+  );
+
+  return res.status(200).send({
+    membership
+  });
+};
 
 /**
  * Delete organization membership with id [membershipId]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const deleteOrganizationMembership = async (req: Request, res: Response) => {
-    /* 
+  /* 
     #swagger.summary = 'Delete organization membership'
     #swagger.description = 'Delete organization membership'
     
@@ -197,39 +219,37 @@ export const deleteOrganizationMembership = async (req: Request, res: Response)
         }
     }   
     */
-    let membership;
+  const {
-    try {
+    params: { organizationId, membershipId }
-        const { membershipId } = req.params;
+  } = await validateRequest(reqValidator.DeleteOrgMemberv2, req);
-        
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-        // delete organization membership
+  ForbiddenError.from(permission).throwUnlessCan(
-        membership = await deleteMembershipOrg({
+    OrgPermissionActions.Delete,
-            membershipOrgId: membershipId
+    OrgPermissionSubjects.Member
-        });
+  );
 
-        await updateSubscriptionOrgQuantity({
+  // delete organization membership
-			organizationId: membership.organization.toString()
+  const membership = await deleteMembershipOrg({
-		});
+    membershipOrgId: membershipId
-    } catch (err) {
+  });
-        Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to delete organization membership'
-		});	
-    }
 
-    return res.status(200).send({
+  await updateSubscriptionOrgQuantity({
-        membership
+    organizationId: membership.organization.toString()
-    });
+  });
-}
+
+  return res.status(200).send({
+    membership
+  });
+};
 
 /**
  * Return workspaces for organization with id [organizationId] that user has
  * access to
- * @param req 
+ * @param req
- * @param res 
+ * @param res
  */
 export const getOrganizationWorkspaces = async (req: Request, res: Response) => {
-    /* 
+  /* 
     #swagger.summary = 'Return projects in organization that user is part of'
     #swagger.description = 'Return projects in organization that user is part of'
     
@@ -262,45 +282,53 @@ export const getOrganizationWorkspaces = async (req: Request, res: Response) =>
         }
     }   
     */
-    const { organizationId } = req.params;
+  const {
+    params: { organizationId }
+  } = await validateRequest(reqValidator.GetOrgWorkspacesv2, req);
 
-    const workspacesSet = new Set(
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-        (
+  ForbiddenError.from(permission).throwUnlessCan(
-            await Workspace.find(
+    OrgPermissionActions.Read,
-                {
+    OrgPermissionSubjects.Workspace
-                    organization: organizationId
+  );
-                },
-                '_id'
-            )
-        ).map((w) => w._id.toString())
-    );
 
-    const workspaces = (
+  const workspacesSet = new Set(
-        await Membership.find({
+    (
-            user: req.user._id
+      await Workspace.find(
-        }).populate('workspace')
+        {
-    )
+          organization: organizationId
+        },
+        "_id"
+      )
+    ).map((w) => w._id.toString())
+  );
+
+  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({
+  return res.status(200).send({
-        workspaces
+    workspaces
-    });
+  });
-}
+};
 
 /**
  * Return service accounts for organization with id [organizationId]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
  */
 export const getOrganizationServiceAccounts = async (req: Request, res: Response) => {
-    const { organizationId } = req.params;
+  const { organizationId } = req.params;
-    
+
-    const serviceAccounts = await ServiceAccount.find({
+  const serviceAccounts = await ServiceAccount.find({
-        organization: new Types.ObjectId(organizationId)
+    organization: new Types.ObjectId(organizationId)
-    });
+  });
-    
+
-    return res.status(200).send({
+  return res.status(200).send({
-        serviceAccounts
+    serviceAccounts
-    });
+  });
-}
+};

backend/src/controllers/v2/secretController.ts

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

backend/src/controllers/v2/serviceAccountsController.ts

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

backend/src/controllers/v2/serviceTokenDataController.ts

@@ -1,30 +1,29 @@
-import * as Sentry from '@sentry/node';
+import { Request, Response } from "express";
-import { Request, Response } from 'express';
+import crypto from "crypto";
-import crypto from 'crypto';
+import bcrypt from "bcrypt";
-import bcrypt from 'bcrypt';
+import { ServiceTokenData } from "../../models";
+import { getSaltRounds } from "../../config";
+import { BadRequestError } from "../../utils/errors";
+import { ActorType, EventType } from "../../ee/models";
+import { EEAuditLogService } from "../../ee/services";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/serviceTokenData";
 import {
-    User,
+  ProjectPermissionActions,
-    ServiceAccount,
+  ProjectPermissionSub,
-    ServiceTokenData
+  getUserProjectPermissions
-} from '../../models';
+} from "../../ee/services/ProjectRoleService";
-import { userHasWorkspaceAccess } from '../../ee/helpers/checkMembershipPermissions';
+import { ForbiddenError } from "@casl/ability";
-import { 
+import { Types } from "mongoose";
-    PERMISSION_READ_SECRETS,
-    AUTH_MODE_JWT,
-    AUTH_MODE_SERVICE_ACCOUNT,
-    AUTH_MODE_SERVICE_TOKEN
-} from '../../variables';
-import { getSaltRounds } from '../../config';
-import { BadRequestError } from '../../utils/errors';
 
 /**
  * Return service token data associated with service token on request
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const getServiceTokenData = async (req: Request, res: Response) => {
-    /* 
+  /* 
     #swagger.summary = 'Return Infisical Token data'
     #swagger.description = 'Return Infisical Token data'
     
@@ -37,111 +36,152 @@ export const getServiceTokenData = async (req: Request, res: Response) => {
             "application/json": {
                 "schema": { 
                     "type": "object",
-					"properties": {
+          "properties": {
                         "serviceTokenData": {
                             "type": "object",
                             $ref: "#/components/schemas/ServiceTokenData",
                             "description": "Details of service token"
                         }
-					}
+          }
                 }
             }           
         }
     }   
     */
 
-    if (!(req.authData.authPayload instanceof ServiceTokenData)) throw BadRequestError({
+  if (!(req.authData.authPayload instanceof ServiceTokenData))
-        message: 'Failed accepted client validation for service token data'
+    throw BadRequestError({
+      message: "Failed accepted client validation for service token data"
     });
 
-    const serviceTokenData = await ServiceTokenData
+  const serviceTokenData = await ServiceTokenData.findById(req.authData.authPayload._id)
-        .findById(req.authData.authPayload._id)
+    .select("+encryptedKey +iv +tag")
-        .select('+encryptedKey +iv +tag')
+    .populate("user")
-        .populate('user');
+    .lean();
 
-    return res.status(200).json(serviceTokenData);
+  return res.status(200).json(serviceTokenData);
-}
+};
 
 /**
  * Create new service token data for workspace with id [workspaceId] and
  * environment [environment].
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const createServiceTokenData = async (req: Request, res: Response) => {
-    let serviceTokenData;
+  let serviceTokenData;
 
-    const {
+  const {
+    body: { workspaceId, permissions, tag, encryptedKey, scopes, name, expiresIn, iv }
+  } = await validateRequest(reqValidator.CreateServiceTokenV2, req);
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Create,
+    ProjectPermissionSub.ServiceTokens
+  );
+
+  const secret = crypto.randomBytes(16).toString("hex");
+  const secretHash = await bcrypt.hash(secret, await getSaltRounds());
+
+  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;
+  }
+
+  serviceTokenData = await new ServiceTokenData({
+    name,
+    workspace: workspaceId,
+    user,
+    scopes,
+    lastUsed: new Date(),
+    expiresAt,
+    secretHash,
+    encryptedKey,
+    iv,
+    tag,
+    permissions
+  }).save();
+
+  // return service token data without sensitive data
+  serviceTokenData = await ServiceTokenData.findById(serviceTokenData._id);
+
+  if (!serviceTokenData) throw new Error("Failed to find service token data");
+
+  const serviceToken = `st.${serviceTokenData._id.toString()}.${secret}`;
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.CREATE_SERVICE_TOKEN,
+      metadata: {
         name,
-        workspaceId,
+        scopes
-        environment,
+      }
-        encryptedKey,
+    },
-        iv,
+    {
-        tag,
+      workspaceId: new Types.ObjectId(workspaceId)
-        expiresIn,
-        permissions
-    } = req.body;
-
-    const secret = crypto.randomBytes(16).toString('hex');
-    const secretHash = await bcrypt.hash(secret, await getSaltRounds());
-
-    let expiresAt; 
-    if (expiresIn) {
-        expiresAt = new Date()
-        expiresAt.setSeconds(expiresAt.getSeconds() + expiresIn);
     }
+  );
 
-    let user, serviceAccount;
+  return res.status(200).send({
-    
+    serviceToken,
-    if (req.authData.authMode === AUTH_MODE_JWT && req.authData.authPayload instanceof User) {
+    serviceTokenData
-        user = req.authData.authPayload._id;
+  });
-    }
+};
-
-    if (req.authData.authMode === AUTH_MODE_SERVICE_ACCOUNT && req.authData.authPayload instanceof ServiceAccount) {
-        serviceAccount = req.authData.authPayload._id;
-    }
-        
-    serviceTokenData = await new ServiceTokenData({
-        name,
-        workspace: workspaceId,
-        environment,
-        user,
-        serviceAccount,
-        lastUsed: new Date(),
-        expiresAt,
-        secretHash,
-        encryptedKey,
-        iv,
-        tag,
-        permissions
-    }).save();
-
-    // return service token data without sensitive data
-    serviceTokenData = await ServiceTokenData.findById(serviceTokenData._id);
-
-    if (!serviceTokenData) throw new Error('Failed to find service token data');
-
-    const serviceToken = `st.${serviceTokenData._id.toString()}.${secret}`;
-
-    return res.status(200).send({
-        serviceToken,
-        serviceTokenData
-    });
-}
 
 /**
  * Delete service token data with id [serviceTokenDataId].
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const deleteServiceTokenData = async (req: Request, res: Response) => {
-    const { serviceTokenDataId } = req.params;
+  const {
+    params: { serviceTokenDataId }
+  } = await validateRequest(reqValidator.DeleteServiceTokenV2, req);
 
-    const serviceTokenData = await ServiceTokenData.findByIdAndDelete(serviceTokenDataId);
+  let serviceTokenData = await ServiceTokenData.findById(serviceTokenDataId);
+  if (!serviceTokenData) throw BadRequestError({ 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 ServiceTokenData.findByIdAndDelete(serviceTokenDataId);
+
+  if (!serviceTokenData)
     return res.status(200).send({
-        serviceTokenData
+      message: "Failed to delete service token"
     });
-}
+
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.DELETE_SERVICE_TOKEN,
+      metadata: {
+        name: serviceTokenData.name,
+        scopes: serviceTokenData?.scopes
+      }
+    },
+    {
+      workspaceId: serviceTokenData.workspace
+    }
+  );
+
+  return res.status(200).send({
+    serviceTokenData
+  });
+};

backend/src/controllers/v2/signupController.ts

@@ -1,15 +1,14 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
+import { MembershipOrg, User } from "../../models";
-import { User, MembershipOrg } from '../../models';
+import { completeAccount } from "../../helpers/user";
-import { completeAccount } from '../../helpers/user';
 import {
-	initializeDefaultOrg
+	initializeDefaultOrg,
-} from '../../helpers/signup';
+} from "../../helpers/signup";
-import { issueAuthTokens } from '../../helpers/auth';
+import { issueAuthTokens } from "../../helpers/auth";
-import { INVITED, ACCEPTED } from '../../variables';
+import { ACCEPTED, INVITED } from "../../variables";
-import { standardRequest } from '../../config/request';
+import { standardRequest } from "../../config/request";
-import { getLoopsApiKey, getHttpsEnabled } from '../../config';
+import { getHttpsEnabled, getLoopsApiKey } from "../../config";
-import { updateSubscriptionOrgQuantity } from '../../helpers/organization';
+import { updateSubscriptionOrgQuantity } from "../../helpers/organization";
 
 /**
  * Complete setting up user by adding their personal and auth information as part of the
@@ -19,142 +18,136 @@ import { updateSubscriptionOrgQuantity } from '../../helpers/organization';
  * @returns
  */
 export const completeAccountSignup = async (req: Request, res: Response) => {
-	let user, token, refreshToken;
+	let user;
-	try {
+  const {
-		const {
+    email,
-			email,
+    firstName,
-			firstName,
+    lastName,
-			lastName,
+    protectedKey,
-			protectedKey,
+    protectedKeyIV,
-			protectedKeyIV,
+    protectedKeyTag,
-			protectedKeyTag,
+    publicKey,
-			publicKey,
+    encryptedPrivateKey,
-			encryptedPrivateKey,
+    encryptedPrivateKeyIV,
-			encryptedPrivateKeyIV,
+    encryptedPrivateKeyTag,
-			encryptedPrivateKeyTag,
+    salt,
-			salt,
+    verifier,
-			verifier,
+    organizationName,
-			organizationName
+  }: {
-		}: {
+    email: string;
-			email: string;
+    firstName: string;
-			firstName: string;
+    lastName: string;
-			lastName: string;
+    protectedKey: string;
-			protectedKey: string;
+    protectedKeyIV: string;
-			protectedKeyIV: string;
+    protectedKeyTag: string;
-			protectedKeyTag: string;
+    publicKey: string;
-			publicKey: string;
+    encryptedPrivateKey: string;
-			encryptedPrivateKey: string;
+    encryptedPrivateKeyIV: string;
-			encryptedPrivateKeyIV: string;
+    encryptedPrivateKeyTag: string;
-			encryptedPrivateKeyTag: string;
+    salt: string;
-			salt: string;
+    verifier: string;
-			verifier: string;
+    organizationName: string;
-			organizationName: string;
+  } = req.body;
-		} = req.body;
 
-		// get user
+  // get user
-		user = await User.findOne({ email });
+  user = await User.findOne({ email });
 
-		if (!user || (user && user?.publicKey)) {
+  if (!user || (user && user?.publicKey)) {
-			// case 1: user doesn't exist.
+    // case 1: user doesn't exist.
-			// case 2: user has already completed account
+    // case 2: user has already completed account
-			return res.status(403).send({
+    return res.status(403).send({
-				error: 'Failed to complete account for complete user'
+      error: "Failed to complete account for complete user",
-			});
+    });
-		}
+  }
 
-		// complete setting up user's account
+  // complete setting up user's account
-		user = await completeAccount({
+  user = await completeAccount({
-			userId: user._id.toString(),
+    userId: user._id.toString(),
-			firstName,
+    firstName,
-			lastName,
+    lastName,
-			encryptionVersion: 2,
+    encryptionVersion: 2,
-			protectedKey,
+    protectedKey,
-			protectedKeyIV,
+    protectedKeyIV,
-			protectedKeyTag,
+    protectedKeyTag,
-			publicKey,
+    publicKey,
-			encryptedPrivateKey,
+    encryptedPrivateKey,
-			encryptedPrivateKeyIV,
+    encryptedPrivateKeyIV,
-			encryptedPrivateKeyTag,
+    encryptedPrivateKeyTag,
-			salt,
+    salt,
-			verifier
+    verifier,
-		});
+  });
 
-		if (!user)
+  if (!user)
-			throw new Error('Failed to complete account for non-existent user'); // ensure user is non-null
+    throw new Error("Failed to complete account for non-existent user"); // ensure user is non-null
 
-		// initialize default organization and workspace
+  // initialize default organization and workspace
-		await initializeDefaultOrg({
+  await initializeDefaultOrg({
-			organizationName,
+    organizationName,
-			user
+    user,
-		});
+  });
 
-		// update organization membership statuses that are
+  // update organization membership statuses that are
-		// invited to completed with user attached
+  // invited to completed with user attached
-		const membershipsToUpdate = await MembershipOrg.find({
+  const membershipsToUpdate = await MembershipOrg.find({
-			inviteEmail: email,
+    inviteEmail: email,
-			status: INVITED
+    status: INVITED,
-		});
+  });
-		
+  
-		membershipsToUpdate.forEach(async (membership) => {
+  membershipsToUpdate.forEach(async (membership) => {
-			await updateSubscriptionOrgQuantity({
+    await updateSubscriptionOrgQuantity({
-				organizationId: membership.organization.toString()
+      organizationId: membership.organization.toString(),
-			});
+    });
-		});
+  });
 
-		// update organization membership statuses that are
+  // update organization membership statuses that are
-		// invited to completed with user attached
+  // invited to completed with user attached
-		await MembershipOrg.updateMany(
+  await MembershipOrg.updateMany(
-			{
+    {
-				inviteEmail: email,
+      inviteEmail: email,
-				status: INVITED
+      status: INVITED,
-			},
+    },
-			{
+    {
-				user,
+      user,
-				status: ACCEPTED
+      status: ACCEPTED,
-			}
+    }
-		);
+  );
 
-		// issue tokens
+  // issue tokens
-		const tokens = await issueAuthTokens({
+  const tokens = await issueAuthTokens({
-			userId: user._id.toString()
+    userId: user._id,
-		});
+    ip: req.realIP,
+    userAgent: req.headers["user-agent"] ?? "",
+  });
 
-		token = tokens.token;
+  const token = tokens.token;
 
-		// sending a welcome email to new users
+  // sending a welcome email to new users
-		if (await getLoopsApiKey()) {
+  if (await getLoopsApiKey()) {
-			await standardRequest.post("https://app.loops.so/api/v1/events/send", {
+    await standardRequest.post("https://app.loops.so/api/v1/events/send", {
-				"email": email,
+      "email": email,
-				"eventName": "Sign Up",
+      "eventName": "Sign Up",
-				"firstName": firstName,
+      "firstName": firstName,
-				"lastName": lastName
+      "lastName": lastName,
-			}, {
+    }, {
-				headers: {
+      headers: {
-					"Accept": "application/json",
+        "Accept": "application/json",
-					"Authorization": "Bearer " + (await getLoopsApiKey())
+        "Authorization": "Bearer " + (await getLoopsApiKey()),
-				},
+      },
-			});
+    });
-		}
+  }
 
-		// store (refresh) token in httpOnly cookie
+  // store (refresh) token in httpOnly cookie
-		res.cookie('jid', tokens.refreshToken, {
+  res.cookie("jid", tokens.refreshToken, {
-			httpOnly: true,
+    httpOnly: true,
-			path: '/',
+    path: "/",
-			sameSite: 'strict',
+    sameSite: "strict",
-			secure: await getHttpsEnabled()
+    secure: await getHttpsEnabled(),
-		});
+  });
-	} catch (err) {
-		Sentry.setUser(null);
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to complete account setup'
-		});
-	}
 
 	return res.status(200).send({
-		message: 'Successfully set up account',
+		message: "Successfully set up account",
 		user,
-		token
+		token,
 	});
 };
 
@@ -166,110 +159,104 @@ export const completeAccountSignup = async (req: Request, res: Response) => {
  * @returns
  */
 export const completeAccountInvite = async (req: Request, res: Response) => {
-	let user, token, refreshToken;
+	let user;
-	try {
+  const {
-		const {
+    email,
-			email,
+    firstName,
-			firstName,
+    lastName,
-			lastName,
+    protectedKey,
-			protectedKey,
+    protectedKeyIV,
-			protectedKeyIV,
+    protectedKeyTag,
-			protectedKeyTag,
+    publicKey,
-			publicKey,
+    encryptedPrivateKey,
-			encryptedPrivateKey,
+    encryptedPrivateKeyIV,
-			encryptedPrivateKeyIV,
+    encryptedPrivateKeyTag,
-			encryptedPrivateKeyTag,
+    salt,
-			salt,
+    verifier,
-			verifier
+  } = req.body;
-		} = req.body;
 
-		// get user
+  // get user
-		user = await User.findOne({ email });
+  user = await User.findOne({ email });
 
-		if (!user || (user && user?.publicKey)) {
+  if (!user || (user && user?.publicKey)) {
-			// case 1: user doesn't exist.
+    // case 1: user doesn't exist.
-			// case 2: user has already completed account
+    // case 2: user has already completed account
-			return res.status(403).send({
+    return res.status(403).send({
-				error: 'Failed to complete account for complete user'
+      error: "Failed to complete account for complete user",
-			});
+    });
-		}
+  }
 
-		const membershipOrg = await MembershipOrg.findOne({
+  const membershipOrg = await MembershipOrg.findOne({
-			inviteEmail: email,
+    inviteEmail: email,
-			status: INVITED
+    status: INVITED,
-		});
+  });
 
-		if (!membershipOrg) throw new Error('Failed to find invitations for email');
+  if (!membershipOrg) throw new Error("Failed to find invitations for email");
 
-		// complete setting up user's account
+  // complete setting up user's account
-		user = await completeAccount({
+  user = await completeAccount({
-			userId: user._id.toString(),
+    userId: user._id.toString(),
-			firstName,
+    firstName,
-			lastName,
+    lastName,
-			encryptionVersion: 2,
+    encryptionVersion: 2,
-			protectedKey,
+    protectedKey,
-			protectedKeyIV,
+    protectedKeyIV,
-			protectedKeyTag,
+    protectedKeyTag,
-			publicKey,
+    publicKey,
-			encryptedPrivateKey,
+    encryptedPrivateKey,
-			encryptedPrivateKeyIV,
+    encryptedPrivateKeyIV,
-			encryptedPrivateKeyTag,
+    encryptedPrivateKeyTag,
-			salt,
+    salt,
-			verifier
+    verifier,
-		});
+  });
 
-		if (!user)
+  if (!user)
-			throw new Error('Failed to complete account for non-existent user');
+    throw new Error("Failed to complete account for non-existent user");
-		
+  
-		// update organization membership statuses that are
+  // update organization membership statuses that are
-		// invited to completed with user attached
+  // invited to completed with user attached
-		const membershipsToUpdate = await MembershipOrg.find({
+  const membershipsToUpdate = await MembershipOrg.find({
-			inviteEmail: email,
+    inviteEmail: email,
-			status: INVITED
+    status: INVITED,
-		});
+  });
-		
+  
-		membershipsToUpdate.forEach(async (membership) => {
+  membershipsToUpdate.forEach(async (membership) => {
-			await updateSubscriptionOrgQuantity({
+    await updateSubscriptionOrgQuantity({
-				organizationId: membership.organization.toString()
+      organizationId: membership.organization.toString(),
-			});
+    });
-		});
+  });
 
-		await MembershipOrg.updateMany(
+  await MembershipOrg.updateMany(
-			{
+    {
-				inviteEmail: email,
+      inviteEmail: email,
-				status: INVITED
+      status: INVITED,
-			},
+    },
-			{
+    {
-				user,
+      user,
-				status: ACCEPTED
+      status: ACCEPTED,
-			}
+    }
-		);
+  );
 
-		// issue tokens
+  // issue tokens
-		const tokens = await issueAuthTokens({
+  const tokens = await issueAuthTokens({
-			userId: user._id.toString()
+    userId: user._id,
-		});
+    ip: req.realIP,
+    userAgent: req.headers["user-agent"] ?? "",
+  });
 
-		token = tokens.token;
+  const token = tokens.token;
 
-		// store (refresh) token in httpOnly cookie
+  // store (refresh) token in httpOnly cookie
-		res.cookie('jid', tokens.refreshToken, {
+  res.cookie("jid", tokens.refreshToken, {
-			httpOnly: true,
+    httpOnly: true,
-			path: '/',
+    path: "/",
-			sameSite: 'strict',
+    sameSite: "strict",
-			secure: await getHttpsEnabled()
+    secure: await getHttpsEnabled(),
-		});
+  });
-	} catch (err) {
-		Sentry.setUser(null);
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to complete account setup'
-		});
-	}
 
 	return res.status(200).send({
-		message: 'Successfully set up account',
+		message: "Successfully set up account",
 		user,
-		token
+		token,
 	});
-};
+};

backend/src/controllers/v2/tagController.ts

@@ -1,72 +1,82 @@
-import { Request, Response } from 'express';
+import { ForbiddenError } from "@casl/ability";
-import * as Sentry from '@sentry/node';
+import { Request, Response } from "express";
-import { Types } from 'mongoose';
+import { Types } from "mongoose";
+import { Secret, Tag } from "../../models";
+import { BadRequestError } from "../../utils/errors";
+import { validateRequest } from "../../helpers/validation";
 import {
-	Membership, Secret,
+  ProjectPermissionActions,
-} from '../../models';
+  ProjectPermissionSub,
-import Tag, { ITag } from '../../models/tag';
+  getUserProjectPermissions
-import { Builder } from "builder-pattern"
+} from "../../ee/services/ProjectRoleService";
-import to from 'await-to-js';
+import * as reqValidator from "../../validation/tags";
-import { BadRequestError, UnauthorizedRequestError } from '../../utils/errors';
-import { MongoError } from 'mongodb';
-import { userHasWorkspaceAccess } from '../../ee/helpers/checkMembershipPermissions';
 
 export const createWorkspaceTag = async (req: Request, res: Response) => {
-	const { workspaceId } = req.params
+  const {
-	const { name, slug } = req.body
+    body: { name, slug },
-	const sanitizedTagToCreate = Builder<ITag>()
+    params: { workspaceId }
-		.name(name)
+  } = await validateRequest(reqValidator.CreateWorkspaceTagsV2, req);
-		.workspace(new Types.ObjectId(workspaceId))
-		.slug(slug)
-		.user(new Types.ObjectId(req.user._id))
-		.build();
 
-	const [err, createdTag] = await to(Tag.create(sanitizedTagToCreate))
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Create,
+    ProjectPermissionSub.Tags
+  );
 
-	if (err) {
+  const tagToCreate = {
-		if ((err as MongoError).code === 11000) {
+    name,
-			throw BadRequestError({ message: "Tags must be unique in a workspace" })
+    workspace: new Types.ObjectId(workspaceId),
-		}
+    slug,
+    user: new Types.ObjectId(req.user._id)
+  };
 
-		throw err
+  const createdTag = await new Tag(tagToCreate).save();
-	}
 
-	res.json(createdTag)
+  res.json(createdTag);
-}
+};
 
 export const deleteWorkspaceTag = async (req: Request, res: Response) => {
-	const { tagId } = req.params
+  const {
+    params: { tagId }
+  } = await validateRequest(reqValidator.DeleteWorkspaceTagsV2, req);
 
-	const tagFromDB = await Tag.findById(tagId)
+  const tagFromDB = await Tag.findById(tagId);
-	if (!tagFromDB) {
+  if (!tagFromDB) {
-		throw BadRequestError()
+    throw BadRequestError();
-	}
+  }
 
-	// can only delete if the request user is one that belongs to the same workspace as the tag
+  const { permission } = await getUserProjectPermissions(
-	const membership = await Membership.findOne({
+    req.user._id,
-		user: req.user,
+    tagFromDB.workspace.toString()
-		workspace: tagFromDB.workspace
+  );
-	});
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Delete,
+    ProjectPermissionSub.Tags
+  );
 
-	if (!membership) {
+  const result = await Tag.findByIdAndDelete(tagId);
-		UnauthorizedRequestError({ message: 'Failed to validate membership' });
-	}
 
-	const result = await Tag.findByIdAndDelete(tagId);
+  // remove the tag from secrets
+  await Secret.updateMany({ tags: { $in: [tagId] } }, { $pull: { tags: tagId } });
 
-	// remove the tag from secrets
+  res.json(result);
-	await Secret.updateMany(
+};
-		{ tags: { $in: [tagId] } },
-		{ $pull: { tags: tagId } }
-	);
-
-	res.json(result);
-}
 
 export const getWorkspaceTags = async (req: Request, res: Response) => {
-	const { workspaceId } = req.params
+  const {
-	const workspaceTags = await Tag.find({ workspace: workspaceId })
+    params: { workspaceId }
-	return res.json({
+  } = await validateRequest(reqValidator.GetWorkspaceTagsV2, req);
-		workspaceTags
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-	})
+  ForbiddenError.from(permission).throwUnlessCan(
-}
+    ProjectPermissionActions.Read,
+    ProjectPermissionSub.Tags
+  );
+
+  const workspaceTags = await Tag.find({
+    workspace: new Types.ObjectId(workspaceId)
+  });
+
+  return res.json({
+    workspaceTags
+  });
+};

backend/src/controllers/v2/usersController.ts

@@ -1,18 +1,20 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
+import { Types } from "mongoose";
-import {
+import crypto from "crypto";
-    User,
+import bcrypt from "bcrypt";
-    MembershipOrg
+import { APIKeyData, AuthMethod, MembershipOrg, TokenVersion, User } from "../../models";
-} from '../../models';
+import { getSaltRounds } from "../../config";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation";
 
 /**
  * Return the current user.
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const getMe = async (req: Request, res: Response) => {
-    /* 
+  /* 
     #swagger.summary = "Retrieve the current user on the request"
     #swagger.description = "Retrieve the current user on the request"
     
@@ -37,69 +39,117 @@ export const getMe = async (req: Request, res: Response) => {
         }
     }   
     */
-    let user;
+  const user = await User.findById(req.user._id).select(
-    try {
+    "+salt +publicKey +encryptedPrivateKey +iv +tag +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag"
-        user = await User
+  );
-            .findById(req.user._id)
+
-            .select('+salt +publicKey +encryptedPrivateKey +iv +tag +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag');
+  return res.status(200).send({
-    } catch (err) {
+    user
-        Sentry.setUser({ email: req.user.email });
+  });
-		Sentry.captureException(err);
+};
-		return res.status(400).send({
-			message: 'Failed to get current user'
-		});
-    }
-    
-    return res.status(200).send({
-        user
-    });
-}
 
 /**
  * Update the current user's MFA-enabled status [isMfaEnabled].
  * Note: Infisical currently only supports email-based 2FA only; this will expand to
  * include SMS and authenticator app modes of authentication in the future.
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const updateMyMfaEnabled = async (req: Request, res: Response) => {
-    let user;
+  const {
-    try {
+    body: { isMfaEnabled }
-        const { isMfaEnabled }: { isMfaEnabled: boolean } = req.body;
+  } = await validateRequest(reqValidator.UpdateMyMfaEnabledV2, req);
-        req.user.isMfaEnabled = isMfaEnabled;
-        
-        if (isMfaEnabled) { 
-            // TODO: adapt this route/controller 
-            // to work for different forms of MFA
-            req.user.mfaMethods = ['email'];
-        } else {
-            req.user.mfaMethods = [];
-        }
 
-        await req.user.save();
+  req.user.isMfaEnabled = isMfaEnabled;
-        
+
-        user = req.user;
+  if (isMfaEnabled) {
-    } catch (err) {
+    // TODO: adapt this route/controller
-        Sentry.setUser({ email: req.user.email });
+    // to work for different forms of MFA
-		Sentry.captureException(err);
+    req.user.mfaMethods = ["email"];
-		return res.status(400).send({
+  } else {
-			message: "Failed to update current user's MFA status"
+    req.user.mfaMethods = [];
-		}); 
+  }
+
+  await req.user.save();
+
+  const user = req.user;
+
+  return res.status(200).send({
+    user
+  });
+};
+
+/**
+ * Update name of the current user to [firstName, lastName].
+ * @param req
+ * @param res
+ * @returns
+ */
+export const updateName = async (req: Request, res: Response) => {
+  const {
+    body: { lastName, firstName }
+  } = await validateRequest(reqValidator.UpdateNameV2, req);
+
+  const user = await User.findByIdAndUpdate(
+    req.user._id.toString(),
+    {
+      firstName,
+      lastName: lastName ?? ""
+    },
+    {
+      new: true
     }
-    
+  );
-    return res.status(200).send({
+
-        user
+  return res.status(200).send({
+    user
+  });
+};
+
+/**
+ * Update auth method of the current user to [authMethods]
+ * @param req
+ * @param res
+ * @returns
+ */
+export const updateAuthMethods = async (req: Request, res: Response) => {
+  const {
+    body: { authMethods }
+  } = await validateRequest(reqValidator.UpdateAuthMethodsV2, req);
+
+  const hasSamlEnabled = req.user.authMethods.some((authMethod: AuthMethod) =>
+    [AuthMethod.OKTA_SAML, AuthMethod.AZURE_SAML, AuthMethod.JUMPCLOUD_SAML].includes(authMethod)
+  );
+
+  if (hasSamlEnabled) {
+    return res.status(400).send({
+      message: "Failed to update user authentication method because SAML SSO is enforced"
     });
-}
+  }
+
+  const user = await User.findByIdAndUpdate(
+    req.user._id.toString(),
+    {
+      authMethods
+    },
+    {
+      new: true
+    }
+  );
+
+  return res.status(200).send({
+    user
+  });
+};
 
 /**
  * Return organizations that the current user is part of.
- * @param req 
+ * @param req
- * @param res 
+ * @param res
  */
 export const getMyOrganizations = async (req: Request, res: Response) => {
-    /* 
+  /* 
     #swagger.summary = 'Return organizations that current user is part of'
     #swagger.description = 'Return organizations that current user is part of'
     
@@ -126,22 +176,123 @@ export const getMyOrganizations = async (req: Request, res: Response) => {
         }
     }   
     */
-	let organizations;
+  const organizations = (
-	try {
+    await MembershipOrg.find({
-		organizations = (
+      user: req.user._id
-			await MembershipOrg.find({
+    }).populate("organization")
-				user: req.user._id
+  ).map((m) => m.organization);
-			}).populate('organization')
-		).map((m) => m.organization);
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: "Failed to get current user's organizations"
-		});
-	}
 
-	return res.status(200).send({
+  return res.status(200).send({
-		organizations
+    organizations
-	});
+  });
-}
+};
+
+/**
+ * Return API keys belonging to current user.
+ * @param req
+ * @param res
+ * @returns
+ */
+export const getMyAPIKeys = async (req: Request, res: Response) => {
+  const apiKeyData = await APIKeyData.find({
+    user: req.user._id
+  });
+
+  return res.status(200).send(apiKeyData);
+};
+
+/**
+ * Create new API key for current user.
+ * @param req
+ * @param res
+ * @returns
+ */
+export const createAPIKey = async (req: Request, res: Response) => {
+  const {
+    body: { name, expiresIn }
+  } = await validateRequest(reqValidator.CreateApiKeyV2, req);
+
+  const secret = crypto.randomBytes(16).toString("hex");
+  const secretHash = await bcrypt.hash(secret, await getSaltRounds());
+
+  const expiresAt = new Date();
+  expiresAt.setSeconds(expiresAt.getSeconds() + expiresIn);
+
+  let apiKeyData = await new APIKeyData({
+    name,
+    lastUsed: new Date(),
+    expiresAt,
+    user: req.user._id,
+    secretHash
+  }).save();
+
+  // return api key data without sensitive data
+  apiKeyData = (await APIKeyData.findById(apiKeyData._id)) as any;
+
+  if (!apiKeyData) throw new Error("Failed to find API key data");
+
+  const apiKey = `ak.${apiKeyData._id.toString()}.${secret}`;
+
+  return res.status(200).send({
+    apiKey,
+    apiKeyData
+  });
+};
+
+/**
+ * Delete API key with id [apiKeyDataId] belonging to current user
+ * @param req
+ * @param res
+ */
+export const deleteAPIKey = async (req: Request, res: Response) => {
+  const {
+    params: { apiKeyDataId }
+  } = await validateRequest(reqValidator.DeleteApiKeyV2, req);
+
+  const apiKeyData = await APIKeyData.findOneAndDelete({
+    _id: new Types.ObjectId(apiKeyDataId),
+    user: req.user._id
+  });
+
+  return res.status(200).send({
+    apiKeyData
+  });
+};
+
+/**
+ * Return active sessions (TokenVersion) belonging to user
+ * @param req
+ * @param res
+ * @returns
+ */
+export const getMySessions = async (req: Request, res: Response) => {
+  const tokenVersions = await TokenVersion.find({
+    user: req.user._id
+  });
+
+  return res.status(200).send(tokenVersions);
+};
+
+/**
+ * Revoke all active sessions belong to user
+ * @param req
+ * @param res
+ * @returns
+ */
+export const deleteMySessions = async (req: Request, res: Response) => {
+  await TokenVersion.updateMany(
+    {
+      user: req.user._id
+    },
+    {
+      $inc: {
+        refreshVersion: 1,
+        accessVersion: 1
+      }
+    }
+  );
+
+  return res.status(200).send({
+    message: "Successfully revoked all sessions"
+  });
+};

backend/src/controllers/v2/workspaceController.ts

@@ -1,41 +1,39 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
+import { Types } from "mongoose";
-import { Types } from 'mongoose';
+import { Key, Membership, ServiceTokenData, Workspace } from "../../models";
 import {
-	Workspace,
+  pullSecrets as pull,
-	Secret,
+  v2PushSecrets as push,
-	Membership,
+  reformatPullSecrets
-	MembershipOrg,
+} from "../../helpers/secret";
-	Integration,
+import { pushKeys } from "../../helpers/key";
-	IntegrationAuth,
+import { EventService, TelemetryService } from "../../services";
-	Key,
+import { eventPushSecrets } from "../../events";
-	IUser,
+import { EEAuditLogService } from "../../ee/services";
-	ServiceToken,
+import { EventType } from "../../ee/models";
-	ServiceTokenData
+import { validateRequest } from "../../helpers/validation";
-} from '../../models';
+import * as reqValidator from "../../validation";
 import {
-	v2PushSecrets as push,
+  ProjectPermissionActions,
-	pullSecrets as pull,
+  ProjectPermissionSub,
-	reformatPullSecrets
+  getUserProjectPermissions
-} from '../../helpers/secret';
+} from "../../ee/services/ProjectRoleService";
-import { pushKeys } from '../../helpers/key';
+import { ForbiddenError } from "@casl/ability";
-import { TelemetryService, EventService } from '../../services';
-import { eventPushSecrets } from '../../events';
 
 interface V2PushSecret {
-	type: string; // personal or shared
+  type: string; // personal or shared
-	secretKeyCiphertext: string;
+  secretKeyCiphertext: string;
-	secretKeyIV: string;
+  secretKeyIV: string;
-	secretKeyTag: string;
+  secretKeyTag: string;
-	secretKeyHash: string;
+  secretKeyHash: string;
-	secretValueCiphertext: string;
+  secretValueCiphertext: string;
-	secretValueIV: string;
+  secretValueIV: string;
-	secretValueTag: string;
+  secretValueTag: string;
-	secretValueHash: string;
+  secretValueHash: string;
-	secretCommentCiphertext?: string;
+  secretCommentCiphertext?: string;
-	secretCommentIV?: string;
+  secretCommentIV?: string;
-	secretCommentTag?: string;
+  secretCommentTag?: string;
-	secretCommentHash?: string;
+  secretCommentHash?: string;
 }
 
 /**
@@ -46,71 +44,63 @@ interface V2PushSecret {
  * @returns
  */
 export const pushWorkspaceSecrets = async (req: Request, res: Response) => {
-	// upload (encrypted) secrets to workspace with id [workspaceId]
+  // upload (encrypted) secrets to workspace with id [workspaceId]
-	try {
+  const postHogClient = await TelemetryService.getPostHogClient();
-		const postHogClient = await TelemetryService.getPostHogClient();
+  let { secrets }: { secrets: V2PushSecret[] } = req.body;
-		let { secrets }: { secrets: V2PushSecret[] } = req.body;
+  const { keys, environment, channel } = req.body;
-		const { keys, environment, channel } = req.body;
+  const { workspaceId } = req.params;
-		const { workspaceId } = req.params;
 
-		// validate environment
+  // validate environment
-		const workspaceEnvs = req.membership.workspace.environments;
+  const workspaceEnvs = req.membership.workspace.environments;
-		if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
+  if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-			throw new Error('Failed to validate environment');
+    throw new Error("Failed to validate environment");
-		}
+  }
 
-		// sanitize secrets
+  // sanitize secrets
-		secrets = secrets.filter(
+  secrets = secrets.filter(
-			(s: V2PushSecret) => s.secretKeyCiphertext !== '' && s.secretValueCiphertext !== ''
+    (s: V2PushSecret) => s.secretKeyCiphertext !== "" && s.secretValueCiphertext !== ""
-		);
+  );
 
-		await push({
+  await push({
-			userId: req.user._id,
+    userId: req.user._id,
-			workspaceId,
+    workspaceId,
-			environment,
+    environment,
-			secrets,
+    secrets,
-			channel: channel ? channel : 'cli',
+    channel: channel ? channel : "cli",
-			ipAddress: req.ip
+    ipAddress: req.realIP
-		});
+  });
 
-		await pushKeys({
+  await pushKeys({
-			userId: req.user._id,
+    userId: req.user._id,
-			workspaceId,
+    workspaceId,
-			keys
+    keys
-		});
+  });
 
-		if (postHogClient) {
+  if (postHogClient) {
-			postHogClient.capture({
+    postHogClient.capture({
-				event: 'secrets pushed',
+      event: "secrets pushed",
-				distinctId: req.user.email,
+      distinctId: req.user.email,
-				properties: {
+      properties: {
-					numberOfSecrets: secrets.length,
+        numberOfSecrets: secrets.length,
-					environment,
+        environment,
-					workspaceId,
+        workspaceId,
-					channel: channel ? channel : 'cli'
+        channel: channel ? channel : "cli"
-				}
+      }
-			});
+    });
-		}
+  }
 
-		// trigger event - push secrets
+  // trigger event - push secrets
-		EventService.handleEvent({
+  EventService.handleEvent({
-			event: eventPushSecrets({
+    event: eventPushSecrets({
-				workspaceId: new Types.ObjectId(workspaceId),
+      workspaceId: new Types.ObjectId(workspaceId),
-				environment
+      environment,
-			})
+      secretPath: "/"
-		});
+    })
+  });
 
-	} catch (err) {
+  return res.status(200).send({
-		Sentry.setUser({ email: req.user.email });
+    message: "Successfully uploaded workspace secrets"
-		Sentry.captureException(err);
+  });
-		return res.status(400).send({
-			message: 'Failed to upload workspace secrets'
-		});
-	}
-
-	return res.status(200).send({
-		message: 'Successfully uploaded workspace secrets'
-	});
 };
 
 /**
@@ -121,65 +111,57 @@ export const pushWorkspaceSecrets = async (req: Request, res: Response) => {
  * @returns
  */
 export const pullSecrets = async (req: Request, res: Response) => {
-	let secrets;
+  let secrets;
-	try {
+  const postHogClient = await TelemetryService.getPostHogClient();
-		const postHogClient = await TelemetryService.getPostHogClient();
+  const environment: string = req.query.environment as string;
-		const environment: string = req.query.environment as string;
+  const channel: string = req.query.channel as string;
-		const channel: string = req.query.channel as string;
+  const { workspaceId } = req.params;
-		const { workspaceId } = req.params;
 
-		let userId;
+  let userId;
-		if (req.user) {
+  if (req.user) {
-			userId = req.user._id.toString();
+    userId = req.user._id.toString();
-		} else if (req.serviceTokenData) {
+  } else if (req.serviceTokenData) {
-			userId = req.serviceTokenData.user.toString();
+    userId = req.serviceTokenData.user.toString();
-		}
+  }
-		// validate environment
+  // validate environment
-		const workspaceEnvs = req.membership.workspace.environments;
+  const workspaceEnvs = req.membership.workspace.environments;
-		if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
+  if (!workspaceEnvs.find(({ slug }: { slug: string }) => slug === environment)) {
-			throw new Error('Failed to validate environment');
+    throw new Error("Failed to validate environment");
-		}
+  }
 
-		secrets = await pull({
+  secrets = await pull({
-			userId,
+    userId,
-			workspaceId,
+    workspaceId,
-			environment,
+    environment,
-			channel: channel ? channel : 'cli',
+    channel: channel ? channel : "cli",
-			ipAddress: req.ip
+    ipAddress: req.realIP
-		});
+  });
 
-		if (channel !== 'cli') {
+  if (channel !== "cli") {
-			secrets = reformatPullSecrets({ secrets });
+    secrets = reformatPullSecrets({ secrets });
-		}
+  }
 
-		if (postHogClient) {
+  if (postHogClient) {
-			// capture secrets pushed event in production
+    // capture secrets pushed event in production
-			postHogClient.capture({
+    postHogClient.capture({
-				distinctId: req.user.email,
+      distinctId: req.user.email,
-				event: 'secrets pulled',
+      event: "secrets pulled",
-				properties: {
+      properties: {
-					numberOfSecrets: secrets.length,
+        numberOfSecrets: secrets.length,
-					environment,
+        environment,
-					workspaceId,
+        workspaceId,
-					channel: channel ? channel : 'cli'
+        channel: channel ? channel : "cli"
-				}
+      }
-			});
+    });
-		}
+  }
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to pull workspace secrets'
-		});
-	}
 
-	return res.status(200).send({
+  return res.status(200).send({
-		secrets
+    secrets
-	});
+  });
 };
 
 export const getWorkspaceKey = async (req: Request, res: Response) => {
-	/* 
+  /* 
     #swagger.summary = 'Return encrypted project key'
     #swagger.description = 'Return encrypted project key'
     
@@ -207,61 +189,53 @@ export const getWorkspaceKey = async (req: Request, res: Response) => {
         }
     }   
     */
-	let key;
+  const {
-	try {
+    params: { workspaceId }
-		const { workspaceId } = req.params;
+  } = await validateRequest(reqValidator.GetWorkspaceKeyV2, req);
 
-		key = await Key.findOne({
+  const key = await Key.findOne({
-			workspace: workspaceId,
+    workspace: workspaceId,
-			receiver: req.user._id
+    receiver: req.user._id
-		}).populate('sender', '+publicKey');
+  }).populate("sender", "+publicKey");
 
-		if (!key) throw new Error('Failed to find workspace key');
+  if (!key) throw new Error("Failed to find workspace key");
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get workspace key'
-		});
-	}
 
-	return res.status(200).json(key);
+  await EEAuditLogService.createAuditLog(
-}
+    req.authData,
-export const getWorkspaceServiceTokenData = async (
+    {
-	req: Request,
+      type: EventType.GET_WORKSPACE_KEY,
-	res: Response
+      metadata: {
-) => {
+        keyId: key._id.toString()
-	let serviceTokenData;
+      }
-	try {
+    },
-		const { workspaceId } = req.params;
+    {
+      workspaceId: new Types.ObjectId(workspaceId)
+    }
+  );
 
-		serviceTokenData = await ServiceTokenData
+  return res.status(200).json(key);
-			.find({
+};
-				workspace: workspaceId
-			})
-			.select('+encryptedKey +iv +tag');
 
-	} catch (err) {
+export const getWorkspaceServiceTokenData = async (req: Request, res: Response) => {
-		Sentry.setUser({ email: req.user.email });
+  const { workspaceId } = req.params;
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get workspace service token data'
-		});
-	}
 
-	return res.status(200).send({
+  const serviceTokenData = await ServiceTokenData.find({
-		serviceTokenData
+    workspace: workspaceId
-	});
+  }).select("+encryptedKey +iv +tag");
-}
+
+  return res.status(200).send({
+    serviceTokenData
+  });
+};
 
 /**
  * Return memberships for workspace with id [workspaceId]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const getWorkspaceMemberships = async (req: Request, res: Response) => {
-	/* 
+  /* 
     #swagger.summary = 'Return project memberships'
     #swagger.description = 'Return project memberships'
     
@@ -294,34 +268,33 @@ export const getWorkspaceMemberships = async (req: Request, res: Response) => {
         }
     }   
     */
-	let memberships;
+  const {
-	try {
+    params: { workspaceId }
-		const { workspaceId } = req.params;
+  } = await validateRequest(reqValidator.GetWorkspaceMembershipsV2, req);
 
-		memberships = await Membership.find({
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-			workspace: workspaceId
+  ForbiddenError.from(permission).throwUnlessCan(
-		}).populate('user', '+publicKey');
+    ProjectPermissionActions.Read,
-	} catch (err) {
+    ProjectPermissionSub.Member
-		Sentry.setUser({ email: req.user.email });
+  );
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to get workspace memberships'
-		});
-	}
 
-	return res.status(200).send({
+  const memberships = await Membership.find({
-		memberships
+    workspace: workspaceId
-	});
+  }).populate("user", "+publicKey");
-}
+
+  return res.status(200).send({
+    memberships
+  });
+};
 
 /**
  * Update role of membership with id [membershipId] to role [role]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const updateWorkspaceMembership = async (req: Request, res: Response) => {
-	/* 
+  /* 
     #swagger.summary = 'Update project membership'
     #swagger.description = 'Update project membership'
     
@@ -374,42 +347,40 @@ export const updateWorkspaceMembership = async (req: Request, res: Response) =>
         }
     }   
     */
-	let membership;
+  const {
-	try {
+    params: { workspaceId, membershipId },
-		const {
+    body: { role }
-			membershipId
+  } = await validateRequest(reqValidator.UpdateWorkspaceMembershipsV2, req);
-		} = req.params;
+
-		const { role } = req.body;
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-		
+  ForbiddenError.from(permission).throwUnlessCan(
-		membership = await Membership.findByIdAndUpdate(
+    ProjectPermissionActions.Edit,
-			membershipId,
+    ProjectPermissionSub.Member
-			{
+  );
-				role
+
-			}, {
+  const membership = await Membership.findByIdAndUpdate(
-				new: true
+    membershipId,
-			}
+    {
-		);
+      role
-	} catch (err) {
+    },
-		Sentry.setUser({ email: req.user.email });
+    {
-		Sentry.captureException(err);
+      new: true
-		return res.status(400).send({
+    }
-			message: 'Failed to update workspace membership'
+  );
-		});
+
-	}
+  return res.status(200).send({
-	
+    membership
-	return res.status(200).send({
+  });
-		membership
+};
-	}); 
-}
 
 /**
  * Delete workspace membership with id [membershipId]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const deleteWorkspaceMembership = async (req: Request, res: Response) => {
-	/* 
+  /* 
     #swagger.summary = 'Delete project membership'
     #swagger.description = 'Delete project membership'
     
@@ -445,32 +416,29 @@ export const deleteWorkspaceMembership = async (req: Request, res: Response) =>
         }
     }   
     */
-	let membership;
+  const {
-	try {
+    params: { workspaceId, membershipId }
-		const { 
+  } = await validateRequest(reqValidator.DeleteWorkspaceMembershipsV2, req);
-			membershipId
+
-		} = req.params;
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-		
+  ForbiddenError.from(permission).throwUnlessCan(
-		membership = await Membership.findByIdAndDelete(membershipId);
+    ProjectPermissionActions.Delete,
-		
+    ProjectPermissionSub.Member
-		if (!membership) throw new Error('Failed to delete workspace membership');
+  );
-		
+
-		await Key.deleteMany({
+  const membership = await Membership.findByIdAndDelete(membershipId);
-			receiver: membership.user,
+
-			workspace: membership.workspace
+  if (!membership) throw new Error("Failed to delete workspace membership");
-		});
+
-	} catch (err) {
+  await Key.deleteMany({
-		Sentry.setUser({ email: req.user.email });
+    receiver: membership.user,
-		Sentry.captureException(err);
+    workspace: membership.workspace
-		return res.status(400).send({
+  });
-			message: 'Failed to delete workspace membership'
+
-		});	
+  return res.status(200).send({
-	}
+    membership
-	
+  });
-	return res.status(200).send({
+};
-		membership
-	});
-}
 
 /**
  * Change autoCapitilzation Rule of workspace
@@ -479,32 +447,31 @@ export const deleteWorkspaceMembership = async (req: Request, res: Response) =>
  * @returns
  */
 export const toggleAutoCapitalization = async (req: Request, res: Response) => {
-	let workspace;
+  const {
-	try {
+    params: { workspaceId },
-		const { workspaceId } = req.params;
+    body: { autoCapitalization }
-		const { autoCapitalization } = req.body;
+  } = await validateRequest(reqValidator.ToggleAutoCapitalizationV2, req);
 
-		workspace = await Workspace.findOneAndUpdate(
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-			{
+  ForbiddenError.from(permission).throwUnlessCan(
-				_id: workspaceId
+    ProjectPermissionActions.Edit,
-			},
+    ProjectPermissionSub.Settings
-			{
+  );
-				autoCapitalization
-			},
-			{
-				new: true
-			}
-		);
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			message: 'Failed to change autoCapitalization setting'
-		});
-	}
 
-	return res.status(200).send({
+  const workspace = await Workspace.findOneAndUpdate(
-		message: 'Successfully changed autoCapitalization setting',
+    {
-		workspace
+      _id: workspaceId
-	});
+    },
-};
+    {
+      autoCapitalization
+    },
+    {
+      new: true
+    }
+  );
+
+  return res.status(200).send({
+    message: "Successfully changed autoCapitalization setting",
+    workspace
+  });
+};

backend/src/controllers/v3/authController.ts

@@ -0,0 +1,238 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+import { Request, Response } from "express";
+import jwt from "jsonwebtoken";
+import * as bigintConversion from "bigint-conversion";
+const jsrp = require("jsrp");
+import { LoginSRPDetail, User } from "../../models";
+import { createToken, issueAuthTokens, validateProviderAuthToken } from "../../helpers/auth";
+import { checkUserDevice } from "../../helpers/user";
+import { sendMail } from "../../helpers/nodemailer";
+import { TokenService } from "../../services";
+import { EELogService } from "../../ee/services";
+import { BadRequestError, InternalServerError } from "../../utils/errors";
+import { ACTION_LOGIN, TOKEN_EMAIL_MFA } from "../../variables";
+import { getUserAgentType } from "../../utils/posthog"; // TODO: move this
+import { getHttpsEnabled, getJwtMfaLifetime, getJwtMfaSecret } from "../../config";
+import { AuthMethod } from "../../models/user";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/auth";
+
+declare module "jsonwebtoken" {
+  export interface ProviderAuthJwtPayload extends jwt.JwtPayload {
+    userId: string;
+    email: string;
+    authProvider: AuthMethod;
+    isUserCompleted: boolean;
+  }
+}
+
+/**
+ * Log in user step 1: Return [salt] and [serverPublicKey] as part of step 1 of SRP protocol
+ * @param req
+ * @param res
+ * @returns
+ */
+export const login1 = async (req: Request, res: Response) => {
+  const {
+    body: { email, clientPublicKey, providerAuthToken }
+  } = await validateRequest(reqValidator.Login1V3, req);
+
+  const user = await User.findOne({
+    email
+  }).select("+salt +verifier");
+
+  if (!user) throw new Error("Failed to find user");
+
+  if (!user.authMethods.includes(AuthMethod.EMAIL)) {
+    await validateProviderAuthToken({
+      email,
+      providerAuthToken
+    });
+  }
+
+  const server = new jsrp.server();
+  server.init(
+    {
+      salt: user.salt,
+      verifier: user.verifier
+    },
+    async () => {
+      // generate server-side public key
+      const serverPublicKey = server.getPublicKey();
+      await LoginSRPDetail.findOneAndReplace(
+        {
+          email: email
+        },
+        {
+          email,
+          userId: user.id,
+          clientPublicKey: clientPublicKey,
+          serverBInt: bigintConversion.bigintToBuf(server.bInt)
+        },
+        { upsert: true, returnNewDocument: false }
+      );
+
+      return res.status(200).send({
+        serverPublicKey,
+        salt: user.salt
+      });
+    }
+  );
+};
+
+/**
+ * Log in user step 2: complete step 2 of SRP protocol and return token and their (encrypted)
+ * private key
+ * @param req
+ * @param res
+ * @returns
+ */
+export const login2 = async (req: Request, res: Response) => {
+  if (!req.headers["user-agent"])
+    throw InternalServerError({ message: "User-Agent header is required" });
+
+  const {
+    body: { email, providerAuthToken, clientProof }
+  } = await validateRequest(reqValidator.Login2V3, req);
+
+  const user = await User.findOne({
+    email
+  }).select(
+    "+salt +verifier +encryptionVersion +protectedKey +protectedKeyIV +protectedKeyTag +publicKey +encryptedPrivateKey +iv +tag +devices"
+  );
+
+  if (!user) throw new Error("Failed to find user");
+
+  if (!user.authMethods.includes(AuthMethod.EMAIL)) {
+    await validateProviderAuthToken({
+      email,
+      providerAuthToken
+    });
+  }
+
+  const loginSRPDetail = await LoginSRPDetail.findOneAndDelete({ email: email });
+
+  if (!loginSRPDetail) {
+    return BadRequestError(Error("Failed to find login details for SRP"));
+  }
+
+  const server = new jsrp.server();
+  server.init(
+    {
+      salt: user.salt,
+      verifier: user.verifier,
+      b: loginSRPDetail.serverBInt
+    },
+    async () => {
+      server.setClientPublicKey(loginSRPDetail.clientPublicKey);
+
+      // compare server and client shared keys
+      if (server.checkClientProof(clientProof)) {
+        if (user.isMfaEnabled) {
+          // case: user has MFA enabled
+
+          // generate temporary MFA token
+          const token = createToken({
+            payload: {
+              userId: user._id.toString()
+            },
+            expiresIn: await getJwtMfaLifetime(),
+            secret: await getJwtMfaSecret()
+          });
+
+          const code = await TokenService.createToken({
+            type: TOKEN_EMAIL_MFA,
+            email
+          });
+
+          // send MFA code [code] to [email]
+          await sendMail({
+            template: "emailMfa.handlebars",
+            subjectLine: "Infisical MFA code",
+            recipients: [user.email],
+            substitutions: {
+              code
+            }
+          });
+
+          return res.status(200).send({
+            mfaEnabled: true,
+            token
+          });
+        }
+
+        await checkUserDevice({
+          user,
+          ip: req.realIP,
+          userAgent: req.headers["user-agent"] ?? ""
+        });
+
+        // issue tokens
+        const tokens = await issueAuthTokens({
+          userId: user._id,
+          ip: req.realIP,
+          userAgent: req.headers["user-agent"] ?? ""
+        });
+
+        // store (refresh) token in httpOnly cookie
+        res.cookie("jid", tokens.refreshToken, {
+          httpOnly: true,
+          path: "/",
+          sameSite: "strict",
+          secure: await getHttpsEnabled()
+        });
+
+        // case: user does not have MFA enablgged
+        // return (access) token in response
+
+        interface ResponseData {
+          mfaEnabled: boolean;
+          encryptionVersion: any;
+          protectedKey?: string;
+          protectedKeyIV?: string;
+          protectedKeyTag?: string;
+          token: string;
+          publicKey?: string;
+          encryptedPrivateKey?: string;
+          iv?: string;
+          tag?: string;
+        }
+
+        const response: ResponseData = {
+          mfaEnabled: false,
+          encryptionVersion: user.encryptionVersion,
+          token: tokens.token,
+          publicKey: user.publicKey,
+          encryptedPrivateKey: user.encryptedPrivateKey,
+          iv: user.iv,
+          tag: user.tag
+        };
+
+        if (user?.protectedKey && user?.protectedKeyIV && user?.protectedKeyTag) {
+          response.protectedKey = user.protectedKey;
+          response.protectedKeyIV = user.protectedKeyIV;
+          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);
+      }
+
+      return res.status(400).send({
+        message: "Failed to authenticate. Try again?"
+      });
+    }
+  );
+};

backend/src/controllers/v3/index.ts

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

backend/src/controllers/v3/secretsController.ts

@@ -1,183 +1,704 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import { Types } from 'mongoose';
+import { Types } from "mongoose";
-import { 
+import { EventService, SecretService } from "../../services";
-    SecretService, 
+import { eventPushSecrets } from "../../events";
-    TelemetryService,
+import { BotService } from "../../services";
-    EventService
+import { containsGlobPatterns, isValidScope, repackageSecretToRaw } from "../../helpers/secrets";
-} from '../../services';
+import { encryptSymmetric128BitHexKeyUTF8 } from "../../utils/crypto";
-import { eventPushSecrets } from '../../events';
+import { getAllImportedSecrets } from "../../services/SecretImportService";
-import { getAuthDataPayloadIdObj } from '../../utils/auth';
+import { Folder, IServiceTokenData } from "../../models";
-import { BadRequestError } from '../../utils/errors';
+import { getFolderByPath, getFolderWithPathFromId } from "../../services/FolderService";
+import { BadRequestError } from "../../utils/errors";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/secrets";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  getUserProjectPermissions
+} from "../../ee/services/ProjectRoleService";
+import { ForbiddenError, subject } from "@casl/ability";
+import { validateServiceTokenDataClientForWorkspace } from "../../validation";
+import { PERMISSION_READ_SECRETS, PERMISSION_WRITE_SECRETS } from "../../variables";
 
 /**
- * Get secrets for workspace with id [workspaceId] and environment
+ * Return secrets for workspace with id [workspaceId] and environment
- * [environment]
+ * [environment] in plaintext
- * @param req 
+ * @param req
- * @param res 
+ * @param res
  */
-export const getSecrets = async (req: Request, res: Response) => {
+export const getSecretsRaw = async (req: Request, res: Response) => {
-    const workspaceId = req.query.workspaceId as string;
+  const validatedData = await validateRequest(reqValidator.GetSecretsRawV3, req);
-    const environment = req.query.environment as string;
+  let {
+    query: { secretPath, environment, workspaceId }
+  } = validatedData;
+  const {
+    query: { folderId, include_imports: includeImports }
+  } = validatedData;
 
-    const secrets = await SecretService.getSecrets({
+  // if the service token has single scope, it will get all secrets for that scope by default
-        workspaceId: new Types.ObjectId(workspaceId),
+  const serviceTokenDetails: IServiceTokenData = req?.serviceTokenData;
-        environment,
+  if (
-        authData: req.authData
+    serviceTokenDetails &&
-    });
+    serviceTokenDetails.scopes.length == 1 &&
+    !containsGlobPatterns(serviceTokenDetails.scopes[0].secretPath)
+  ) {
+    const scope = serviceTokenDetails.scopes[0];
+    secretPath = scope.secretPath;
+    environment = scope.environment;
+    workspaceId = serviceTokenDetails.workspace.toString();
+  }
 
-    return res.status(200).send({
+  if (folderId && folderId !== "root") {
-        secrets
+    const folder = await Folder.findOne({ workspace: workspaceId, environment });
-    });
+    if (!folder) throw BadRequestError({ message: "Folder not found" });
-}
 
-/**
+    secretPath = getFolderWithPathFromId(folder.nodes, folderId).folderPath;
- * Get secret with name [secretName]
+  }
- * @param req 
- * @param res 
- */
-export const getSecretByName = async (req: Request, res: Response) => {
-    const { secretName } = req.params;
-    const workspaceId = req.query.workspaceId as string;
-    const environment = req.query.environment as string;
-    const type = req.query.type as 'shared' | 'personal' | undefined;
 
-    const secret = await SecretService.getSecret({
+  if (!environment || !workspaceId)
-        secretName,
+    throw BadRequestError({ message: "Missing environment or workspace id" });
-        workspaceId: new Types.ObjectId(workspaceId),
-        environment,
-        type,
-        authData: req.authData
-    });
-    
-    return res.status(200).send({
-        secret
-    });
-}
 
-/**
+  let permissionCheckFn: (env: string, secPath: string) => boolean; // used to pass as callback function to import secret
- * Create secret with name [secretName]
+  if (req.user?._id) {
- * @param req 
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
- * @param res 
+    ForbiddenError.from(permission).throwUnlessCan(
- */
+      ProjectPermissionActions.Read,
-export const createSecret = async (req: Request, res: Response) => {
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
-    const { secretName } = req.params;
+    );
-    const { 
+    permissionCheckFn = (env: string, secPath: string) =>
-        workspaceId,
+      permission.can(
-        environment,
+        ProjectPermissionActions.Read,
-        type,
+        subject(ProjectPermissionSub.Secrets, {
-        secretKeyCiphertext,
+          environment: env,
-        secretKeyIV,
+          secretPath: secPath
-        secretKeyTag,
-        secretValueCiphertext,
-        secretValueIV,
-        secretValueTag,
-        secretCommentCiphertext,
-        secretCommentIV,
-        secretCommentTag
-    } = req.body;
-    
-    const secret = await SecretService.createSecret({
-        secretName,
-        workspaceId: new Types.ObjectId(workspaceId),
-        environment,
-        type,
-        authData: req.authData,
-        secretKeyCiphertext,
-        secretKeyIV,
-        secretKeyTag,
-        secretValueCiphertext,
-        secretValueIV,
-        secretValueTag,
-        ...((secretCommentCiphertext && secretCommentIV && secretCommentTag) ? {
-            secretCommentCiphertext,
-            secretCommentIV,
-            secretCommentTag
-        } : {})
-    });
-
-    await EventService.handleEvent({
-        event: eventPushSecrets({
-            workspaceId: new Types.ObjectId(workspaceId),
-            environment
         })
+      );
+  } else {
+    await validateServiceTokenDataClientForWorkspace({
+      serviceTokenData: req.authData.authPayload as IServiceTokenData,
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath,
+      requiredPermissions: [PERMISSION_READ_SECRETS]
     });
+    permissionCheckFn = (env: string, secPath: string) =>
+      isValidScope(req.authData.authPayload as IServiceTokenData, env, secPath);
+  }
 
-    const secretWithoutBlindIndex = secret.toObject();
+  const secrets = await SecretService.getSecrets({
-    delete secretWithoutBlindIndex.secretBlindIndex;
+    workspaceId: new Types.ObjectId(workspaceId),
-    
+    environment,
+    folderId,
+    secretPath,
+    authData: req.authData
+  });
+
+  const key = await BotService.getWorkspaceKeyWithBot({
+    workspaceId: new Types.ObjectId(workspaceId)
+  });
+
+  if (includeImports) {
+    const folders = await Folder.findOne({ workspace: workspaceId, environment });
+    let folderId = "root";
+    // if folder exist get it and replace folderid with new one
+    if (folders) {
+      const folder = getFolderByPath(folders.nodes, secretPath as string);
+      if (!folder) {
+        throw BadRequestError({ message: "Folder not found" });
+      }
+      folderId = folder.id;
+    }
+    const importedSecrets = await getAllImportedSecrets(
+      workspaceId,
+      environment,
+      folderId,
+      permissionCheckFn
+    );
     return res.status(200).send({
-        secret: secretWithoutBlindIndex
+      secrets: secrets.map((secret) =>
+        repackageSecretToRaw({
+          secret,
+          key
+        })
+      ),
+      imports: importedSecrets.map((el) => ({
+        ...el,
+        secrets: el.secrets.map((secret) => repackageSecretToRaw({ secret, key }))
+      }))
     });
-}
+  }
+
+  return res.status(200).send({
+    secrets: secrets.map((secret) => {
+      const rep = repackageSecretToRaw({
+        secret,
+        key
+      });
+      return rep;
+    })
+  });
+};
+
+/**
+ * Return secret with name [secretName] in plaintext
+ * @param req
+ * @param res
+ */
+export const getSecretByNameRaw = async (req: Request, res: Response) => {
+  const {
+    query: { secretPath, environment, workspaceId, type },
+    params: { secretName }
+  } = await validateRequest(reqValidator.GetSecretByNameRawV3, req);
+
+  if (req.user?._id) {
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Read,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+  } else {
+    await validateServiceTokenDataClientForWorkspace({
+      serviceTokenData: req.authData.authPayload as IServiceTokenData,
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath,
+      requiredPermissions: [PERMISSION_READ_SECRETS]
+    });
+  }
+
+  const secret = await SecretService.getSecret({
+    secretName,
+    workspaceId: new Types.ObjectId(workspaceId),
+    environment,
+    type,
+    secretPath,
+    authData: req.authData
+  });
+
+  const key = await BotService.getWorkspaceKeyWithBot({
+    workspaceId: new Types.ObjectId(workspaceId)
+  });
+
+  return res.status(200).send({
+    secret: repackageSecretToRaw({
+      secret,
+      key
+    })
+  });
+};
+
+/**
+ * Create secret with name [secretName] in plaintext
+ * @param req
+ * @param res
+ */
+export const createSecretRaw = async (req: Request, res: Response) => {
+  const {
+    params: { secretName },
+    body: { secretPath, environment, workspaceId, type, secretValue, secretComment }
+  } = await validateRequest(reqValidator.CreateSecretRawV3, req);
+
+  if (req.user?._id) {
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Create,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+  } else {
+    await validateServiceTokenDataClientForWorkspace({
+      serviceTokenData: req.authData.authPayload as IServiceTokenData,
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath,
+      requiredPermissions: [PERMISSION_WRITE_SECRETS]
+    });
+  }
+
+  const key = await BotService.getWorkspaceKeyWithBot({
+    workspaceId: new Types.ObjectId(workspaceId)
+  });
+
+  const secretKeyEncrypted = encryptSymmetric128BitHexKeyUTF8({
+    plaintext: secretName,
+    key
+  });
+
+  const secretValueEncrypted = encryptSymmetric128BitHexKeyUTF8({
+    plaintext: secretValue,
+    key
+  });
+
+  const secretCommentEncrypted = encryptSymmetric128BitHexKeyUTF8({
+    plaintext: secretComment,
+    key
+  });
+
+  const secret = await SecretService.createSecret({
+    secretName,
+    workspaceId: new Types.ObjectId(workspaceId),
+    environment,
+    type,
+    authData: req.authData,
+    secretKeyCiphertext: secretKeyEncrypted.ciphertext,
+    secretKeyIV: secretKeyEncrypted.iv,
+    secretKeyTag: secretKeyEncrypted.tag,
+    secretValueCiphertext: secretValueEncrypted.ciphertext,
+    secretValueIV: secretValueEncrypted.iv,
+    secretValueTag: secretValueEncrypted.tag,
+    secretPath,
+    secretCommentCiphertext: secretCommentEncrypted.ciphertext,
+    secretCommentIV: secretCommentEncrypted.iv,
+    secretCommentTag: secretCommentEncrypted.tag
+  });
+
+  await EventService.handleEvent({
+    event: eventPushSecrets({
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath
+    })
+  });
+
+  const secretWithoutBlindIndex = secret.toObject();
+  delete secretWithoutBlindIndex.secretBlindIndex;
+
+  return res.status(200).send({
+    secret: repackageSecretToRaw({
+      secret: secretWithoutBlindIndex,
+      key
+    })
+  });
+};
 
 /**
  * Update secret with name [secretName]
  * @param req
- * @param res 
+ * @param res
  */
-export const updateSecretByName = async (req: Request, res: Response) => {
+export const updateSecretByNameRaw = async (req: Request, res: Response) => {
-    const { secretName } = req.params;
+  const {
-    const {
+    params: { secretName },
-        workspaceId,
+    body: { secretValue, environment, secretPath, type, workspaceId }
-        environment,
+  } = await validateRequest(reqValidator.UpdateSecretByNameRawV3, req);
-        type,
-        secretValueCiphertext,
-        secretValueIV,
-        secretValueTag
-    } = req.body;
 
-    const secret = await SecretService.updateSecret({
+  if (req.user?._id) {
-        secretName,
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-        workspaceId,
+    ForbiddenError.from(permission).throwUnlessCan(
-        environment,
+      ProjectPermissionActions.Edit,
-        type,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
-        authData: req.authData,
+    );
-        secretValueCiphertext,
+  } else {
-        secretValueIV,
+    await validateServiceTokenDataClientForWorkspace({
-        secretValueTag
+      serviceTokenData: req.authData.authPayload as IServiceTokenData,
-    });
+      workspaceId: new Types.ObjectId(workspaceId),
-    
+      environment,
-    await EventService.handleEvent({
+      secretPath,
-        event: eventPushSecrets({
+      requiredPermissions: [PERMISSION_WRITE_SECRETS]
-            workspaceId: new Types.ObjectId(workspaceId),
-            environment
-        })
     });
+  }
 
-    return res.status(200).send({
+  const key = await BotService.getWorkspaceKeyWithBot({
-        secret
+    workspaceId: new Types.ObjectId(workspaceId)
-    });
+  });
-}
+
+  const secretValueEncrypted = encryptSymmetric128BitHexKeyUTF8({
+    plaintext: secretValue,
+    key
+  });
+
+  const secret = await SecretService.updateSecret({
+    secretName,
+    workspaceId: new Types.ObjectId(workspaceId),
+    environment,
+    type,
+    authData: req.authData,
+    secretValueCiphertext: secretValueEncrypted.ciphertext,
+    secretValueIV: secretValueEncrypted.iv,
+    secretValueTag: secretValueEncrypted.tag,
+    secretPath
+  });
+
+  await EventService.handleEvent({
+    event: eventPushSecrets({
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath
+    })
+  });
+
+  return res.status(200).send({
+    secret: repackageSecretToRaw({
+      secret,
+      key
+    })
+  });
+};
 
 /**
  * Delete secret with name [secretName]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
+ */
+export const deleteSecretByNameRaw = async (req: Request, res: Response) => {
+  const {
+    params: { secretName },
+    body: { environment, secretPath, type, workspaceId }
+  } = await validateRequest(reqValidator.DeleteSecretByNameRawV3, req);
+
+  if (req.user?._id) {
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Delete,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+  } else {
+    await validateServiceTokenDataClientForWorkspace({
+      serviceTokenData: req.authData.authPayload as IServiceTokenData,
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath,
+      requiredPermissions: [PERMISSION_WRITE_SECRETS]
+    });
+  }
+
+  const { secret } = await SecretService.deleteSecret({
+    secretName,
+    workspaceId: new Types.ObjectId(workspaceId),
+    environment,
+    type,
+    authData: req.authData,
+    secretPath
+  });
+
+  await EventService.handleEvent({
+    event: eventPushSecrets({
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath
+    })
+  });
+
+  const key = await BotService.getWorkspaceKeyWithBot({
+    workspaceId: new Types.ObjectId(workspaceId)
+  });
+
+  return res.status(200).send({
+    secret: repackageSecretToRaw({
+      secret,
+      key
+    })
+  });
+};
+
+/**
+ * Get secrets for workspace with id [workspaceId] and environment
+ * [environment]
+ * @param req
+ * @param res
+ */
+export const getSecrets = async (req: Request, res: Response) => {
+  const validatedData = await validateRequest(reqValidator.GetSecretsV3, req);
+  const {
+    query: { environment, workspaceId, include_imports: includeImports, folderId }
+  } = validatedData;
+
+  let {
+    query: { secretPath }
+  } = validatedData;
+
+  if (folderId && folderId !== "root") {
+    const folder = await Folder.findOne({ workspace: workspaceId, environment });
+    if (!folder) throw BadRequestError({ message: "Folder not found" });
+
+    secretPath = getFolderWithPathFromId(folder.nodes, folderId).folderPath;
+  }
+
+  let permissionCheckFn: (env: string, secPath: string) => boolean; // used to pass as callback function to import secret
+  if (req.user?._id) {
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Read,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+    permissionCheckFn = (env: string, secPath: string) =>
+      permission.can(
+        ProjectPermissionActions.Read,
+        subject(ProjectPermissionSub.Secrets, {
+          environment: env,
+          secretPath: secPath
+        })
+      );
+  } else {
+    await validateServiceTokenDataClientForWorkspace({
+      serviceTokenData: req.authData.authPayload as IServiceTokenData,
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath,
+      requiredPermissions: [PERMISSION_READ_SECRETS]
+    });
+    permissionCheckFn = (env: string, secPath: string) =>
+      isValidScope(req.authData.authPayload as IServiceTokenData, env, secPath);
+  }
+
+  const secrets = await SecretService.getSecrets({
+    workspaceId: new Types.ObjectId(workspaceId),
+    environment,
+    folderId,
+    secretPath,
+    authData: req.authData
+  });
+
+  if (includeImports) {
+    const folders = await Folder.findOne({ workspace: workspaceId, environment });
+    let folderId = "root";
+    // if folder exist get it and replace folderid with new one
+    if (folders) {
+      const folder = getFolderByPath(folders.nodes, secretPath as string);
+      if (!folder) {
+        throw BadRequestError({ message: "Folder not found" });
+      }
+      folderId = folder.id;
+    }
+    const importedSecrets = await getAllImportedSecrets(
+      workspaceId,
+      environment,
+      folderId,
+      permissionCheckFn
+    );
+    return res.status(200).send({
+      secrets,
+      imports: importedSecrets
+    });
+  }
+
+  return res.status(200).send({
+    secrets
+  });
+};
+
+/**
+ * Return secret with name [secretName]
+ * @param req
+ * @param res
+ */
+export const getSecretByName = async (req: Request, res: Response) => {
+  const {
+    query: { secretPath, environment, workspaceId, type },
+    params: { secretName }
+  } = await validateRequest(reqValidator.GetSecretByNameV3, req);
+
+  if (req.user?._id) {
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Read,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+  } else {
+    await validateServiceTokenDataClientForWorkspace({
+      serviceTokenData: req.authData.authPayload as IServiceTokenData,
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath,
+      requiredPermissions: [PERMISSION_READ_SECRETS]
+    });
+  }
+
+  const secret = await SecretService.getSecret({
+    secretName,
+    workspaceId: new Types.ObjectId(workspaceId),
+    environment,
+    type,
+    secretPath,
+    authData: req.authData
+  });
+
+  return res.status(200).send({
+    secret
+  });
+};
+
+/**
+ * Create secret with name [secretName]
+ * @param req
+ * @param res
+ */
+export const createSecret = async (req: Request, res: Response) => {
+  const {
+    body: {
+      workspaceId,
+      secretPath,
+      environment,
+      metadata,
+      type,
+      secretKeyIV,
+      secretKeyTag,
+      secretValueIV,
+      secretValueTag,
+      secretCommentIV,
+      secretCommentTag,
+      secretKeyCiphertext,
+      secretValueCiphertext,
+      secretCommentCiphertext
+    },
+    params: { secretName }
+  } = await validateRequest(reqValidator.CreateSecretV3, req);
+
+  if (req.user?._id) {
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Create,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+  } else {
+    await validateServiceTokenDataClientForWorkspace({
+      serviceTokenData: req.authData.authPayload as IServiceTokenData,
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath,
+      requiredPermissions: [PERMISSION_WRITE_SECRETS]
+    });
+  }
+
+  const secret = await SecretService.createSecret({
+    secretName,
+    workspaceId: new Types.ObjectId(workspaceId),
+    environment,
+    type,
+    authData: req.authData,
+    secretKeyCiphertext,
+    secretKeyIV,
+    secretKeyTag,
+    secretValueCiphertext,
+    secretValueIV,
+    secretValueTag,
+    secretPath,
+    secretCommentCiphertext,
+    secretCommentIV,
+    secretCommentTag,
+    metadata
+  });
+
+  await EventService.handleEvent({
+    event: eventPushSecrets({
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath
+    })
+  });
+
+  const secretWithoutBlindIndex = secret.toObject();
+  delete secretWithoutBlindIndex.secretBlindIndex;
+
+  return res.status(200).send({
+    secret: secretWithoutBlindIndex
+  });
+};
+
+/**
+ * Update secret with name [secretName]
+ * @param req
+ * @param res
+ */
+export const updateSecretByName = async (req: Request, res: Response) => {
+  const {
+    body: {
+      secretValueCiphertext,
+      secretValueTag,
+      secretValueIV,
+      type,
+      environment,
+      secretPath,
+      workspaceId
+    },
+    params: { secretName }
+  } = await validateRequest(reqValidator.UpdateSecretByNameV3, req);
+
+  if (req.user?._id) {
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Edit,
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+  } else {
+    await validateServiceTokenDataClientForWorkspace({
+      serviceTokenData: req.authData.authPayload as IServiceTokenData,
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath,
+      requiredPermissions: [PERMISSION_WRITE_SECRETS]
+    });
+  }
+
+  const secret = await SecretService.updateSecret({
+    secretName,
+    workspaceId: new Types.ObjectId(workspaceId),
+    environment,
+    type,
+    authData: req.authData,
+    secretValueCiphertext,
+    secretValueIV,
+    secretValueTag,
+    secretPath
+  });
+
+  await EventService.handleEvent({
+    event: eventPushSecrets({
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath
+    })
+  });
+
+  return res.status(200).send({
+    secret
+  });
+};
+
+/**
+ * Delete secret with name [secretName]
+ * @param req
+ * @param res
  */
 export const deleteSecretByName = async (req: Request, res: Response) => {
-    const { secretName } = req.params;
+  const {
-    const {
+    body: { type, environment, secretPath, workspaceId },
-        workspaceId,
+    params: { secretName }
-        environment,
+  } = await validateRequest(reqValidator.DeleteSecretByNameV3, req);
-        type
-    } = req.body;
-    
-    const { secret, secrets } = await SecretService.deleteSecret({
-        secretName,
-        workspaceId,
-        environment,
-        type,
-        authData: req.authData
-    });
 
-    await EventService.handleEvent({
+  if (req.user?._id) {
-        event: eventPushSecrets({
+    const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
-            workspaceId: new Types.ObjectId(workspaceId),
+    ForbiddenError.from(permission).throwUnlessCan(
-            environment
+      ProjectPermissionActions.Delete,
-        })
+      subject(ProjectPermissionSub.Secrets, { environment, secretPath })
+    );
+  } else {
+    await validateServiceTokenDataClientForWorkspace({
+      serviceTokenData: req.authData.authPayload as IServiceTokenData,
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath,
+      requiredPermissions: [PERMISSION_WRITE_SECRETS]
     });
+  }
 
-    return res.status(200).send({
+  const { secret } = await SecretService.deleteSecret({
-        secret
+    secretName,
-    });
+    workspaceId: new Types.ObjectId(workspaceId),
-}
+    environment,
+    type,
+    authData: req.authData,
+    secretPath
+  });
+
+  await EventService.handleEvent({
+    event: eventPushSecrets({
+      workspaceId: new Types.ObjectId(workspaceId),
+      environment,
+      secretPath
+    })
+  });
+
+  return res.status(200).send({
+    secret
+  });
+};

backend/src/controllers/v3/signupController.ts

@@ -0,0 +1,194 @@
+import jwt from "jsonwebtoken";
+import { Request, Response } from "express";
+import * as Sentry from "@sentry/node";
+import { MembershipOrg, User } from "../../models";
+import { completeAccount } from "../../helpers/user";
+import { initializeDefaultOrg } from "../../helpers/signup";
+import { issueAuthTokens, validateProviderAuthToken } from "../../helpers/auth";
+import { ACCEPTED, INVITED } from "../../variables";
+import { standardRequest } from "../../config/request";
+import { getHttpsEnabled, getJwtSignupSecret, getLoopsApiKey } from "../../config";
+import { BadRequestError } from "../../utils/errors";
+import { TelemetryService } from "../../services";
+import { AuthMethod } from "../../models";
+import { validateRequest } from "../../helpers/validation";
+import * as reqValidator from "../../validation/auth";
+
+/**
+ * Complete setting up user by adding their personal and auth information as part of the
+ * signup flow
+ * @param req
+ * @param res
+ * @returns
+ */
+export const completeAccountSignup = async (req: Request, res: Response) => {
+  let user, token;
+  try {
+    const {
+      body: {
+        email,
+        publicKey,
+        salt,
+        lastName,
+        verifier,
+        firstName,
+        protectedKey,
+        protectedKeyIV,
+        protectedKeyTag,
+        organizationName,
+        providerAuthToken,
+        attributionSource,
+        encryptedPrivateKey,
+        encryptedPrivateKeyIV,
+        encryptedPrivateKeyTag
+      }
+    } = await validateRequest(reqValidator.CompletedAccountSignupV3, req);
+
+    user = await User.findOne({ email });
+
+    if (!user || (user && user?.publicKey)) {
+      // case 1: user doesn't exist.
+      // case 2: user has already completed account
+      return res.status(403).send({
+        error: "Failed to complete account for complete user"
+      });
+    }
+
+    if (providerAuthToken) {
+      await validateProviderAuthToken({
+        email,
+        providerAuthToken
+      });
+    } else {
+      const [AUTH_TOKEN_TYPE, AUTH_TOKEN_VALUE] = <[string, string]>(
+        req.headers["authorization"]?.split(" ", 2)
+      ) ?? [null, null];
+      if (AUTH_TOKEN_TYPE === null) {
+        throw BadRequestError({ message: "Missing Authorization Header in the request header." });
+      }
+      if (AUTH_TOKEN_TYPE.toLowerCase() !== "bearer") {
+        throw BadRequestError({
+          message: `The provided authentication type '${AUTH_TOKEN_TYPE}' is not supported.`
+        });
+      }
+      if (AUTH_TOKEN_VALUE === null) {
+        throw BadRequestError({
+          message: "Missing Authorization Body in the request header"
+        });
+      }
+
+      const decodedToken = <jwt.UserIDJwtPayload>(
+        jwt.verify(AUTH_TOKEN_VALUE, await getJwtSignupSecret())
+      );
+
+      if (decodedToken.userId !== user.id) {
+        throw BadRequestError();
+      }
+    }
+
+    // complete setting up user's account
+    user = await completeAccount({
+      userId: user._id.toString(),
+      firstName,
+      lastName,
+      encryptionVersion: 2,
+      protectedKey,
+      protectedKeyIV,
+      protectedKeyTag,
+      publicKey,
+      encryptedPrivateKey,
+      encryptedPrivateKeyIV,
+      encryptedPrivateKeyTag,
+      salt,
+      verifier
+    });
+
+    if (!user) throw new Error("Failed to complete account for non-existent user"); // ensure user is non-null
+
+    const hasSamlEnabled = user.authMethods.some((authMethod: AuthMethod) =>
+      [AuthMethod.OKTA_SAML, AuthMethod.AZURE_SAML, AuthMethod.JUMPCLOUD_SAML].includes(authMethod)
+    );
+
+    if (!hasSamlEnabled) {
+      // TODO: modify this part
+      // initialize default organization and workspace
+      await initializeDefaultOrg({
+        organizationName,
+        user
+      });
+    }
+
+    // update organization membership statuses that are
+    // invited to completed with user attached
+    await MembershipOrg.updateMany(
+      {
+        inviteEmail: email,
+        status: INVITED
+      },
+      {
+        user,
+        status: ACCEPTED
+      }
+    );
+
+    // issue tokens
+    const tokens = await issueAuthTokens({
+      userId: user._id,
+      ip: req.realIP,
+      userAgent: req.headers["user-agent"] ?? ""
+    });
+
+    token = tokens.token;
+
+    // sending a welcome email to new users
+    if (await getLoopsApiKey()) {
+      await standardRequest.post(
+        "https://app.loops.so/api/v1/events/send",
+        {
+          email: email,
+          eventName: "Sign Up",
+          firstName: firstName,
+          lastName: lastName
+        },
+        {
+          headers: {
+            Accept: "application/json",
+            Authorization: "Bearer " + (await getLoopsApiKey())
+          }
+        }
+      );
+    }
+
+    // store (refresh) token in httpOnly cookie
+    res.cookie("jid", tokens.refreshToken, {
+      httpOnly: true,
+      path: "/",
+      sameSite: "strict",
+      secure: await getHttpsEnabled()
+    });
+
+    const postHogClient = await TelemetryService.getPostHogClient();
+    if (postHogClient) {
+      postHogClient.capture({
+        event: "User Signed Up",
+        distinctId: email,
+        properties: {
+          email,
+          ...(attributionSource ? { attributionSource } : {})
+        }
+      });
+    }
+  } catch (err) {
+    Sentry.setUser(null);
+    Sentry.captureException(err);
+    return res.status(400).send({
+      message: "Failed to complete account setup"
+    });
+  }
+
+  return res.status(200).send({
+    message: "Successfully set up account",
+    user,
+    token
+  });
+};

backend/src/controllers/v3/workspacesController.ts

@@ -1,90 +1,103 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import { Types } from 'mongoose';
+import { Types } from "mongoose";
-import { Secret } from '../../models';
+import { validateRequest } from "../../helpers/validation";
-import { SecretService } from'../../services';
+import { Secret } from "../../models";
+import { SecretService } from "../../services";
+import { getUserProjectPermissions } from "../../ee/services/ProjectRoleService";
+import { UnauthorizedRequestError } from "../../utils/errors";
+import * as reqValidator from "../../validation/workspace";
 
 /**
  * Return whether or not all secrets in workspace with id [workspaceId]
  * are blind-indexed
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const getWorkspaceBlindIndexStatus = async (req: Request, res: Response) => {
-    const { workspaceId } = req.params;
+  const {
+    params: { workspaceId }
+  } = await validateRequest(reqValidator.GetWorkspaceBlinkIndexStatusV3, req);
 
-    const secretsWithoutBlindIndex = await Secret.countDocuments({
+  const { membership } = await getUserProjectPermissions(req.user._id, workspaceId);
-        workspace: new Types.ObjectId(workspaceId),
+  if (membership.role !== "admin")
-        secretBlindIndex: {
+    throw UnauthorizedRequestError({ message: "User must be an admin" });
-            $exists: false
-        }
-    });
 
-    return res.status(200).send(secretsWithoutBlindIndex === 0);
+  const secretsWithoutBlindIndex = await Secret.countDocuments({
-}
+    workspace: new Types.ObjectId(workspaceId),
+    secretBlindIndex: {
+      $exists: false
+    }
+  });
+
+  return res.status(200).send(secretsWithoutBlindIndex === 0);
+};
 
 /**
  * Get all secrets for workspace with id [workspaceId]
  */
 export const getWorkspaceSecrets = async (req: Request, res: Response) => {
-    const { workspaceId } = req.params;
+  const {
+    params: { workspaceId }
+  } = await validateRequest(reqValidator.GetWorkspaceSecretsV3, req);
 
-    const secrets = await Secret.find({
+  const { membership } = await getUserProjectPermissions(req.user._id, workspaceId);
-        workspace: new Types.ObjectId (workspaceId)
+  if (membership.role !== "admin")
-    });
+    throw UnauthorizedRequestError({ message: "User must be an admin" });
-    
+
-    return res.status(200).send({
+  const secrets = await Secret.find({
-        secrets
+    workspace: new Types.ObjectId(workspaceId)
-    });
+  });
-}
+
+  return res.status(200).send({
+    secrets
+  });
+};
 
 /**
  * Update blind indices for secrets in workspace with id [workspaceId]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
  */
 export const nameWorkspaceSecrets = async (req: Request, res: Response) => {
-    interface SecretToUpdate {
+  const {
-        secretName: string;
+    params: { workspaceId },
-        _id: string;
+    body: { secretsToUpdate }
-    }
+  } = await validateRequest(reqValidator.NameWorkspaceSecretsV3, req);
 
-    const { workspaceId } = req.params;
+  const { membership } = await getUserProjectPermissions(req.user._id, workspaceId);
-    const { 
+  if (membership.role !== "admin")
-        secretsToUpdate 
+    throw UnauthorizedRequestError({ message: "User must be an admin" });
-    }: {
-        secretsToUpdate: SecretToUpdate[];
-    } = req.body;
 
-    // get secret blind index salt
+  // get secret blind index salt
-    const salt = await SecretService.getSecretBlindIndexSalt({
+  const salt = await SecretService.getSecretBlindIndexSalt({
-        workspaceId: new Types.ObjectId(workspaceId)
+    workspaceId: new Types.ObjectId(workspaceId)
-    });
+  });
 
-    // update secret blind indices
+  // update secret blind indices
-    const operations = await Promise.all(
+  const operations = await Promise.all(
-        secretsToUpdate.map(async (secretToUpdate: SecretToUpdate) => {
+    secretsToUpdate.map(async (secretToUpdate) => {
-            const secretBlindIndex = await SecretService.generateSecretBlindIndexWithSalt({
+      const secretBlindIndex = await SecretService.generateSecretBlindIndexWithSalt({
-                secretName: secretToUpdate.secretName,
+        secretName: secretToUpdate.secretName,
-                salt
+        salt
-            });
+      });
-    
-            return ({
-                updateOne: {
-                    filter: {
-                        _id: new Types.ObjectId(secretToUpdate._id)
-                    },
-                    update: {
-                        secretBlindIndex
-                    }
-                }
-            });
-        })
-    );
 
-    await Secret.bulkWrite(operations);
+      return {
+        updateOne: {
+          filter: {
+            _id: new Types.ObjectId(secretToUpdate._id)
+          },
+          update: {
+            secretBlindIndex
+          }
+        }
+      };
+    })
+  );
 
-    return res.status(200).send({
+  await Secret.bulkWrite(operations);
-        message: 'Successfully named workspace secrets'
+
-    });
+  return res.status(200).send({
-}
+    message: "Successfully named workspace secrets"
+  });
+};

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

@@ -1,31 +1,32 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import * as Sentry from '@sentry/node';
+import { Action } from "../../models";
-import { Action, SecretVersion } from '../../models';
+import { ActionNotFoundError } from "../../../utils/errors";
-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;
+  let action;
-    try {
+  try {
-        const { actionId } = req.params;
+    const {
-        
+      params: { actionId }
-        action = await Action
+    } = await validateRequest(reqValidator.GetActionV1, req);
-            .findById(actionId)
-            .populate([
-                'payload.secretVersions.oldSecretVersion',
-                'payload.secretVersions.newSecretVersion'
-            ]);
-        
-        if (!action) throw ActionNotFoundError({
-            message: 'Failed to find action'
-        });
 
-    } catch (err) {
+    action = await Action.findById(actionId).populate([
-        throw ActionNotFoundError({
+      "payload.secretVersions.oldSecretVersion",
-            message: 'Failed to find action'
+      "payload.secretVersions.newSecretVersion"
-        });
+    ]);
-    }
+
-    
+    if (!action)
-    return res.status(200).send({
+      throw ActionNotFoundError({
-        action
+        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/cloudProductsController.ts

@@ -1,34 +1,32 @@
-import * as Sentry from '@sentry/node';
+import { Request, Response } from "express";
-import { Request, Response } from 'express';
+import { EELicenseService } from "../../services";
-import { EELicenseService } from '../../services';
+import { getLicenseServerUrl } from "../../../config";
-import { getLicenseServerUrl } from '../../../config';
+import { licenseServerKeyRequest } from "../../../config/request";
-import { licenseServerKeyRequest } from '../../../config/request';
+import { validateRequest } from "../../../helpers/validation";
+import * as reqValidator from "../../../validation/cloudProducts";
 
 /**
  * Return available cloud product information.
  * Note: Nicely formatted to easily construct a table from
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const getCloudProducts = async (req: Request, res: Response) => {
-    try {
+  const {
-        const billingCycle = req.query['billing-cycle'] as string;
+    query: { "billing-cycle": billingCycle }
+  } = await validateRequest(reqValidator.GetCloudProductsV1, req);
 
-        if (EELicenseService.instanceType === 'cloud') {
+  if (EELicenseService.instanceType === "cloud") {
-            const { data } = await licenseServerKeyRequest.get(
+    const { data } = await licenseServerKeyRequest.get(
-                `${await getLicenseServerUrl()}/api/license-server/v1/cloud-products?billing-cycle=${billingCycle}`
+      `${await getLicenseServerUrl()}/api/license-server/v1/cloud-products?billing-cycle=${billingCycle}`
-            ); 
+    );
 
-            return res.status(200).send(data);
+    return res.status(200).send(data);
-        }
+  }
-    } catch (err) {
+
-        Sentry.setUser({ email: req.user.email });
+  return res.status(200).send({
-        Sentry.captureException(err);
+    head: [],
-    }
+    rows: []
-    
+  });
-    return res.status(200).send({
+};
-        head: [],
-        rows: []
-    });
-}

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

@@ -1,19 +1,23 @@
-import * as stripeController from './stripeController';
+import * as secretController from "./secretController";
-import * as secretController from './secretController';
+import * as secretSnapshotController from "./secretSnapshotController";
-import * as secretSnapshotController from './secretSnapshotController';
+import * as organizationsController from "./organizationsController";
-import * as organizationsController from './organizationsController';
+import * as ssoController from "./ssoController";
-import * as workspaceController from './workspaceController';
+import * as usersController from "./usersController";
-import * as actionController from './actionController';
+import * as workspaceController from "./workspaceController";
-import * as membershipController from './membershipController';
+import * as actionController from "./actionController";
-import * as cloudProductsController from './cloudProductsController';
+import * as membershipController from "./membershipController";
+import * as cloudProductsController from "./cloudProductsController";
+import * as roleController from "./roleController";
 
 export {
-    stripeController,
+  secretController,
-    secretController,
+  secretSnapshotController,
-    secretSnapshotController,
+  organizationsController,
-    organizationsController,
+  ssoController,
-    workspaceController,
+  usersController,
-    actionController,
+  workspaceController,
-    membershipController,
+  actionController,
-    cloudProductsController
+  membershipController,
-}
+  cloudProductsController,
+  roleController
+};

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

@@ -1,11 +1,12 @@
 import { Request, Response } from "express";
-import { Membership, Workspace } from "../../../models";
+import { IUser, Membership, Workspace } from "../../../models";
+import { EventType } from "../../../ee/models";
 import { IMembershipPermission } from "../../../models/membership";
 import { BadRequestError, UnauthorizedRequestError } from "../../../utils/errors";
 import { ADMIN, MEMBER } from "../../../variables/organization";
-import { PERMISSION_READ_SECRETS, PERMISSION_WRITE_SECRETS } from '../../../variables';
+import { PERMISSION_READ_SECRETS, PERMISSION_WRITE_SECRETS } from "../../../variables";
-import { Builder } from "builder-pattern"
 import _ from "lodash";
+import { EEAuditLogService } from "../../services";
 
 export const denyMembershipPermissions = async (req: Request, res: Response) => {
   const { membershipId } = req.params;
@@ -15,10 +16,10 @@ export const denyMembershipPermissions = async (req: Request, res: Response) =>
       throw BadRequestError({ message: "One or more required fields are missing from the request or have incorrect type" })
     }
 
-    return Builder<IMembershipPermission>()
+    return {
-      .environmentSlug(permission.environmentSlug)
+      environmentSlug: permission.environmentSlug,
-      .ability(permission.ability)
+      ability: permission.ability
-      .build();
+    }
   })
 
   const sanitizedMembershipPermissionsUnique = _.uniqWith(sanitizedMembershipPermissions, _.isEqual)
@@ -39,7 +40,7 @@ export const denyMembershipPermissions = async (req: Request, res: Response) =>
     throw BadRequestError({ message: "Something went wrong when locating the related workspace" })
   }
 
-  const uniqueEnvironmentSlugs = new Set(_.uniq(_.map(relatedWorkspace.environments, 'slug')));
+  const uniqueEnvironmentSlugs = new Set(_.uniq(_.map(relatedWorkspace.environments, "slug")));
 
   sanitizedMembershipPermissionsUnique.forEach(permission => {
     if (!uniqueEnvironmentSlugs.has(permission.environmentSlug)) {
@@ -52,13 +53,34 @@ export const denyMembershipPermissions = async (req: Request, res: Response) =>
     { _id: membershipToModify._id },
     { $set: { deniedPermissions: sanitizedMembershipPermissionsUnique } },
     { new: true }
-  )
+  ).populate<{ user: IUser }>("user");
 
   if (!updatedMembershipWithPermissions) {
     throw BadRequestError({ message: "The resource has been removed before it can be modified" })
   }
 
+  await EEAuditLogService.createAuditLog(
+    req.authData,
+    {
+      type: EventType.UPDATE_USER_WORKSPACE_DENIED_PERMISSIONS,
+      metadata: {
+        userId: updatedMembershipWithPermissions.user._id.toString(),
+        email: updatedMembershipWithPermissions.user.email,
+        deniedPermissions: updatedMembershipWithPermissions.deniedPermissions.map(({
+          environmentSlug,
+          ability
+        }) => ({
+          environmentSlug,
+          ability
+        }))
+      }
+    },
+    {
+      workspaceId: updatedMembershipWithPermissions.workspace
+    }
+  );
+
   res.send({
-    permissionsDenied: updatedMembershipWithPermissions.deniedPermissions
+    permissionsDenied: updatedMembershipWithPermissions.deniedPermissions,
   })
 }

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

@@ -1,83 +1,505 @@
-import { Request, Response } from 'express';
+import { Types } from "mongoose";
-import { getLicenseServerUrl } from '../../../config';
+import { Request, Response } from "express";
-import { licenseServerKeyRequest } from '../../../config/request';
+import { getLicenseServerUrl } from "../../../config";
-import { EELicenseService } from '../../services';
+import { licenseServerKeyRequest } from "../../../config/request";
+import { EELicenseService } from "../../services";
+import { validateRequest } from "../../../helpers/validation";
+import * as reqValidator from "../../../validation/organization";
+import {
+  OrgPermissionActions,
+  OrgPermissionSubjects,
+  getUserOrgPermissions
+} from "../../services/RoleService";
+import { ForbiddenError } from "@casl/ability";
+import { Organization } from "../../../models";
+import { OrganizationNotFoundError } from "../../../utils/errors";
+
+export const getOrganizationPlansTable = async (req: Request, res: Response) => {
+  const {
+    query: { billingCycle },
+    params: { organizationId }
+  } = await validateRequest(reqValidator.GetOrgPlansTablev1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Read,
+    OrgPermissionSubjects.Billing
+  );
+
+  const { data } = await licenseServerKeyRequest.get(
+    `${await getLicenseServerUrl()}/api/license-server/v1/cloud-products?billing-cycle=${billingCycle}`
+  );
+
+  return res.status(200).send(data);
+};
 
 /**
- * Return the organization's current plan and allowed feature set
+ * Return the organization current plan's feature set
  */
 export const getOrganizationPlan = async (req: Request, res: Response) => {
-    const { organizationId } = req.params;
+  const {
+    query: { workspaceId },
+    params: { organizationId }
+  } = await validateRequest(reqValidator.GetOrgPlanv1, req);
 
-    const plan = await EELicenseService.getOrganizationPlan(organizationId);
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Read,
+    OrgPermissionSubjects.Billing
+  );
 
-    return res.status(200).send({
+  const plan = await EELicenseService.getPlan(
-        plan,
+    new Types.ObjectId(organizationId),
-    });
+    new Types.ObjectId(workspaceId)
-}
+  );
+
+  return res.status(200).send({
+    plan
+  });
+};
 
 /**
- * Update the organization plan to product with id [productId]
+ * Return checkout url for pro trial
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
-export const updateOrganizationPlan = async (req: Request, res: Response) => {
+export const startOrganizationTrial = async (req: Request, res: Response) => {
-    const {
+  const {
-        productId
+    params: { organizationId },
-    } = req.body;
+    body: { success_url }
+  } = await validateRequest(reqValidator.StartOrgTrailv1, req);
 
-    const { data  } = await licenseServerKeyRequest.patch(
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-        `${await getLicenseServerUrl()}/api/license-server/v1/customers/${req.organization.customerId}/cloud-plan`,
+  ForbiddenError.from(permission).throwUnlessCan(
-        {
+    OrgPermissionActions.Create,
-            productId
+    OrgPermissionSubjects.Billing
-        }
+  );
-    ); 
+  ForbiddenError.from(permission).throwUnlessCan(
-    
+    OrgPermissionActions.Edit,
-    return res.status(200).send(data);
+    OrgPermissionSubjects.Billing
-}
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const {
+    data: { url }
+  } = await licenseServerKeyRequest.post(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/session/trial`,
+    {
+      success_url
+    }
+  );
+
+  EELicenseService.delPlan(new Types.ObjectId(organizationId));
+
+  return res.status(200).send({
+    url
+  });
+};
+
+/**
+ * Return the organization's current plan's billing info
+ * @param req
+ * @param res
+ * @returns
+ */
+export const getOrganizationPlanBillingInfo = async (req: Request, res: Response) => {
+  const {
+    params: { organizationId }
+  } = await validateRequest(reqValidator.GetOrgPlanBillingInfov1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Read,
+    OrgPermissionSubjects.Billing
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const { data } = await licenseServerKeyRequest.get(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/cloud-plan/billing`
+  );
+
+  return res.status(200).send(data);
+};
+
+/**
+ * Return the organization's current plan's feature table
+ * @param req
+ * @param res
+ * @returns
+ */
+export const getOrganizationPlanTable = async (req: Request, res: Response) => {
+  const {
+    params: { organizationId }
+  } = await validateRequest(reqValidator.GetOrgPlanTablev1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Read,
+    OrgPermissionSubjects.Billing
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const { data } = await licenseServerKeyRequest.get(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/cloud-plan/table`
+  );
+
+  return res.status(200).send(data);
+};
+
+export const getOrganizationBillingDetails = async (req: Request, res: Response) => {
+  const {
+    params: { organizationId }
+  } = await validateRequest(reqValidator.GetOrgBillingDetailsv1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Read,
+    OrgPermissionSubjects.Billing
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const { data } = await licenseServerKeyRequest.get(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/billing-details`
+  );
+
+  return res.status(200).send(data);
+};
+
+export const updateOrganizationBillingDetails = async (req: Request, res: Response) => {
+  const {
+    params: { organizationId },
+    body: { name, email }
+  } = await validateRequest(reqValidator.UpdateOrgBillingDetailsv1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Edit,
+    OrgPermissionSubjects.Billing
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const { data } = await licenseServerKeyRequest.patch(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/billing-details`,
+    {
+      ...(name ? { name } : {}),
+      ...(email ? { email } : {})
+    }
+  );
+
+  return res.status(200).send(data);
+};
 
 /**
  * Return the organization's payment methods on file
  */
 export const getOrganizationPmtMethods = async (req: Request, res: Response) => {
-    const { data: { pmtMethods } } = await licenseServerKeyRequest.get(
+  const {
-        `${await getLicenseServerUrl()}/api/license-server/v1/customers/${req.organization.customerId}/billing-details/payment-methods`
+    params: { organizationId }
-    );
+  } = await validateRequest(reqValidator.GetOrgPmtMethodsv1, req);
 
-    return res.status(200).send({
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-        pmtMethods
+  ForbiddenError.from(permission).throwUnlessCan(
-    }); 
+    OrgPermissionActions.Read,
-}
+    OrgPermissionSubjects.Billing
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const {
+    data: { pmtMethods }
+  } = await licenseServerKeyRequest.get(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/billing-details/payment-methods`
+  );
+
+  return res.status(200).send(pmtMethods);
+};
 
 /**
- * Return a Stripe session URL to add payment method for organization
+ * Return URL to add payment method for organization
  */
 export const addOrganizationPmtMethod = async (req: Request, res: Response) => {
-    const {
+  const {
-        success_url,
+    params: { organizationId },
-        cancel_url
+    body: { success_url, cancel_url }
-    } = req.body;
+  } = await validateRequest(reqValidator.CreateOrgPmtMethodv1, req);
-    
-    const { data: { url } } = await licenseServerKeyRequest.post(
-        `${await getLicenseServerUrl()}/api/license-server/v1/customers/${req.organization.customerId}/billing-details/payment-methods`,
-        {
-            success_url,
-            cancel_url
-        }
-    );
-    
-    return res.status(200).send({
-        url
-    }); 
-}
 
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Create,
+    OrgPermissionSubjects.Billing
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const {
+    data: { url }
+  } = await licenseServerKeyRequest.post(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/billing-details/payment-methods`,
+    {
+      success_url,
+      cancel_url
+    }
+  );
+
+  return res.status(200).send({
+    url
+  });
+};
+
+/**
+ * Delete payment method with id [pmtMethodId] for organization
+ * @param req
+ * @param res
+ * @returns
+ */
 export const deleteOrganizationPmtMethod = async (req: Request, res: Response) => {
-    const { pmtMethodId } = req.params;
+  const {
+    params: { organizationId, pmtMethodId }
+  } = await validateRequest(reqValidator.DelOrgPmtMethodv1, req);
 
-    const { data } = await licenseServerKeyRequest.delete(
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
-        `${await getLicenseServerUrl()}/api/license-server/v1/customers/${req.organization.customerId}/billing-details/payment-methods/${pmtMethodId}`,
+  ForbiddenError.from(permission).throwUnlessCan(
-    );
+    OrgPermissionActions.Delete,
-        
+    OrgPermissionSubjects.Billing
-    return res.status(200).send(data);
+  );
-}
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const { data } = await licenseServerKeyRequest.delete(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/billing-details/payment-methods/${pmtMethodId}`
+  );
+
+  return res.status(200).send(data);
+};
+
+/**
+ * Return the organization's tax ids on file
+ */
+export const getOrganizationTaxIds = async (req: Request, res: Response) => {
+  const {
+    params: { organizationId }
+  } = await validateRequest(reqValidator.GetOrgTaxIdsv1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Read,
+    OrgPermissionSubjects.Billing
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const {
+    data: { tax_ids }
+  } = await licenseServerKeyRequest.get(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/billing-details/tax-ids`
+  );
+
+  return res.status(200).send(tax_ids);
+};
+
+/**
+ * Add tax id to organization
+ */
+export const addOrganizationTaxId = async (req: Request, res: Response) => {
+  const {
+    params: { organizationId },
+    body: { type, value }
+  } = await validateRequest(reqValidator.CreateOrgTaxId, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Create,
+    OrgPermissionSubjects.Billing
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const { data } = await licenseServerKeyRequest.post(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/billing-details/tax-ids`,
+    {
+      type,
+      value
+    }
+  );
+
+  return res.status(200).send(data);
+};
+
+/**
+ * Delete tax id with id [taxId] from organization tax ids on file
+ * @param req
+ * @param res
+ * @returns
+ */
+export const deleteOrganizationTaxId = async (req: Request, res: Response) => {
+  const {
+    params: { organizationId, taxId }
+  } = await validateRequest(reqValidator.DelOrgTaxIdv1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Delete,
+    OrgPermissionSubjects.Billing
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const { data } = await licenseServerKeyRequest.delete(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/billing-details/tax-ids/${taxId}`
+  );
+
+  return res.status(200).send(data);
+};
+
+/**
+ * Return organization's invoices on file
+ * @param req
+ * @param res
+ * @returns
+ */
+export const getOrganizationInvoices = async (req: Request, res: Response) => {
+  const {
+    params: { organizationId }
+  } = await validateRequest(reqValidator.GetOrgInvoicesv1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Read,
+    OrgPermissionSubjects.Billing
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const {
+    data: { invoices }
+  } = await licenseServerKeyRequest.get(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/invoices`
+  );
+
+  return res.status(200).send(invoices);
+};
+
+/**
+ * Return organization's licenses on file
+ * @param req
+ * @param res
+ * @returns
+ */
+export const getOrganizationLicenses = async (req: Request, res: Response) => {
+  const {
+    params: { organizationId }
+  } = await validateRequest(reqValidator.GetOrgLicencesv1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Read,
+    OrgPermissionSubjects.Billing
+  );
+
+  const organization = await Organization.findById(organizationId);
+  if (!organization) {
+    throw OrganizationNotFoundError({
+      message: "Failed to find organization"
+    });
+  }
+
+  const {
+    data: { licenses }
+  } = await licenseServerKeyRequest.get(
+    `${await getLicenseServerUrl()}/api/license-server/v1/customers/${
+      organization.customerId
+    }/licenses`
+  );
+
+  return res.status(200).send(licenses);
+};

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

@@ -0,0 +1,235 @@
+import { Request, Response } from "express";
+import {
+  CreateRoleSchema,
+  DeleteRoleSchema,
+  GetRoleSchema,
+  GetUserPermission,
+  GetUserProjectPermission,
+  UpdateRoleSchema
+} from "../../validation/role";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  adminProjectPermissions,
+  getUserProjectPermissions,
+  memberProjectPermissions,
+  viewerProjectPermission
+} from "../../services/ProjectRoleService";
+import {
+  OrgPermissionActions,
+  OrgPermissionSubjects,
+  adminPermissions,
+  getUserOrgPermissions,
+  memberPermissions
+} from "../../services/RoleService";
+import { BadRequestError } from "../../../utils/errors";
+import Role from "../../models/role";
+import { validateRequest } from "../../../helpers/validation";
+import { packRules } from "@casl/ability/extra";
+
+export const createRole = async (req: Request, res: Response) => {
+  const {
+    body: { workspaceId, name, description, slug, permissions, orgId }
+  } = await validateRequest(CreateRoleSchema, req);
+
+  const isOrgRole = !workspaceId; // if workspaceid is provided then its a workspace rule
+  if (isOrgRole) {
+    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 getUserProjectPermissions(req.user.id, workspaceId);
+    if (permission.cannot(ProjectPermissionActions.Create, ProjectPermissionSub.Role)) {
+      throw BadRequestError({ message: "User doesn't have the permission." });
+    }
+  }
+
+  const existingRole = await Role.findOne({ organization: orgId, workspace: workspaceId, slug });
+  if (existingRole) {
+    throw BadRequestError({ message: "Role already exist" });
+  }
+
+  const role = new Role({
+    organization: orgId,
+    workspace: workspaceId,
+    isOrgRole,
+    name,
+    slug,
+    permissions,
+    description
+  });
+  await role.save();
+
+  res.status(200).json({
+    message: "Successfully created role",
+    data: {
+      role
+    }
+  });
+};
+
+export const updateRole = async (req: Request, res: Response) => {
+  const {
+    params: { id },
+    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 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 getUserProjectPermissions(req.user.id, workspaceId);
+    if (permission.cannot(ProjectPermissionActions.Edit, ProjectPermissionSub.Role)) {
+      throw BadRequestError({ message: "User doesn't have the workspace permission." });
+    }
+  }
+
+  if (slug) {
+    const existingRole = await Role.findOne({
+      organization: orgId,
+      slug,
+      isOrgRole,
+      workspace: workspaceId
+    });
+    if (existingRole && existingRole.id !== id) {
+      throw BadRequestError({ message: "Role already exist" });
+    }
+  }
+
+  const role = await Role.findByIdAndUpdate(
+    id,
+    { name, description, slug, permissions },
+    { returnDocument: "after" }
+  );
+
+  if (!role) {
+    throw BadRequestError({ message: "Role not found" });
+  }
+  res.status(200).json({
+    message: "Successfully updated role",
+    data: {
+      role
+    }
+  });
+};
+
+export const deleteRole = async (req: Request, res: Response) => {
+  const {
+    params: { id }
+  } = await validateRequest(DeleteRoleSchema, req);
+
+  const role = await Role.findById(id);
+  if (!role) {
+    throw BadRequestError({ message: "Role not found" });
+  }
+
+  const isOrgRole = !role.workspace;
+  if (isOrgRole) {
+    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 getUserProjectPermissions(req.user.id, role.workspace.toString());
+    if (permission.cannot(ProjectPermissionActions.Delete, ProjectPermissionSub.Role)) {
+      throw BadRequestError({ message: "User doesn't have the workspace permission." });
+    }
+  }
+
+  await Role.findByIdAndDelete(role.id);
+
+  res.status(200).json({
+    message: "Successfully deleted role",
+    data: {
+      role
+    }
+  });
+};
+
+export const getRoles = async (req: Request, res: Response) => {
+  const {
+    query: { workspaceId, orgId }
+  } = await validateRequest(GetRoleSchema, req);
+
+  const isOrgRole = !workspaceId;
+  if (isOrgRole) {
+    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 getUserProjectPermissions(req.user.id, workspaceId);
+    if (permission.cannot(ProjectPermissionActions.Read, ProjectPermissionSub.Role)) {
+      throw BadRequestError({ message: "User doesn't have the workspace permission." });
+    }
+  }
+
+  const customRoles = await Role.find({ organization: orgId, isOrgRole, workspace: workspaceId });
+  // as this is shared between org and workspace switch the rule set based on it
+  const roles = [
+    {
+      _id: "admin",
+      name: "Admin",
+      slug: "admin",
+      description: "Complete administration access over the organization",
+      permissions: isOrgRole ? adminPermissions.rules : adminProjectPermissions.rules
+    },
+    {
+      _id: "member",
+      name: isOrgRole ? "Member" : "Developer",
+      slug: "member",
+      description: "Non-administrative role in an organization",
+      permissions: isOrgRole ? memberPermissions.rules : memberProjectPermissions.rules
+    },
+    // viewer role only for project level
+    ...(isOrgRole
+      ? []
+      : [
+          {
+            _id: "viewer",
+            name: "Viewer",
+            slug: "viewer",
+            description: "Non-administrative role in an organization",
+            permissions: viewerProjectPermission.rules
+          }
+        ]),
+    ...customRoles
+  ];
+
+  res.status(200).json({
+    message: "Successfully fetched role list",
+    data: {
+      roles
+    }
+  });
+};
+
+export const getUserPermissions = async (req: Request, res: Response) => {
+  const {
+    params: { orgId }
+  } = await validateRequest(GetUserPermission, req);
+  const { permission } = await getUserOrgPermissions(req.user._id, orgId);
+
+  res.status(200).json({
+    data: {
+      permissions: packRules(permission.rules)
+    }
+  });
+};
+
+export const getUserWorkspacePermissions = async (req: Request, res: Response) => {
+  const {
+    params: { workspaceId }
+  } = await validateRequest(GetUserProjectPermission, req);
+  const { permission } = await getUserProjectPermissions(req.user._id, workspaceId);
+
+  res.status(200).json({
+    data: {
+      permissions: packRules(permission.rules)
+    }
+  });
+};

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

@@ -1,16 +1,25 @@
-import { Request, Response } from 'express';
+import { ForbiddenError, subject } from "@casl/ability";
-import * as Sentry from '@sentry/node';
+import { Request, Response } from "express";
-import { Secret } from '../../../models';
+import { validateRequest } from "../../../helpers/validation";
-import { SecretVersion } from '../../models';
+import { Folder, Secret } from "../../../models";
-import { EESecretService } from '../../services';
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  getUserProjectPermissions
+} from "../../services/ProjectRoleService";
+import { BadRequestError } from "../../../utils/errors";
+import * as reqValidator from "../../../validation";
+import { SecretVersion } from "../../models";
+import { EESecretService } from "../../services";
+import { getFolderWithPathFromId } from "../../../services/FolderService";
 
 /**
  * Return secret versions for secret with id [secretId]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
  */
- export const getSecretVersions = async (req: Request, res: Response) => {
+export const getSecretVersions = async (req: Request, res: Response) => {
-	/* 
+  /* 
     #swagger.summary = 'Return secret versions'
     #swagger.description = 'Return secret versions'
     
@@ -55,41 +64,42 @@ import { EESecretService } from '../../services';
         }
     }   
     */
-	let secretVersions;
+  const {
-	try {
+    params: { secretId },
-		const { secretId } = req.params;
+    query: { offset, limit }
+  } = await validateRequest(reqValidator.GetSecretVersionsV1, req);
 
-		const offset: number = parseInt(req.query.offset as string);
+  const secret = await Secret.findById(secretId);
-		const limit: number = parseInt(req.query.limit as string);
+  if (!secret) {
-		
+    throw BadRequestError({ message: "Failed to find secret" });
-		secretVersions = await SecretVersion.find({
+  }
-			secret: secretId
-		})
-		.sort({ createdAt: -1 })
-		.skip(offset)
-		.limit(limit);
 
-	} catch (err) {
+  const { permission } = await getUserProjectPermissions(req.user._id, secret.workspace.toString());
-		Sentry.setUser({ email: req.user.email });
+  ForbiddenError.from(permission).throwUnlessCan(
-		Sentry.captureException(err);
+    ProjectPermissionActions.Read,
-		return res.status(400).send({
+    ProjectPermissionSub.SecretRollback
-			message: 'Failed to get secret versions'
+  );
-		});
+
-	}
+  const secretVersions = await SecretVersion.find({
-	
+    secret: secretId
-	return res.status(200).send({
+  })
-		secretVersions
+    .sort({ createdAt: -1 })
-	});
+    .skip(offset)
-}
+    .limit(limit);
+
+  return res.status(200).send({
+    secretVersions
+  });
+};
 
 /**
  * Roll back secret with id [secretId] to version [version]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const rollbackSecretVersion = async (req: Request, res: Response) => {
-	/* 
+  /* 
     #swagger.summary = 'Roll back secret to a version.'
     #swagger.description = 'Roll back secret to a version.'
     
@@ -137,97 +147,117 @@ export const rollbackSecretVersion = async (req: Request, res: Response) => {
         }
     }   
     */
-	let secret;
-	try {
-		const { secretId } = req.params;
-		const { version } = req.body;
-		
-		// validate secret version
-		const oldSecretVersion = await SecretVersion.findOne({
-			secret: secretId,
-			version
-		}).select('+secretBlindIndex')
-		
-		if (!oldSecretVersion) throw new Error('Failed to find secret version');
-		
-		const {
-			workspace,
-			type,
-			user,
-			environment,
-			secretBlindIndex,
-			secretKeyCiphertext,
-			secretKeyIV,
-			secretKeyTag,
-			secretValueCiphertext,
-			secretValueIV,
-			secretValueTag,
-			algorithm,
-			keyEncoding
-		} = oldSecretVersion;
-		
-		// update secret
-		secret = await Secret.findByIdAndUpdate(
-			secretId,
-			{
-				$inc: {
-					version: 1
-				},
-				workspace,
-				type,
-				user,
-				environment,
-				...(secretBlindIndex ? { secretBlindIndex } : {}),
-				secretKeyCiphertext,
-				secretKeyIV,
-				secretKeyTag,
-				secretValueCiphertext,
-				secretValueIV,
-				secretValueTag,
-				algorithm,
-				keyEncoding
-			},
-			{
-				new: true
-			}
-		);
-		
-		if (!secret) throw new Error('Failed to find and update secret');
 
-		// add new secret version
+  const {
-		await new SecretVersion({
+    params: { secretId },
-			secret: secretId,
+    body: { version }
-			version: secret.version,
+  } = await validateRequest(reqValidator.RollbackSecretVersionV1, req);
-			workspace,
+
-			type,
+  const toBeUpdatedSec = await Secret.findById(secretId);
-			user,
+  if (!toBeUpdatedSec) {
-			environment,
+    throw BadRequestError({ message: "Failed to find secret" });
-			isDeleted: false,
+  }
-			...(secretBlindIndex ? { secretBlindIndex } : {}),
+  const { permission } = await getUserProjectPermissions(
-			secretKeyCiphertext,
+    req.user._id,
-			secretKeyIV,
+    toBeUpdatedSec.workspace.toString()
-			secretKeyTag,
+  );
-			secretValueCiphertext,
+  ForbiddenError.from(permission).throwUnlessCan(
-			secretValueIV,
+    ProjectPermissionActions.Create,
-			secretValueTag,
+    ProjectPermissionSub.SecretRollback
-			algorithm,
+  );
-			keyEncoding
+
-		}).save();
+  // validate secret version
-		
+  const oldSecretVersion = await SecretVersion.findOne({
-		// take secret snapshot
+    secret: secretId,
-		await EESecretService.takeSecretSnapshot({
+    version
-			workspaceId: secret.workspace
+  }).select("+secretBlindIndex");
-		});
+
-		
+  if (!oldSecretVersion) throw new Error("Failed to find secret version");
-	} catch (err) {
+
-		Sentry.setUser({ email: req.user.email });
+  const {
-		Sentry.captureException(err);
+    workspace,
-		return res.status(400).send({
+    type,
-			message: 'Failed to roll back secret version'
+    user,
-		});
+    environment,
-	}
+    secretBlindIndex,
-	
+    secretKeyCiphertext,
-	return res.status(200).send({
+    secretKeyIV,
-		secret
+    secretKeyTag,
-	});
+    secretValueCiphertext,
-}
+    secretValueIV,
+    secretValueTag,
+    algorithm,
+    folder,
+    keyEncoding
+  } = oldSecretVersion;
+
+  let secretPath = "/";
+  const folders = await Folder.findOne({ workspace, environment });
+  if (folders)
+    secretPath = getFolderWithPathFromId(folders.nodes, folder || "root")?.folderPath || "/";
+  ForbiddenError.from(permission).throwUnlessCan(
+    ProjectPermissionActions.Edit,
+    subject(ProjectPermissionSub.Secrets, { environment: toBeUpdatedSec.environment, secretPath })
+  );
+
+  // update secret
+  const secret = await Secret.findByIdAndUpdate(
+    secretId,
+    {
+      $inc: {
+        version: 1
+      },
+      workspace,
+      type,
+      user,
+      environment,
+      ...(secretBlindIndex ? { secretBlindIndex } : {}),
+      secretKeyCiphertext,
+      secretKeyIV,
+      secretKeyTag,
+      secretValueCiphertext,
+      secretValueIV,
+      secretValueTag,
+      folderId: folder,
+      algorithm,
+      keyEncoding
+    },
+    {
+      new: true
+    }
+  );
+
+  if (!secret) throw new Error("Failed to find and update secret");
+
+  // add new secret version
+  await new SecretVersion({
+    secret: secretId,
+    version: secret.version,
+    workspace,
+    type,
+    user,
+    environment,
+    isDeleted: false,
+    ...(secretBlindIndex ? { secretBlindIndex } : {}),
+    secretKeyCiphertext,
+    secretKeyIV,
+    secretKeyTag,
+    secretValueCiphertext,
+    secretValueIV,
+    secretValueTag,
+    folder,
+    algorithm,
+    keyEncoding
+  }).save();
+
+  // take secret snapshot
+  await EESecretService.takeSecretSnapshot({
+    workspaceId: secret.workspace,
+    environment,
+    folderId: folder
+  });
+
+  return res.status(200).send({
+    secret
+  });
+};

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

@@ -1,33 +1,61 @@
-import { Request, Response } from 'express';
+import { ForbiddenError } from "@casl/ability";
-import * as Sentry from '@sentry/node';
+import { Request, Response } from "express";
-import { SecretSnapshot } from '../../models';
+import { validateRequest } from "../../../helpers/validation";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub,
+  getUserProjectPermissions
+} from "../../services/ProjectRoleService";
+import * as reqValidator from "../../../validation/secretSnapshot";
+import { ISecretVersion, SecretSnapshot, TFolderRootVersionSchema } from "../../models";
 
 /**
  * Return secret snapshot with id [secretSnapshotId]
- * @param req 
+ * @param req
- * @param res 
+ * @param res
- * @returns 
+ * @returns
  */
 export const getSecretSnapshot = async (req: Request, res: Response) => {
-    let secretSnapshot;
+  const {
-    try {
+    params: { secretSnapshotId }
-        const { secretSnapshotId } = req.params;
+  } = await validateRequest(reqValidator.GetSecretSnapshotV1, req);
 
-        secretSnapshot = await SecretSnapshot
+  const secretSnapshot = await SecretSnapshot.findById(secretSnapshotId)
-            .findById(secretSnapshotId)
+    .lean()
-            .populate('secretVersions');
+    .populate<{ secretVersions: ISecretVersion[] }>({
-        
+      path: "secretVersions",
-        if (!secretSnapshot) throw new Error('Failed to find secret snapshot');
+      populate: {
+        path: "tags",
+        model: "Tag"
+      }
+    })
+    .populate<{ folderVersion: TFolderRootVersionSchema }>("folderVersion");
 
-    } catch (err) {
+  if (!secretSnapshot) throw new Error("Failed to find secret snapshot");
-        Sentry.setUser({ email: req.user.email });
+
-		Sentry.captureException(err);
+  const { permission } = await getUserProjectPermissions(
-		return res.status(400).send({
+    req.user._id,
-			message: 'Failed to get secret snapshot'
+    secretSnapshot.workspace.toString()
-		});
+  );
-    }
+  ForbiddenError.from(permission).throwUnlessCan(
-    
+    ProjectPermissionActions.Read,
-    return res.status(200).send({
+    ProjectPermissionSub.SecretRollback
-        secretSnapshot
+  );
-    });
+
-}
+  const folderId = secretSnapshot.folderId;
+  // to show only the folder required secrets
+  secretSnapshot.secretVersions = secretSnapshot.secretVersions.filter(
+    ({ folder }) => folder === folderId
+  );
+
+  secretSnapshot.folderVersion = secretSnapshot?.folderVersion?.nodes?.children?.map(
+    ({ id, name }) => ({
+      id,
+      name
+    })
+  ) as any;
+
+  return res.status(200).send({
+    secretSnapshot
+  });
+};

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

@@ -0,0 +1,259 @@
+import { Request, Response } from "express";
+import { Types } from "mongoose";
+import { BotOrgService } from "../../../services";
+import { SSOConfig } from "../../models";
+import { AuthMethod, MembershipOrg, User } from "../../../models";
+import { getSSOConfigHelper } from "../../helpers/organizations";
+import { client } from "../../../config";
+import { ResourceNotFoundError } from "../../../utils/errors";
+import { getSiteURL } from "../../../config";
+import { EELicenseService } from "../../services";
+import * as reqValidator from "../../../validation/sso";
+import { validateRequest } from "../../../helpers/validation";
+import {
+  OrgPermissionActions,
+  OrgPermissionSubjects,
+  getUserOrgPermissions
+} from "../../services/RoleService";
+import { ForbiddenError } from "@casl/ability";
+
+/**
+ * Redirect user to appropriate SSO endpoint after successful authentication
+ * to finish inputting their master key for logging in or signing up
+ * @param req
+ * @param res
+ * @returns
+ */
+export const redirectSSO = async (req: Request, res: Response) => {
+  if (req.isUserCompleted) {
+    return res.redirect(
+      `${await getSiteURL()}/login/sso?token=${encodeURIComponent(req.providerAuthToken)}`
+    );
+  }
+
+  return res.redirect(
+    `${await getSiteURL()}/signup/sso?token=${encodeURIComponent(req.providerAuthToken)}`
+  );
+};
+
+/**
+ * Return organization SAML SSO configuration
+ * @param req
+ * @param res
+ * @returns
+ */
+export const getSSOConfig = async (req: Request, res: Response) => {
+  const {
+    query: { organizationId }
+  } = await validateRequest(reqValidator.GetSsoConfigv1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Read,
+    OrgPermissionSubjects.Sso
+  );
+
+  const data = await getSSOConfigHelper({
+    organizationId: new Types.ObjectId(organizationId)
+  });
+
+  return res.status(200).send(data);
+};
+
+/**
+ * Update organization SAML SSO configuration
+ * @param req
+ * @param res
+ * @returns
+ */
+export const updateSSOConfig = async (req: Request, res: Response) => {
+  const {
+    body: { organizationId, authProvider, isActive, entryPoint, issuer, cert }
+  } = await validateRequest(reqValidator.UpdateSsoConfigv1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Edit,
+    OrgPermissionSubjects.Sso
+  );
+
+  const plan = await EELicenseService.getPlan(new Types.ObjectId(organizationId));
+
+  if (!plan.samlSSO)
+    return res.status(400).send({
+      message:
+        "Failed to update SAML SSO configuration due to plan restriction. Upgrade plan to update SSO configuration."
+    });
+
+  interface PatchUpdate {
+    authProvider?: string;
+    isActive?: boolean;
+    encryptedEntryPoint?: string;
+    entryPointIV?: string;
+    entryPointTag?: string;
+    encryptedIssuer?: string;
+    issuerIV?: string;
+    issuerTag?: string;
+    encryptedCert?: string;
+    certIV?: string;
+    certTag?: string;
+  }
+
+  const update: PatchUpdate = {};
+
+  if (authProvider) {
+    update.authProvider = authProvider;
+  }
+
+  if (isActive !== undefined) {
+    update.isActive = isActive;
+  }
+
+  const key = await BotOrgService.getSymmetricKey(new Types.ObjectId(organizationId));
+
+  if (entryPoint) {
+    const {
+      ciphertext: encryptedEntryPoint,
+      iv: entryPointIV,
+      tag: entryPointTag
+    } = client.encryptSymmetric(entryPoint, key);
+
+    update.encryptedEntryPoint = encryptedEntryPoint;
+    update.entryPointIV = entryPointIV;
+    update.entryPointTag = entryPointTag;
+  }
+
+  if (issuer) {
+    const {
+      ciphertext: encryptedIssuer,
+      iv: issuerIV,
+      tag: issuerTag
+    } = client.encryptSymmetric(issuer, key);
+
+    update.encryptedIssuer = encryptedIssuer;
+    update.issuerIV = issuerIV;
+    update.issuerTag = issuerTag;
+  }
+
+  if (cert) {
+    const {
+      ciphertext: encryptedCert,
+      iv: certIV,
+      tag: certTag
+    } = client.encryptSymmetric(cert, key);
+
+    update.encryptedCert = encryptedCert;
+    update.certIV = certIV;
+    update.certTag = certTag;
+  }
+
+  const ssoConfig = await SSOConfig.findOneAndUpdate(
+    {
+      organization: new Types.ObjectId(organizationId)
+    },
+    update,
+    {
+      new: true
+    }
+  );
+
+  if (!ssoConfig)
+    throw ResourceNotFoundError({
+      message: "Failed to find SSO config to update"
+    });
+
+  if (update.isActive !== undefined) {
+    const membershipOrgs = await MembershipOrg.find({
+      organization: new Types.ObjectId(organizationId)
+    }).select("user");
+
+    if (update.isActive) {
+      await User.updateMany(
+        {
+          _id: {
+            $in: membershipOrgs.map((membershipOrg) => membershipOrg.user)
+          }
+        },
+        {
+          authMethods: [ssoConfig.authProvider]
+        }
+      );
+    } else {
+      await User.updateMany(
+        {
+          _id: {
+            $in: membershipOrgs.map((membershipOrg) => membershipOrg.user)
+          }
+        },
+        {
+          authMethods: [AuthMethod.EMAIL]
+        }
+      );
+    }
+  }
+
+  return res.status(200).send(ssoConfig);
+};
+
+/**
+ * Create organization SAML SSO configuration
+ * @param req
+ * @param res
+ * @returns
+ */
+export const createSSOConfig = async (req: Request, res: Response) => {
+  const {
+    body: { organizationId, authProvider, isActive, entryPoint, issuer, cert }
+  } = await validateRequest(reqValidator.CreateSsoConfigv1, req);
+
+  const { permission } = await getUserOrgPermissions(req.user._id, organizationId);
+  ForbiddenError.from(permission).throwUnlessCan(
+    OrgPermissionActions.Create,
+    OrgPermissionSubjects.Sso
+  );
+
+  const plan = await EELicenseService.getPlan(new Types.ObjectId(organizationId));
+
+  if (!plan.samlSSO)
+    return res.status(400).send({
+      message:
+        "Failed to create SAML SSO configuration due to plan restriction. Upgrade plan to add SSO configuration."
+    });
+
+  const key = await BotOrgService.getSymmetricKey(new Types.ObjectId(organizationId));
+
+  const {
+    ciphertext: encryptedEntryPoint,
+    iv: entryPointIV,
+    tag: entryPointTag
+  } = client.encryptSymmetric(entryPoint, key);
+
+  const {
+    ciphertext: encryptedIssuer,
+    iv: issuerIV,
+    tag: issuerTag
+  } = client.encryptSymmetric(issuer, key);
+
+  const {
+    ciphertext: encryptedCert,
+    iv: certIV,
+    tag: certTag
+  } = client.encryptSymmetric(cert, key);
+
+  const ssoConfig = await new SSOConfig({
+    organization: new Types.ObjectId(organizationId),
+    authProvider,
+    isActive,
+    encryptedEntryPoint,
+    entryPointIV,
+    entryPointTag,
+    encryptedIssuer,
+    issuerIV,
+    issuerTag,
+    encryptedCert,
+    certIV,
+    certTag
+  }).save();
+
+  return res.status(200).send(ssoConfig);
+};

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

@@ -1,41 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { Request, Response } from 'express';
-import Stripe from 'stripe';
-import { getStripeSecretKey, getStripeWebhookSecret } from '../../../config';
-
-/**
- * Handle service provisioning/un-provisioning via Stripe
- * @param req
- * @param res
- * @returns
- */
-export const handleWebhook = async (req: Request, res: Response) => {
-	let event;
-	try {
-		const stripe = new Stripe(await getStripeSecretKey(), {
-			apiVersion: '2022-08-01'
-		});
-
-		// check request for valid stripe signature
-		const sig = req.headers['stripe-signature'] as string;
-		event = stripe.webhooks.constructEvent(
-			req.body,
-			sig,
-			await getStripeWebhookSecret()
-		);
-	} catch (err) {
-		Sentry.setUser({ email: req.user.email });
-		Sentry.captureException(err);
-		return res.status(400).send({
-			error: 'Failed to process webhook'
-		});
-	}
-
-	switch (event.type) {
-		case '':
-			break;
-		default:
-	}
-
-	return res.json({ received: true });
-};

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

@@ -0,0 +1,13 @@
+import { Request, Response } from "express";
+
+/**
+ * Return the ip address of the current user
+ * @param req 
+ * @param res 
+ * @returns 
+ */
+export const getMyIp = (req: Request, res: Response) => {
+    return res.status(200).send({
+        ip: req.authData.ipAddress
+    });
+}

backend/src/ee/helpers/action.ts

@@ -1,17 +1,17 @@
-import { Types } from 'mongoose';
+import { Types } from "mongoose";
-import { Action } from '../models';
+import { Action } from "../models";
 import { 
+    getLatestNSecretSecretVersionIds,
     getLatestSecretVersionIds,
-    getLatestNSecretSecretVersionIds
+} from "../helpers/secretVersion";
-} from '../helpers/secretVersion';
 import { 
+    ACTION_ADD_SECRETS,
+    ACTION_DELETE_SECRETS,
     ACTION_LOGIN,
     ACTION_LOGOUT,
-    ACTION_ADD_SECRETS,
     ACTION_READ_SECRETS,
-    ACTION_DELETE_SECRETS,
     ACTION_UPDATE_SECRETS,
-} from '../../variables';
+} from "../../variables";
 
 /**
  * Create an (audit) action for updating secrets
@@ -26,7 +26,7 @@ const createActionUpdateSecret = async ({
     serviceAccountId,
     serviceTokenDataId,
     workspaceId,
-    secretIds
+    secretIds,
 }: {
     name: string;
     userId?: Types.ObjectId;
@@ -37,11 +37,11 @@ const createActionUpdateSecret = async ({
 }) => {
     const latestSecretVersions = (await getLatestNSecretSecretVersionIds({
             secretIds,
-            n: 2
+            n: 2,
         }))
         .map((s) => ({
             oldSecretVersion: s.versions[0]._id,
-            newSecretVersion: s.versions[1]._id
+            newSecretVersion: s.versions[1]._id,
         }));
     
     const action = await new Action({
@@ -51,8 +51,8 @@ const createActionUpdateSecret = async ({
         serviceTokenData: serviceTokenDataId,
         workspace: workspaceId,
         payload: {
-            secretVersions: latestSecretVersions
+            secretVersions: latestSecretVersions,
-        }
+        },
     }).save();
     
     return action;
@@ -72,7 +72,7 @@ const createActionSecret = async ({
     serviceAccountId,
     serviceTokenDataId,
     workspaceId,
-    secretIds
+    secretIds,
 }: {
     name: string;
     userId?: Types.ObjectId;
@@ -84,10 +84,10 @@ const createActionSecret = async ({
     // case: action is adding, deleting, or reading secrets
     // -> add new secret versions
     const latestSecretVersions = (await getLatestSecretVersionIds({
-        secretIds
+        secretIds,
     }))
     .map((s) => ({
-        newSecretVersion: s.versionId
+        newSecretVersion: s.versionId,
     }));
     
    const action = await new Action({
@@ -97,8 +97,8 @@ const createActionSecret = async ({
         serviceTokenData: serviceTokenDataId,
         workspace: workspaceId,
         payload: {
-            secretVersions: latestSecretVersions
+            secretVersions: latestSecretVersions,
-        }
+        },
     }).save(); 
     
     return action;
@@ -116,7 +116,7 @@ const createActionClient = ({
     name,
     userId,
     serviceAccountId,
-    serviceTokenDataId
+    serviceTokenDataId,
 }: {
     name: string;
     userId?: Types.ObjectId;
@@ -127,7 +127,7 @@ const createActionClient = ({
         name,
         user: userId,
         serviceAccount: serviceAccountId,
-        serviceTokenData: serviceTokenDataId
+        serviceTokenData: serviceTokenDataId,
     }).save();
 
     return action; 
@@ -162,27 +162,27 @@ const createActionHelper = async ({
         case ACTION_LOGOUT:
             action = await createActionClient({
                 name,
-                userId
+                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');
+            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
+                secretIds,
             });
             break;
         case ACTION_UPDATE_SECRETS:
-            if (!workspaceId || !secretIds) throw new Error('Missing required params workspace id or secret ids to create action secret');
+            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
+                secretIds,
             });
             break;
     }
@@ -191,5 +191,5 @@ const createActionHelper = async ({
 }
 
 export { 
-    createActionHelper
+    createActionHelper,
 };

backend/src/ee/helpers/checkMembershipPermissions.ts

@@ -1,7 +1,7 @@
-import { Types } from 'mongoose';
+import { Types } from "mongoose";
 import _ from "lodash";
 import { Membership } from "../../models";
-import { PERMISSION_READ_SECRETS, PERMISSION_WRITE_SECRETS } from '../../variables';
+import { PERMISSION_READ_SECRETS, PERMISSION_WRITE_SECRETS } from "../../variables";
 
 export const userHasWorkspaceAccess = async (userId: Types.ObjectId, workspaceId: Types.ObjectId, environment: string, action: any) => {
   const membershipForWorkspace = await Membership.findOne({ workspace: workspaceId, user: userId })

backend/src/ee/helpers/log.ts

@@ -1,8 +1,8 @@
-import { Types } from 'mongoose';
+import { Types } from "mongoose";
 import { 
+    IAction,
     Log,
-    IAction
+} from "../models";
-} from '../models';
 
 /**
  * Create an (audit) log
@@ -21,7 +21,7 @@ const createLogHelper = async ({
     workspaceId,
     actions,
     channel,
-    ipAddress
+    ipAddress,
 }: {
     userId?: Types.ObjectId;
     serviceAccountId?: Types.ObjectId;
@@ -39,12 +39,12 @@ const createLogHelper = async ({
         actionNames: actions.map((a) => a.name),
         actions,
         channel,
-        ipAddress
+        ipAddress,
     }).save();
 
     return log;
 }
 
 export {
-    createLogHelper
+    createLogHelper,
 }

backend/src/ee/helpers/organizations.ts

@@ -0,0 +1,64 @@
+import { Types } from "mongoose";
+import {
+    SSOConfig
+} from "../models";
+import {
+    BotOrgService
+} from "../../services";
+import { client } from "../../config";
+import { ValidationError } from "../../utils/errors";
+
+export const getSSOConfigHelper = async ({
+    organizationId,
+    ssoConfigId
+}: {
+    organizationId?: Types.ObjectId;
+    ssoConfigId?: Types.ObjectId;
+}) => {
+    
+    if (!organizationId && !ssoConfigId) throw ValidationError({
+        message: "Getting SSO data requires either id of organization or SSO data"
+    });
+    
+    const ssoConfig = await SSOConfig.findOne({
+        ...(organizationId ? { organization: organizationId } : {}),
+        ...(ssoConfigId ? { _id: ssoConfigId } : {})
+    });
+    
+    if (!ssoConfig) throw new Error("Failed to find organization SSO data");
+    
+    const key = await BotOrgService.getSymmetricKey(
+        ssoConfig.organization
+    );
+    
+    const entryPoint = client.decryptSymmetric(
+        ssoConfig.encryptedEntryPoint,
+        key,
+        ssoConfig.entryPointIV,
+        ssoConfig.entryPointTag
+    );
+
+    const issuer = client.decryptSymmetric(
+        ssoConfig.encryptedIssuer,
+        key,
+        ssoConfig.issuerIV,
+        ssoConfig.issuerTag
+    );
+
+    const cert = client.decryptSymmetric(
+        ssoConfig.encryptedCert,
+        key,
+        ssoConfig.certIV,
+        ssoConfig.certTag
+    );
+    
+    return ({
+        _id: ssoConfig._id,
+        organization: ssoConfig.organization,
+        authProvider: ssoConfig.authProvider,
+        isActive: ssoConfig.isActive,
+        entryPoint,
+        issuer,
+        cert
+    });
+}

backend/src/ee/helpers/secret.ts

@@ -1,6 +1,11 @@
 import { Types } from "mongoose";
-import { Secret, ISecret } from "../../models";
+import { Secret } from "../../models";
-import { SecretSnapshot, SecretVersion, ISecretVersion } from "../models";
+import {
+  FolderVersion,
+  ISecretVersion,
+  SecretSnapshot,
+  SecretVersion,
+} from "../models";
 
 /**
  * Save a secret snapshot that is a copy of the current state of secrets in workspace with id
@@ -12,22 +17,31 @@ import { SecretSnapshot, SecretVersion, ISecretVersion } from "../models";
  */
 const takeSecretSnapshotHelper = async ({
   workspaceId,
+  environment,
+  folderId = "root",
 }: {
   workspaceId: Types.ObjectId;
+  environment: string;
+  folderId?: string;
 }) => {
+  // get all folder ids
   const secretIds = (
     await Secret.find(
       {
         workspace: workspaceId,
+        environment,
+        folder: folderId,
       },
       "_id"
-    )
+    ).lean()
   ).map((s) => s._id);
 
   const latestSecretVersions = (
     await SecretVersion.aggregate([
       {
         $match: {
+          environment,
+          workspace: new Types.ObjectId(workspaceId),
           secret: {
             $in: secretIds,
           },
@@ -45,6 +59,11 @@ const takeSecretSnapshotHelper = async ({
       },
     ]).exec()
   ).map((s) => s.versionId);
+  const latestFolderVersion = await FolderVersion.findOne({
+    environment,
+    workspace: workspaceId,
+    "nodes.id": folderId,
+  }).sort({ "nodes.version": -1 });
 
   const latestSecretSnapshot = await SecretSnapshot.findOne({
     workspace: workspaceId,
@@ -52,8 +71,11 @@ const takeSecretSnapshotHelper = async ({
 
   const secretSnapshot = await new SecretSnapshot({
     workspace: workspaceId,
+    environment,
     version: latestSecretSnapshot ? latestSecretSnapshot.version + 1 : 1,
     secretVersions: latestSecretVersions,
+    folderId,
+    folderVersion: latestFolderVersion,
   }).save();
 
   return secretSnapshot;
@@ -96,5 +118,5 @@ const markDeletedSecretVersionsHelper = async ({
 export {
   takeSecretSnapshotHelper,
   addSecretVersionsHelper,
-  markDeletedSecretVersionsHelper
+  markDeletedSecretVersionsHelper,
 };

backend/src/ee/helpers/secretVersion.ts

@@ -1,92 +1,82 @@
-import { Types } from 'mongoose';
+import { Types } from "mongoose";
-import { SecretVersion } from '../models';
+import { SecretVersion } from "../models";
 
 /**
  * Return latest secret versions for secrets with ids [secretIds]
  * @param {Object} obj
  * @param {Object} obj.secretIds = ids of secrets to get latest versions for
- * @returns 
+ * @returns
  */
 const getLatestSecretVersionIds = async ({
-    secretIds
+  secretIds,
 }: {
-    secretIds: Types.ObjectId[];
+  secretIds: Types.ObjectId[];
 }) => {
-    interface LatestSecretVersionId {
+  const latestSecretVersionIds = await SecretVersion.aggregate([
-        _id: Types.ObjectId;
+    {
-        version: number;
+      $match: {
-        versionId: Types.ObjectId;
+        secret: {
-    }
+          $in: secretIds,
-    
-    const latestSecretVersionIds = (await SecretVersion.aggregate([
-        {
-            $match: { 
-                secret: { 
-                    $in: secretIds 
-                } 
-            }
         },
-        {
+      },
-            $group: {
+    },
-                _id: '$secret',
+    {
-                version: { $max: '$version' },
+      $group: {
-                versionId: { $max: '$_id' } // id of latest secret version
+        _id: "$secret",
-            }
+        version: { $max: "$version" },
-        },
+        versionId: { $max: "$_id" }, // id of latest secret version
-        {
+      },
-            $sort: { version: -1 }
+    },
-        }
+    {
-        ])
+      $sort: { version: -1 },
-        .exec());
+    },
-    
+  ]).exec();
-    return latestSecretVersionIds;
+
-}
+  return latestSecretVersionIds;
+};
 
 /**
  * Return latest [n] secret versions for secrets with ids [secretIds]
  * @param {Object} obj
  * @param {Object} obj.secretIds = ids of secrets to get latest versions for
  * @param {Number} obj.n - number of latest secret versions to return for each secret
- * @returns 
+ * @returns
  */
 const getLatestNSecretSecretVersionIds = async ({
-    secretIds,
+  secretIds,
-    n
+  n,
 }: {
-    secretIds: Types.ObjectId[];
+  secretIds: Types.ObjectId[];
-    n: number;
+  n: number;
 }) => {
-    // TODO: optimize query
+  // TODO: optimize query
-    const latestNSecretVersions = (await SecretVersion.aggregate([
+  const latestNSecretVersions = await SecretVersion.aggregate([
-        {
+    {
-            $match: {
+      $match: {
-            secret: {
+        secret: {
-                $in: secretIds,
+          $in: secretIds,
-            },
-            },
         },
-        {
+      },
-            $sort: { version: -1 },
+    },
-        },
+    {
-        {
+      $sort: { version: -1 },
-            $group: {
+    },
-            _id: "$secret",
+    {
-            versions: { $push: "$$ROOT" },
+      $group: {
-            },
+        _id: "$secret",
-        },
+        versions: { $push: "$$ROOT" },
-        {
+      },
-            $project: {
+    },
-            _id: 0,
+    {
-            secret: "$_id",
+      $project: {
-            versions: { $slice: ["$versions", n] },
+        _id: 0,
-            },
+        secret: "$_id",
-        }
+        versions: { $slice: ["$versions", n] },
-    ]));
+      },
-    
+    },
-    return latestNSecretVersions;
+  ]);
-}
 
-export {
+  return latestNSecretVersions;
-    getLatestSecretVersionIds,
+};
-    getLatestNSecretSecretVersionIds
+
-}
+export { getLatestSecretVersionIds, getLatestNSecretSecretVersionIds };

backend/src/ee/middleware/index.ts

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

backend/src/ee/middleware/requireLicenseAuth.ts

@@ -1,23 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-
-/**
- * Validate if organization hosting meets license requirements to 
- * access a license-specific route.
- * @param {Object} obj
- * @param {String[]} obj.acceptedTiers
- */
-const requireLicenseAuth = ({
-    acceptedTiers
-}: {
-    acceptedTiers: string[];
-}) => {
-    return async (req: Request, res: Response, next: NextFunction) => {
-        try {
-
-        } catch (err) {
-
-        }
-    }
-}
-
-export default requireLicenseAuth;

backend/src/ee/middleware/requireSecretSnapshotAuth.ts

@@ -1,9 +1,9 @@
-import { Request, Response, NextFunction } from 'express';
+import { NextFunction, Request, Response } from "express";
-import { UnauthorizedRequestError, SecretSnapshotNotFoundError } from '../../utils/errors';
+import { SecretSnapshotNotFoundError } from "../../utils/errors";
-import { SecretSnapshot } from '../models';
+import { SecretSnapshot } from "../models";
 import {
-    validateMembership
+    validateMembership,
-} from '../../helpers/membership';
+} from "../../helpers/membership";
 
 /**
  * Validate if user on request has proper membership for secret snapshot
@@ -15,7 +15,7 @@ import {
 const requireSecretSnapshotAuth = ({
     acceptedRoles,
 }: {
-    acceptedRoles: Array<'admin' | 'member'>;
+    acceptedRoles: Array<"admin" | "member">;
 }) => {
     return async (req: Request, res: Response, next: NextFunction) => {
         const { secretSnapshotId } = req.params;
@@ -24,14 +24,14 @@ const requireSecretSnapshotAuth = ({
         
         if (!secretSnapshot) {
             return next(SecretSnapshotNotFoundError({
-                message: 'Failed to find secret snapshot'
+                message: "Failed to find secret snapshot",
             }));
         }
         
         await validateMembership({
             userId: req.user._id,
             workspaceId: secretSnapshot.workspace,
-            acceptedRoles
+            acceptedRoles,
         });
         
         req.secretSnapshot = secretSnapshot as any;

backend/src/ee/models/action.ts

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

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

@@ -0,0 +1,76 @@
+import { Schema, Types, model } from "mongoose";
+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;
+}
+
+const auditLogSchema = new Schema<IAuditLog>(
+    {
+        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
+        }
+    },
+    {
+        timestamps: true
+    }
+);
+
+export const AuditLog = model<IAuditLog>("AuditLog", auditLogSchema); 

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

@@ -0,0 +1,47 @@
+export enum ActorType {
+    USER = "user",
+    SERVICE = "service"
+}
+
+export enum UserAgentType {
+    WEB = "web",
+    CLI = "cli",
+    K8_OPERATOR = "k8-operator",
+    OTHER = "other"
+}
+
+export enum EventType {
+    GET_SECRETS = "get-secrets",
+    GET_SECRET = "get-secret",
+    REVEAL_SECRET = "reveal-secret",
+    CREATE_SECRET = "create-secret",
+    UPDATE_SECRET = "update-secret",
+    DELETE_SECRET = "delete-secret",
+    GET_WORKSPACE_KEY = "get-workspace-key",
+    AUTHORIZE_INTEGRATION = "authorize-integration",
+    UNAUTHORIZE_INTEGRATION = "unauthorize-integration",
+    CREATE_INTEGRATION = "create-integration",
+    DELETE_INTEGRATION = "delete-integration",
+    ADD_TRUSTED_IP = "add-trusted-ip",
+    UPDATE_TRUSTED_IP = "update-trusted-ip",
+    DELETE_TRUSTED_IP = "delete-trusted-ip",
+    CREATE_SERVICE_TOKEN = "create-service-token",
+    DELETE_SERVICE_TOKEN = "delete-service-token",
+    CREATE_ENVIRONMENT = "create-environment",
+    UPDATE_ENVIRONMENT = "update-environment",
+    DELETE_ENVIRONMENT = "delete-environment",
+    ADD_WORKSPACE_MEMBER = "add-workspace-member",
+    REMOVE_WORKSPACE_MEMBER = "remove-workspace-member",
+    CREATE_FOLDER = "create-folder",
+    UPDATE_FOLDER = "update-folder",
+    DELETE_FOLDER = "delete-folder",
+    CREATE_WEBHOOK = "create-webhook",
+    UPDATE_WEBHOOK_STATUS = "update-webhook-status",
+    DELETE_WEBHOOK = "delete-webhook",
+    GET_SECRET_IMPORTS = "get-secret-imports",
+    CREATE_SECRET_IMPORT = "create-secret-import",
+    UPDATE_SECRET_IMPORT = "update-secret-import",
+    DELETE_SECRET_IMPORT = "delete-secret-import",
+    UPDATE_USER_WORKSPACE_ROLE = "update-user-workspace-role",
+    UPDATE_USER_WORKSPACE_DENIED_PERMISSIONS = "update-user-workspace-denied-permissions"
+}

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

@@ -0,0 +1,3 @@
+export * from "./auditLog";
+export * from "./enums";
+export * from "./types";

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

@@ -0,0 +1,403 @@
+import {
+    ActorType,
+    EventType
+} from "./enums";
+
+interface UserActorMetadata {
+    userId: string;
+    email: string;
+}
+
+interface ServiceActorMetadata {
+    serviceId: string;
+    name: string;
+}
+
+export interface UserActor {
+    type: ActorType.USER;
+    metadata: UserActorMetadata;
+}
+
+export interface ServiceActor {
+    type: ActorType.SERVICE;
+    metadata: ServiceActorMetadata;
+}
+
+export type Actor = 
+    | UserActor
+    | ServiceActor;
+
+interface GetSecretsEvent {
+    type: EventType.GET_SECRETS;
+    metadata: {
+        environment: string;
+        secretPath: string;
+        numberOfSecrets: number;
+    };
+}
+
+interface GetSecretEvent {
+    type: EventType.GET_SECRET;
+    metadata: {
+        environment: string;
+        secretPath: string;
+        secretId: string;
+        secretKey: string;
+        secretVersion: number;
+    };
+}
+
+interface CreateSecretEvent {
+    type: EventType.CREATE_SECRET;
+    metadata: {
+        environment: string;
+        secretPath: string;
+        secretId: string;
+        secretKey: string;
+        secretVersion: number;
+    }
+}
+
+interface UpdateSecretEvent {
+    type: EventType.UPDATE_SECRET;
+    metadata: {
+        environment: string;
+        secretPath: string;
+        secretId: string;
+        secretKey: string;
+        secretVersion: number;
+    }
+}
+
+interface DeleteSecretEvent {
+    type: EventType.DELETE_SECRET;
+    metadata: {
+        environment: string;
+        secretPath: string;
+        secretId: string;
+        secretKey: string;
+        secretVersion: number;
+    }
+}
+
+interface GetWorkspaceKeyEvent {
+    type: EventType.GET_WORKSPACE_KEY,
+    metadata: {
+        keyId: string;
+    }
+}
+
+interface AuthorizeIntegrationEvent {
+    type: EventType.AUTHORIZE_INTEGRATION;
+    metadata: {
+        integration: string;
+    }
+}
+
+interface UnauthorizeIntegrationEvent {
+    type: EventType.UNAUTHORIZE_INTEGRATION;
+    metadata: {
+        integration: string;
+    }
+}
+
+interface CreateIntegrationEvent {
+    type: EventType.CREATE_INTEGRATION;
+    metadata: {
+        integrationId: string;
+        integration: string; // TODO: fix type
+        environment: string;
+        secretPath: string;
+        url?: string;
+        app?: string;
+        appId?: string;
+        targetEnvironment?: string;
+        targetEnvironmentId?: string;
+        targetService?: string;
+        targetServiceId?: string;
+        path?: string;
+        region?: string;
+    }
+}
+
+interface DeleteIntegrationEvent {
+    type: EventType.DELETE_INTEGRATION;
+    metadata: {
+        integrationId: string;
+        integration: string; // TODO: fix type
+        environment: string;
+        secretPath: string;
+        url?: string;
+        app?: string;
+        appId?: string;
+        targetEnvironment?: string;
+        targetEnvironmentId?: string;
+        targetService?: string;
+        targetServiceId?: string;
+        path?: string;
+        region?: string;
+    }
+}
+
+interface AddTrustedIPEvent {
+    type: EventType.ADD_TRUSTED_IP;
+    metadata: {
+        trustedIpId: string;
+        ipAddress: string;
+        prefix?: number;
+    }
+}
+
+interface UpdateTrustedIPEvent {
+    type: EventType.UPDATE_TRUSTED_IP;
+    metadata: {
+        trustedIpId: string;
+        ipAddress: string;
+        prefix?: number;
+    }
+}
+
+interface DeleteTrustedIPEvent {
+    type: EventType.DELETE_TRUSTED_IP;
+    metadata: {
+        trustedIpId: string;
+        ipAddress: string;
+        prefix?: number;
+    }
+}
+
+interface CreateServiceTokenEvent {
+    type: EventType.CREATE_SERVICE_TOKEN;
+    metadata: {
+        name: string;
+        scopes: Array<{
+            environment: string;
+            secretPath: string;
+        }>;
+    }
+}
+
+interface DeleteServiceTokenEvent {
+    type: EventType.DELETE_SERVICE_TOKEN;
+    metadata: {
+        name: string;
+        scopes: Array<{
+            environment: string;
+            secretPath: string;
+        }>;
+    }
+}
+
+interface CreateEnvironmentEvent {
+    type: EventType.CREATE_ENVIRONMENT;
+    metadata: {
+        name: string;
+        slug: string;
+    }
+}
+
+interface UpdateEnvironmentEvent {
+    type: EventType.UPDATE_ENVIRONMENT;
+    metadata: {
+        oldName: string;
+        newName: string;
+        oldSlug: string;
+        newSlug: string;
+    }
+}
+
+interface DeleteEnvironmentEvent {
+    type: EventType.DELETE_ENVIRONMENT;
+    metadata: {
+        name: string;
+        slug: string;
+    }
+}
+
+interface AddWorkspaceMemberEvent {
+    type: EventType.ADD_WORKSPACE_MEMBER;
+    metadata: {
+        userId: string;
+        email: string;
+    }
+}
+
+interface RemoveWorkspaceMemberEvent {
+    type: EventType.REMOVE_WORKSPACE_MEMBER;
+    metadata: {
+        userId: string;
+        email: string;
+    }
+}
+
+interface CreateFolderEvent {
+    type: EventType.CREATE_FOLDER;
+    metadata: {
+        environment: string;
+        folderId: string;
+        folderName: string;
+        folderPath: string;
+    }
+}
+
+interface UpdateFolderEvent {
+    type: EventType.UPDATE_FOLDER;
+    metadata: {
+        environment: string;
+        folderId: string;
+        oldFolderName: string;
+        newFolderName: string;
+        folderPath: string;
+    }
+}
+
+interface DeleteFolderEvent {
+    type: EventType.DELETE_FOLDER;
+    metadata: {
+        environment: string;
+        folderId: string;
+        folderName: string;
+        folderPath: string;
+    }
+}
+
+interface CreateWebhookEvent {
+    type: EventType.CREATE_WEBHOOK,
+    metadata: {
+        webhookId: string;
+        environment: string;
+        secretPath: string;
+        webhookUrl: string;
+        isDisabled: boolean;
+    }
+}
+
+interface UpdateWebhookStatusEvent {
+    type: EventType.UPDATE_WEBHOOK_STATUS,
+    metadata: {
+        webhookId: string;
+        environment: string;
+        secretPath: string;
+        webhookUrl: string;
+        isDisabled: boolean;
+    }
+}
+
+interface DeleteWebhookEvent {
+    type: EventType.DELETE_WEBHOOK,
+    metadata: {
+        webhookId: string;
+        environment: string;
+        secretPath: string;
+        webhookUrl: string;
+        isDisabled: boolean;
+    }
+}
+
+interface GetSecretImportsEvent {
+    type: EventType.GET_SECRET_IMPORTS,
+    metadata: {
+        environment: string;
+        secretImportId: string;
+        folderId: string;
+        numberOfImports: number;
+    }
+}
+
+interface CreateSecretImportEvent {
+    type: EventType.CREATE_SECRET_IMPORT,
+    metadata: {
+        secretImportId: string;
+        folderId: string;
+        importFromEnvironment: string;
+        importFromSecretPath: string;
+        importToEnvironment: string;
+        importToSecretPath: string;
+    }
+}
+
+interface UpdateSecretImportEvent {
+    type: EventType.UPDATE_SECRET_IMPORT,
+    metadata: {
+        secretImportId: string;
+        folderId: string;
+        importToEnvironment: string;
+        importToSecretPath: string;
+        orderBefore: {
+          environment: string;
+          secretPath: string;
+        }[],
+        orderAfter: {
+          environment: string;
+          secretPath: string;
+        }[]
+    }
+}
+
+interface DeleteSecretImportEvent {
+    type: EventType.DELETE_SECRET_IMPORT,
+    metadata: {
+        secretImportId: string;
+        folderId: string;
+        importFromEnvironment: string;
+        importFromSecretPath: string;
+        importToEnvironment: string;
+        importToSecretPath: string;
+    }
+}
+
+interface UpdateUserRole {
+    type: EventType.UPDATE_USER_WORKSPACE_ROLE,
+    metadata: {
+        userId: string;
+        email: string;
+        oldRole: string;
+        newRole: string;
+    }
+}
+
+interface UpdateUserDeniedPermissions {
+    type: EventType.UPDATE_USER_WORKSPACE_DENIED_PERMISSIONS,
+    metadata: {
+        userId: string;
+        email: string;
+        deniedPermissions: {
+            environmentSlug: string;
+            ability: string;
+        }[]
+    }
+}
+
+export type Event = 
+    | GetSecretsEvent
+    | GetSecretEvent
+    | CreateSecretEvent
+    | UpdateSecretEvent
+    | DeleteSecretEvent
+    | GetWorkspaceKeyEvent
+    | AuthorizeIntegrationEvent
+    | UnauthorizeIntegrationEvent
+    | CreateIntegrationEvent
+    | DeleteIntegrationEvent
+    | AddTrustedIPEvent
+    | UpdateTrustedIPEvent
+    | DeleteTrustedIPEvent
+    | CreateServiceTokenEvent
+    | DeleteServiceTokenEvent
+    | CreateEnvironmentEvent
+    | UpdateEnvironmentEvent
+    | DeleteEnvironmentEvent
+    | AddWorkspaceMemberEvent
+    | RemoveWorkspaceMemberEvent
+    | CreateFolderEvent
+    | UpdateFolderEvent
+    | DeleteFolderEvent
+    | CreateWebhookEvent
+    | UpdateWebhookStatusEvent
+    | DeleteWebhookEvent
+    | GetSecretImportsEvent
+    | CreateSecretImportEvent
+    | UpdateSecretImportEvent
+    | DeleteSecretImportEvent
+    | UpdateUserRole
+    | UpdateUserDeniedPermissions;

backend/src/ee/models/folderVersion.ts

@@ -0,0 +1,58 @@
+import { Schema, Types, model } from "mongoose";
+
+export type TFolderRootVersionSchema = {
+  _id: Types.ObjectId;
+  workspace: Types.ObjectId;
+  environment: string;
+  nodes: TFolderVersionSchema;
+};
+
+export type TFolderVersionSchema = {
+  id: string;
+  name: string;
+  version: number;
+  children: TFolderVersionSchema[];
+};
+
+const folderVersionSchema = new Schema<TFolderVersionSchema>({
+  id: {
+    required: true,
+    type: String,
+    default: "root",
+  },
+  name: {
+    required: true,
+    type: String,
+    default: "root",
+  },
+  version: {
+    required: true,
+    type: Number,
+    default: 1,
+  },
+});
+
+folderVersionSchema.add({ children: [folderVersionSchema] });
+
+const folderRootVersionSchema = new Schema<TFolderRootVersionSchema>(
+  {
+    workspace: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      required: true,
+    },
+    environment: {
+      type: String,
+      required: true,
+    },
+    nodes: folderVersionSchema,
+  },
+  {
+    timestamps: true,
+  }
+);
+
+export const FolderVersion = model<TFolderRootVersionSchema>(
+  "FolderVersion",
+  folderRootVersionSchema
+);

backend/src/ee/models/gitAppInstallationSession.ts

@@ -0,0 +1,34 @@
+import { Schema, Types, model } from "mongoose";
+
+type GitAppInstallationSession = {
+  id: string;
+  sessionId: string;
+  organization: Types.ObjectId;
+  user: Types.ObjectId;
+}
+
+const gitAppInstallationSession = new Schema<GitAppInstallationSession>({
+  id: {
+    required: true,
+    type: String,
+  },
+  sessionId: {
+    type: String,
+    required: true,
+    unique: true
+  },
+  organization: {
+    type: Schema.Types.ObjectId,
+    required: true,
+    unique: true
+  },
+  user: {
+    type: Schema.Types.ObjectId,
+    ref: "User"
+  }
+});
+
+
+const GitAppInstallationSession = model<GitAppInstallationSession>("git_app_installation_session", gitAppInstallationSession);
+
+export default GitAppInstallationSession;

backend/src/ee/models/gitAppOrganizationInstallation.ts

@@ -0,0 +1,31 @@
+import { Schema, model } from "mongoose";
+
+type Installation = {
+  installationId: string
+  organizationId: string
+  user: Schema.Types.ObjectId
+};
+
+
+const gitAppOrganizationInstallation = new Schema<Installation>({
+  installationId: {
+    type: String,
+    required: true,
+    unique: true
+  },
+  organizationId: {
+    type: String,
+    required: true,
+    unique: true
+  },
+  user: {
+    type: Schema.Types.ObjectId,
+    ref: "User",
+    required: true,
+  }
+});
+
+
+const GitAppOrganizationInstallation = model<Installation>("git_app_organization_installation", gitAppOrganizationInstallation);
+
+export default GitAppOrganizationInstallation;