Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

feat: add approval request on global system

adilsond62797beb043
diff --git a/backend/e2e-test/routes/v1/access-approval-global-policy-routing.spec.ts b/backend/e2e-test/routes/v1/access-approval-global-policy-routing.spec.ts
index 9ef008e705..97c4782bf9 100644
--- a/backend/e2e-test/routes/v1/access-approval-global-policy-routing.spec.ts
+++ b/backend/e2e-test/routes/v1/access-approval-global-policy-routing.spec.ts
@@ -194,12 +194,16 @@ describe("Access approval policy routing", () => {
await expectNoLegacyRow(policy.id);
});
- test("Updating a global policy onto a path another policy covers is rejected on either system", async () => {
+ test("Updating a policy onto a path another policy covers is rejected on either system", async () => {
+ const db = getDb();
const policy = await createGlobalPolicy({
name: "policy-routing-conflict",
secretPath: "/policy-routing-conflict"
});
- await createLegacyPolicy({ name: "policy-routing-conflict-legacy", secretPath: "/policy-routing-conflict-legacy" });
+ const legacyPolicy = await createLegacyPolicy({
+ name: "policy-routing-conflict-legacy",
+ secretPath: "/policy-routing-conflict-legacy"
+ });
await createGlobalPolicy({
name: "policy-routing-conflict-global",
secretPath: "/policy-routing-conflict-global"
@@ -213,6 +217,13 @@ describe("Access approval policy routing", () => {
expect(globalConflict.statusCode).toBe(400);
expect(globalConflict.json().message).toContain(`already exists in environment '${seedData1.environment.slug}'`);
+ const legacyOntoGlobal = await patchPolicy(legacyPolicy.id, { secretPath: "/policy-routing-conflict-global" });
+ expect(legacyOntoGlobal.statusCode).toBe(400);
+ expect(legacyOntoGlobal.json().message).toContain(`already exists in environment '${seedData1.environment.slug}'`);
+
+ const unchangedLegacy = await db(TableName.AccessApprovalPolicy).where({ id: legacyPolicy.id }).first();
+ expect(unchangedLegacy?.secretPath).toBe("/policy-routing-conflict-legacy");
+
const samePath = await patchPolicy(policy.id, { secretPath: "/policy-routing-conflict" });
expect(samePath.statusCode).toBe(200);
});
diff --git a/backend/e2e-test/routes/v1/access-approval-global-request-lifecycle.spec.ts b/backend/e2e-test/routes/v1/access-approval-global-request-lifecycle.spec.ts
new file mode 100644
index 0000000000..20d7b023d5
--- /dev/null
+++ b/backend/e2e-test/routes/v1/access-approval-global-request-lifecycle.spec.ts
@@ -0,0 +1,278 @@
+import { Knex } from "knex";
+
+import { TableName } from "@app/db/schemas";
+import { seedData1 } from "@app/db/seed-data";
+import { ApproverType } from "@app/ee/services/access-approval-policy/access-approval-policy-types";
+
+const getDb = () => (globalThis as unknown as { testDb: Knex }).testDb;
+
+const SECRET_ACCESS_TYPE = "secret-access";
+
+const globalPolicyIds: string[] = [];
+
+const authHeaders = () => ({ authorization: `Bearer ${jwtAuthToken}` });
+
+const createGlobalPolicy = async (dto: { name: string; secretPath: string }) => {
+ const res = await testServer.inject({
+ method: "POST",
+ url: "/api/v1/access-approvals/policies",
+ headers: authHeaders(),
+ body: {
+ projectSlug: seedData1.project.slug,
+ environment: seedData1.environment.slug,
+ name: dto.name,
+ secretPath: dto.secretPath,
+ approvers: [{ type: ApproverType.User, id: seedData1.id }],
+ approvals: 1,
+ allowedSelfApprovals: true
+ }
+ });
+ expect(res.statusCode).toBe(200);
+ const { approval } = res.json();
+ globalPolicyIds.push(approval.id);
+ return approval as { id: string };
+};
+
+const createAccessRequest = (secretPath: string, body: Record<string, unknown> = {}) =>
+ testServer.inject({
+ method: "POST",
+ url: `/api/v1/access-approvals/requests?projectSlug=${seedData1.project.slug}`,
+ headers: authHeaders(),
+ body: {
+ permissions: [
+ ["read", "secrets", { environment: seedData1.environment.slug, secretPath: { $glob: secretPath } }]
+ ],
+ isTemporary: false,
+ ...body
+ }
+ });
+
+const reviewAccessRequest = (requestId: string, body: Record<string, unknown>) =>
+ testServer.inject({
+ method: "POST",
+ url: `/api/v1/access-approvals/requests/${requestId}/review`,
+ headers: authHeaders(),
+ body
+ });
+
+const revokeAccessRequest = (requestId: string) =>
+ testServer.inject({
+ method: "POST",
+ url: `/api/v1/access-approvals/requests/${requestId}/revoke`,
+ headers: authHeaders()
+ });
+
+const listAccessRequests = () =>
+ testServer.inject({
+ method: "GET",
+ url: `/api/v1/access-approvals/requests?projectSlug=${seedData1.project.slug}`,
+ headers: authHeaders()
+ });
+
+const countAccessRequests = () =>
+ testServer.inject({
+ method: "GET",
+ url: `/api/v1/access-approvals/requests/count?projectSlug=${seedData1.project.slug}`,
+ headers: authHeaders()
+ });
+
+const createApprovedTemporaryRequest = async (secretPath: string) => {
+ const policy = await createGlobalPolicy({ name: `lifecycle-${secretPath.slice(1)}`, secretPath });
+
+ const createRes = await createAccessRequest(secretPath, { isTemporary: true, temporaryRange: "1h" });
+ expect(createRes.statusCode).toBe(200);
+ const requestId = createRes.json().approval.id as string;
+
+ const reviewRes = await reviewAccessRequest(requestId, { status: "approved" });
+ expect(reviewRes.statusCode).toBe(200);
+
+ return { policy, requestId };
+};
+
+describe("Access approval request lifecycle on the global system", () => {
+ afterEach(async () => {
+ const db = getDb();
+ const globalIds = globalPolicyIds.splice(0);
+
+ await db(TableName.AdditionalPrivilege)
+ .where({ actorUserId: seedData1.id })
+ .whereLike("name", "requested-privilege-%")
+ .del();
+ await db(TableName.ApprovalRequestGrants)
+ .where({ projectId: seedData1.project.id, type: SECRET_ACCESS_TYPE })
+ .del();
+ if (globalIds.length) {
+ await db(TableName.ApprovalRequests).whereIn("policyId", globalIds).del();
+ await db(TableName.ApprovalPolicies).whereIn("id", globalIds).del();
+ }
+ });
+
+ test("Approving a request creates a grant and a privilege that references it", async () => {
+ const db = getDb();
+ const { policy, requestId } = await createApprovedTemporaryRequest("/lifecycle-approve");
+
+ const approvals = await db(TableName.ApprovalRequestApprovals)
+ .join(
+ TableName.ApprovalRequestSteps,
+ `${TableName.ApprovalRequestApprovals}.stepId`,
+ `${TableName.ApprovalRequestSteps}.id`
+ )
+ .where(`${TableName.ApprovalRequestSteps}.requestId`, requestId)
+ .select(`${TableName.ApprovalRequestApprovals}.decision`);
+ expect(approvals).toHaveLength(1);
+ expect(approvals[0].decision).toBe("approved");
+
+ const request = await db(TableName.ApprovalRequests).where({ id: requestId }).first();
+ expect(request?.status).toBe("approved");
+ expect(request?.policyId).toBe(policy.id);
+
+ const grant = await db(TableName.ApprovalRequestGrants).where({ requestId }).first();
+ expect(grant?.status).toBe("active");
+ expect(grant?.type).toBe(SECRET_ACCESS_TYPE);
+ expect(grant?.granteeUserId).toBe(seedData1.id);
+ expect(grant?.expiresAt).toBeTruthy();
+
+ const privilege = await db(TableName.AdditionalPrivilege).where({ grantId: grant?.id }).first();
+ expect(privilege).toBeDefined();
+ expect(privilege?.actorUserId).toBe(seedData1.id);
+ expect(privilege?.projectId).toBe(seedData1.project.id);
+ expect(privilege?.isTemporary).toBe(true);
+ expect(privilege?.temporaryRange).toBe("1h");
+
+ const legacyRows = await db(TableName.AccessApprovalRequest).where({ id: requestId });
+ expect(legacyRows).toHaveLength(0);
+ });
+
+ test("Revoking an approved request revokes the grant and deletes the privilege", async () => {
+ const db = getDb();
+ const { requestId } = await createApprovedTemporaryRequest("/lifecycle-revoke");
+
+ const grantBefore = await db(TableName.ApprovalRequestGrants).where({ requestId }).first();
+ expect(grantBefore?.status).toBe("active");
+ const privilegeBefore = await db(TableName.AdditionalPrivilege).where({ grantId: grantBefore?.id }).first();
+ expect(privilegeBefore).toBeDefined();
+
+ const revokeRes = await revokeAccessRequest(requestId);
+ expect(revokeRes.statusCode).toBe(200);
+ const { request } = revokeRes.json();
+ expect(request.id).toBe(requestId);
+ expect(request.status).toBe("revoked");
+ expect(request.revokedByUserId).toBe(seedData1.id);
+ expect(request.revokedAt).toBeTruthy();
+ expect(request.privilegeId).toBeNull();
+
+ const grantAfter = await db(TableName.ApprovalRequestGrants).where({ id: grantBefore?.id }).first();
+ expect(grantAfter?.status).toBe("revoked");
+ expect(grantAfter?.revokedAt).toBeTruthy();
+ expect(grantAfter?.revokedByUserId).toBe(seedData1.id);
+
+ const privilegeAfter = await db(TableName.AdditionalPrivilege).where({ id: privilegeBefore?.id }).first();
+ expect(privilegeAfter).toBeUndefined();
+
+ const secondRevoke = await revokeAccessRequest(requestId);
+ expect(secondRevoke.statusCode).toBe(400);
+ expect(secondRevoke.json().message).toBe("Only approved requests can be revoked");
+ });
+
+ test("Rejecting a request creates no grant and no privilege", async () => {
+ const db = getDb();
+ const secretPath = "/lifecycle-reject";
+ await createGlobalPolicy({ name: "lifecycle-reject", secretPath });
+
+ const createRes = await createAccessRequest(secretPath);
+ expect(createRes.statusCode).toBe(200);
+ const requestId = createRes.json().approval.id as string;
+
+ const reviewRes = await reviewAccessRequest(requestId, { status: "rejected" });
+ expect(reviewRes.statusCode).toBe(200);
+ expect(reviewRes.json().review.status).toBe("rejected");
+
+ const request = await db(TableName.ApprovalRequests).where({ id: requestId }).first();
+ expect(request?.status).toBe("rejected");
+
+ const grants = await db(TableName.ApprovalRequestGrants).where({ requestId });
+ expect(grants).toHaveLength(0);
+
+ const privileges = await db(TableName.AdditionalPrivilege)
+ .where({ actorUserId: seedData1.id })
+ .whereLike("name", "requested-privilege-%");
+ expect(privileges).toHaveLength(0);
+ });
+
+ test("Global requests are served by the list and count endpoints", async () => {
+ const { policy, requestId: approvedId } = await createApprovedTemporaryRequest("/lifecycle-list");
+
+ const pendingPath = "/lifecycle-list-pending";
+ await createGlobalPolicy({ name: "lifecycle-list-pending", secretPath: pendingPath });
+ const pendingRes = await createAccessRequest(pendingPath);
+ expect(pendingRes.statusCode).toBe(200);
+ const pendingId = pendingRes.json().approval.id as string;
+
+ const listRes = await listAccessRequests();
+ expect(listRes.statusCode).toBe(200);
+ const { requests } = listRes.json();
+
+ const approved = requests.find((request: { id: string }) => request.id === approvedId);
+ expect(approved).toBeDefined();
+ expect(approved.policyId).toBe(policy.id);
+ expect(approved.policy.id).toBe(policy.id);
+ expect(approved.policy.secretPath).toBe("/lifecycle-list");
+ expect(approved.environmentName).toBe(seedData1.environment.slug);
+ expect(approved.isApproved).toBe(true);
+ expect(approved.isTemporary).toBe(true);
+ expect(approved.privilege).not.toBeNull();
+ expect(approved.privilege.isTemporary).toBe(true);
+ expect(approved.reviewers).toEqual([expect.objectContaining({ userId: seedData1.id, status: "approved" })]);
+ expect(approved.policy.approvers).toEqual([expect.objectContaining({ userId: seedData1.id, sequence: 1 })]);
+ expect(approved.requestedByUser.userId).toBe(seedData1.id);
+ expect(approved.approvedByUser.userId).toBe(seedData1.id);
+
+ const pending = requests.find((request: { id: string }) => request.id === pendingId);
+ expect(pending).toBeDefined();
+ expect(pending.status).toBe("pending");
+ expect(pending.isApproved).toBe(false);
+ expect(pending.privilege).toBeNull();
+ expect(pending.reviewers).toEqual([]);
+
+ const countRes = await countAccessRequests();
+ expect(countRes.statusCode).toBe(200);
+ expect(countRes.json().pendingCount).toBeGreaterThanOrEqual(1);
+ expect(countRes.json().finalizedCount).toBeGreaterThanOrEqual(1);
+
+ const revokeRes = await revokeAccessRequest(approvedId);
+ expect(revokeRes.statusCode).toBe(200);
+
+ const afterRevoke = (await listAccessRequests())
+ .json()
+ .requests.find((request: { id: string }) => request.id === approvedId);
+ expect(afterRevoke.status).toBe("revoked");
+ expect(afterRevoke.privilege).toBeNull();
+ expect(afterRevoke.revokedByUser.userId).toBe(seedData1.id);
+ });
+
+ test("A duplicate pending request, an edit, and a bypass are rejected", async () => {
+ const secretPath = "/lifecycle-guards";
+ await createGlobalPolicy({ name: "lifecycle-guards", secretPath });
+
+ const createRes = await createAccessRequest(secretPath);
+ expect(createRes.statusCode).toBe(200);
+ const requestId = createRes.json().approval.id as string;
+
+ const duplicateRes = await createAccessRequest(secretPath);
+ expect(duplicateRes.statusCode).toBe(400);
+ expect(duplicateRes.json().message).toBe("You already have a pending access request with the same criteria");
+
+ const patchRes = await testServer.inject({
+ method: "PATCH",
+ url: `/api/v1/access-approvals/requests/${requestId}`,
+ headers: authHeaders(),
+ body: { temporaryRange: "30m", editNote: "shorter" }
+ });
+ expect(patchRes.statusCode).toBe(400);
+ expect(patchRes.json().message).toBe("Access requests on the global approval system cannot be edited");
+
+ const bypassRes = await reviewAccessRequest(requestId, { status: "approved", bypassReason: "need it right now" });
+ expect(bypassRes.statusCode).toBe(400);
+ expect(bypassRes.json().message).toBe("Break-glass approvals are not supported for this request yet");
+ });
+});
diff --git a/backend/e2e-test/routes/v1/access-approval-global-request-routing.spec.ts b/backend/e2e-test/routes/v1/access-approval-global-request-routing.spec.ts
index ae2d759f3a..2c279ddc78 100644
--- a/backend/e2e-test/routes/v1/access-approval-global-request-routing.spec.ts
+++ b/backend/e2e-test/routes/v1/access-approval-global-request-routing.spec.ts
@@ -1,3 +1,5 @@
+import { createFakeWebhookServer } from "e2e-test/fakes/webhook-destination";
+import { createWebhook } from "e2e-test/testUtils/webhooks";
import { Knex } from "knex";
import { TableName } from "@app/db/schemas";
@@ -7,8 +9,7 @@ import { EnforcementLevel } from "@app/lib/types";
const getDb = () => (globalThis as unknown as { testDb: Knex }).testDb;
-const GLOBAL_REQUEST_UNSUPPORTED_MESSAGE =
- "Secret access approval requests are not supported on the global approval system yet";
+const SECRET_ACCESS_TYPE = "secret-access";
// Both systems share the seeded project and environment, so every policy this
// file creates is removed after each test to keep later specs unaffected.
@@ -85,12 +86,37 @@ const createAccessRequest = (secretPath: string) =>
}
});
+const reviewAccessRequest = (requestId: string, status: "approved" | "rejected") =>
+ testServer.inject({
+ method: "POST",
+ url: `/api/v1/access-approvals/requests/${requestId}/review`,
+ headers: {
+ authorization: `Bearer ${jwtAuthToken}`
+ },
+ body: { status }
+ });
+
+const revokeAccessRequest = (requestId: string) =>
+ testServer.inject({
+ method: "POST",
+ url: `/api/v1/access-approvals/requests/${requestId}/revoke`,
+ headers: {
+ authorization: `Bearer ${jwtAuthToken}`
+ }
+ });
+
describe("Access approval request routing", () => {
afterEach(async () => {
const db = getDb();
const legacyIds = legacyPolicyIds.splice(0);
const globalIds = globalPolicyIds.splice(0);
+ // Privileges are reaped first because both grant and request FKs are SET NULL,
+ // so the rows would otherwise be orphaned rather than cascaded.
+ await db(TableName.AdditionalPrivilege)
+ .where({ actorUserId: seedData1.id })
+ .whereLike("name", "requested-privilege-%")
+ .del();
if (legacyIds.length) {
await db(TableName.AccessApprovalRequest).whereIn("policyId", legacyIds).del();
await db(TableName.AccessApprovalPolicyApprover).whereIn("policyId", legacyIds).del();
@@ -98,6 +124,10 @@ describe("Access approval request routing", () => {
await db(TableName.AccessApprovalPolicy).whereIn("id", legacyIds).del();
}
if (globalIds.length) {
+ await db(TableName.ApprovalRequestGrants)
+ .where({ projectId: seedData1.project.id, type: SECRET_ACCESS_TYPE })
+ .del();
+ await db(TableName.ApprovalRequests).whereIn("policyId", globalIds).del();
await db(TableName.ApprovalPolicies).whereIn("id", globalIds).del();
}
});
@@ -143,8 +173,18 @@ describe("Access approval request routing", () => {
const res = await createAccessRequest(secretPath);
- expect(res.statusCode).toBe(400);
- expect(res.json().message).toBe(GLOBAL_REQUEST_UNSUPPORTED_MESSAGE);
+ expect(res.statusCode).toBe(200);
+ const { approval } = res.json();
+ expect(approval.policyId).toBe(globalPolicyRow?.id);
+ expect(approval.status).toBe("pending");
+
+ const globalRequest = await db(TableName.ApprovalRequests).where({ id: approval.id }).first();
+ expect(globalRequest?.type).toBe(SECRET_ACCESS_TYPE);
+ expect(globalRequest?.policyId).toBe(globalPolicyRow?.id);
+ expect(globalRequest?.requesterId).toBe(seedData1.id);
+
+ const steps = await db(TableName.ApprovalRequestSteps).where({ requestId: approval.id });
+ expect(steps).toHaveLength(1);
const legacyRows = await db(TableName.AccessApprovalRequest)
.whereRaw(`"permissions"::text like ?`, [`%${secretPath}%`])
@@ -152,6 +192,92 @@ describe("Access approval request routing", () => {
expect(legacyRows).toHaveLength(0);
});
+ test("Review and revoke of a legacy request keep running on the legacy system", async () => {
+ const db = getDb();
+ const secretPath = "/routing-legacy-lifecycle";
+ const legacyPolicy = await createLegacyPolicy({ name: "routing-legacy-lifecycle", secretPath });
+
+ const createRes = await createAccessRequest(secretPath);
+ expect(createRes.statusCode).toBe(200);
+ const requestId = createRes.json().approval.id as string;
+
+ const reviewRes = await reviewAccessRequest(requestId, "approved");
+ expect(reviewRes.statusCode).toBe(200);
+ expect(reviewRes.json().review.requestId).toBe(requestId);
+
+ const reviewers = await db(TableName.AccessApprovalRequestReviewer).where({ requestId });
+ expect(reviewers).toHaveLength(1);
+
+ const approved = await db(TableName.AccessApprovalRequest).where({ id: requestId }).first();
+ expect(approved?.status).toBe("approved");
+ expect(approved?.policyId).toBe(legacyPolicy.id);
+ const privilegeId = approved?.privilegeId as string;
+ expect(privilegeId).toBeTruthy();
+
+ const privilege = await db(TableName.AdditionalPrivilege).where({ id: privilegeId }).first();
+ expect(privilege?.grantId).toBeNull();
+
+ const revokeRes = await revokeAccessRequest(requestId);
+ expect(revokeRes.statusCode).toBe(200);
+ expect(revokeRes.json().request.status).toBe("revoked");
+
+ const deletedPrivilege = await db(TableName.AdditionalPrivilege).where({ id: privilegeId }).first();
+ expect(deletedPrivilege).toBeUndefined();
+
+ const globalRequests = await db(TableName.ApprovalRequests).where({ id: requestId });
+ expect(globalRequests).toHaveLength(0);
+ const grants = await db(TableName.ApprovalRequestGrants).where({ requestId });
+ expect(grants).toHaveLength(0);
+ });
+
+ test("Creating a request on the global system sends the access request webhook", async () => {
+ const secretPath = "/routing-global-webhook";
+ const fakeWebhookServer = await createFakeWebhookServer();
+ const webhook = await createWebhook({
+ projectId: seedData1.project.id,
+ environmentSlug: seedData1.environment.slug,
+ webhookUrl: fakeWebhookServer.url,
+ authToken: jwtAuthToken
+ });
+
+ try {
+ const createRes = await createGlobalPolicy({ name: "routing-global-webhook", secretPath });
+ expect(createRes.statusCode).toBe(200);
+ const policyId = createRes.json().approval.id as string;
+
+ const res = await createAccessRequest(secretPath);
+ expect(res.statusCode).toBe(200);
+ const { approval } = res.json();
+
+ const message = await fakeWebhookServer.waitForMessage(
+ (m) => (m.body as { request?: { id?: string } })?.request?.id === approval.id,
+ 10_000
+ );
+ expect(message.body).toMatchObject({
+ event: "secrets.access-request.modified",
+ action: "created",
+ project: { id: seedData1.project.id },
+ request: {
+ id: approval.id,
+ status: "pending",
+ isBypassed: false,
+ policy: { id: policyId, name: "routing-global-webhook", hasSequencedApprovers: false },
+ requestedAccess: {
+ target: { environment: { slug: seedData1.environment.slug }, secretPath },
+ isTemporary: false,
+ permissions: [{ subject: "secrets", actions: ["read"] }]
+ },
+ requestedBy: { type: "user", id: seedData1.id },
+ approvedAt: null,
+ revokedAt: null
+ }
+ });
+ } finally {
+ await getDb()(TableName.Webhook).where({ id: webhook.id }).del();
+ await fakeWebhookServer.stop();
+ }
+ }, 30_000);
+
test("A request with no policy on either system is rejected", async () => {
const res = await createAccessRequest("/routing-none");
diff --git a/backend/src/ee/services/access-approval-policy/access-approval-policy-service.ts b/backend/src/ee/services/access-approval-policy/access-approval-policy-service.ts
index 04c9afbc93..74ed611359 100644
--- a/backend/src/ee/services/access-approval-policy/access-approval-policy-service.ts
+++ b/backend/src/ee/services/access-approval-policy/access-approval-policy-service.ts
@@ -6,10 +6,14 @@ import { ProjectPermissionActions, ProjectPermissionSub } from "@app/ee/services
import { BadRequestError, NotFoundError } from "@app/lib/errors";
import { groupBy } from "@app/lib/fn";
import { TAdditionalPrivilegeDALFactory } from "@app/services/additional-privilege/additional-privilege-dal";
-import { TApprovalPolicyDALFactory } from "@app/services/approval-policy/approval-policy-dal";
+import {
+ TApprovalPolicyDALFactory,
+ TApprovalPolicySecretEnvironmentDALFactory
+} from "@app/services/approval-policy/approval-policy-dal";
import { ApprovalPolicyType } from "@app/services/approval-policy/approval-policy-enums";
import { TProjectDALFactory } from "@app/services/project/project-dal";
import { TProjectEnvDALFactory } from "@app/services/project-env/project-env-dal";
+import { secretAccessApprovalPolicyExists } from "@app/services/secret-access-approval-bridge/secret-access-approval-bridge-fns";
import { TSecretAccessApprovalBridgeServiceFactory } from "@app/services/secret-access-approval-bridge/secret-access-approval-bridge-service";
import { TUserDALFactory } from "@app/services/user/user-dal";
@@ -48,6 +52,10 @@ type TAccessApprovalPolicyServiceFactoryDep = {
accessApprovalRequestReviewerDAL: Pick<TAccessApprovalRequestReviewerDALFactory, "update" | "delete">;
accessApprovalPolicyEnvironmentDAL: TAccessApprovalPolicyEnvironmentDALFactory;
approvalPolicyDAL: Pick<TApprovalPolicyDALFactory, "findOne">;
+ approvalPolicySecretEnvironmentDAL: Pick<
+ TApprovalPolicySecretEnvironmentDALFactory,
+ "findPolicyByEnvIdsAndSecretPath"
+ >;
secretAccessApprovalBridge: Pick<
TSecretAccessApprovalBridgeServiceFactory,
| "updateAccessApprovalPolicy"
@@ -72,6 +80,7 @@ export const accessApprovalPolicyServiceFactory = ({
additionalPrivilegeDAL,
accessApprovalRequestReviewerDAL,
approvalPolicyDAL,
+ approvalPolicySecretEnvironmentDAL,
secretAccessApprovalBridge
}: TAccessApprovalPolicyServiceFactoryDep): TAccessApprovalPolicyServiceFactory => {
const $usesGlobalApprovalBridge = async (policyId: string) => {
@@ -96,14 +105,23 @@ export const accessApprovalPolicyServiceFactory = ({
secretPath: string;
policyId?: string;
}) => {
- if (!envId && !envIds) {
- throw new BadRequestError({ message: "Must provide either envId or envIds" });
+ const resolvedEnvIds = envId ? [envId] : envIds;
+ if (!resolvedEnvIds?.length) {
+ throw new BadRequestError({ message: "Must provide either envId or envIds" }); // this message is not good for error
}
- const policy = await accessApprovalPolicyDAL.findPolicyByEnvIdAndSecretPath({
- secretPath,
- envIds: envId ? [envId] : (envIds as string[])
- });
- return policyId ? policy && policy.id !== policyId : Boolean(policy);
+
+ for (const id of resolvedEnvIds) {
+ if (
+ // eslint-disable-next-line no-await-in-loop
+ await secretAccessApprovalPolicyExists(
+ { envId: id, secretPath, excludePolicyId: policyId },
+ { accessApprovalPolicyDAL, approvalPolicySecretEnvironmentDAL }
+ )
+ ) {
+ return true;
+ }
+ }
+ return false;
};
const { verifyProjectSubjectsMembership } = approvalPolicyMembershipVerifierFactory({ projectDAL });
diff --git a/backend/src/ee/services/access-approval-request/access-approval-request-service.ts b/backend/src/ee/services/access-approval-request/access-approval-request-service.ts
index 10d0cdd525..187ef60971 100644
--- a/backend/src/ee/services/access-approval-request/access-approval-request-service.ts
+++ b/backend/src/ee/services/access-approval-request/access-approval-request-service.ts
@@ -76,7 +76,15 @@ type TSecretApprovalRequestServiceFactoryDep = {
TApprovalPolicySecretEnvironmentDALFactory,
"findPolicyByEnvIdsAndSecretPath"
>;
- secretAccessApprovalBridge: Pick<TSecretAccessApprovalBridgeServiceFactory, "createAccessApprovalRequest">;
+ secretAccessApprovalBridge: Pick<
+ TSecretAccessApprovalBridgeServiceFactory,
+ | "createAccessApprovalRequest"
+ | "listAccessApprovalRequests"
+ | "countAccessApprovalRequests"
+ | "isGlobalAccessApprovalRequest"
+ | "reviewAccessApprovalRequest"
+ | "revokeAccessApprovalRequest"
+ >;
accessApprovalRequestReviewerDAL: Pick<
TAccessApprovalRequestReviewerDALFactory,
"create" | "find" | "findOne" | "transaction" | "delete"
@@ -300,6 +308,7 @@ export const accessApprovalRequestServiceFactory = ({
envSlug,
secretPath,
requestedByUserId: actorId,
+ actorOrgId,
permissions: requestedPermissions,
isTemporary,
temporaryRange,
@@ -513,6 +522,10 @@ export const accessApprovalRequestServiceFactory = ({
editNote,
requestId
}) => {
+ if (await secretAccessApprovalBridge.isGlobalAccessApprovalRequest(requestId)) {
+ throw new BadRequestError({ message: "Access requests on the global approval system cannot be edited" });
+ }
+
const cfg = getConfig();
const accessApprovalRequest = await accessApprovalRequestDAL.findById(requestId);
@@ -714,6 +727,15 @@ export const accessApprovalRequestServiceFactory = ({
return { request: approval, projectId: accessApprovalRequest.projectId };
};
+ const $listRequestsAcrossSystems = async (projectId: string) => {
+ const policies = await accessApprovalPolicyDAL.find({ projectId });
+ const [legacyRequests, globalRequests] = await Promise.all([
+ accessApprovalRequestDAL.findRequestsWithPrivilegeByPolicyIds(policies.map((p) => p.id)),
+ secretAccessApprovalBridge.listAccessApprovalRequests({ projectId })
+ ]);
+ return [...legacyRequests, ...globalRequests];
+ };
+
const listApprovalRequests: TAccessApprovalRequestServiceFactory["listApprovalRequests"] = async ({
projectSlug,
authorUserId,
@@ -740,8 +762,7 @@ export const accessApprovalRequestServiceFactory = ({
ProjectPermissionSub.ApprovalRequests
);
- const policies = await accessApprovalPolicyDAL.find({ projectId: project.id });
- let requests = await accessApprovalRequestDAL.findRequestsWithPrivilegeByPolicyIds(policies.map((p) => p.id));
+ let requests = await $listRequestsAcrossSystems(project.id);
if (!canReadAllApprovalRequests) {
requests = requests.filter((request) => request.requestedByUserId === actorId);
@@ -777,6 +798,18 @@ export const accessApprovalRequestServiceFactory = ({
actorOrgId,
bypassReason
}) => {
+ if (await secretAccessApprovalBridge.isGlobalAccessApprovalRequest(requestId)) {
+ return secretAccessApprovalBridge.reviewAccessApprovalRequest({
+ requestId,
+ actor,
+ status,
+ actorId,
+ actorAuthMethod,
+ actorOrgId,
+ bypassReason
+ });
+ }
+
const accessApprovalRequest = await accessApprovalRequestDAL.findById(requestId);
if (!accessApprovalRequest) {
throw new NotFoundError({ message: `Secret approval request with ID '${requestId}' not found` });
@@ -1133,6 +1166,16 @@ export const accessApprovalRequestServiceFactory = ({
actorOrgId,
actorAuthMethod
}) => {
+ if (await secretAccessApprovalBridge.isGlobalAccessApprovalRequest(requestId)) {
+ return secretAccessApprovalBridge.revokeAccessApprovalRequest({
+ requestId,
+ actor,
+ actorId,
+ actorOrgId,
+ actorAuthMethod
+ });
+ }
+
const accessApprovalRequest = await accessApprovalRequestDAL.findById(requestId);
if (!accessApprovalRequest)
throw new NotFoundError({ message: `Access approval request with ID '${requestId}' not found` });
@@ -1216,6 +1259,26 @@ export const accessApprovalRequestServiceFactory = ({
return { request: updatedRequest, projectId: accessApprovalRequest.projectId };
};
+ const $countRequestsAcrossSystems = async ({
+ projectId,
+ policyId,
+ requestedByUserId
+ }: {
+ projectId: string;
+ policyId?: string;
+ requestedByUserId?: string;
+ }) => {
+ const [legacyCount, globalCount] = await Promise.all([
+ accessApprovalRequestDAL.getCount({ projectId, policyId, requestedByUserId }),
+ secretAccessApprovalBridge.countAccessApprovalRequests({ projectId, policyId, requesterId: requestedByUserId })
+ ]);
+
+ return {
+ pendingCount: legacyCount.pendingCount + globalCount.pendingCount,
+ finalizedCount: legacyCount.finalizedCount + globalCount.finalizedCount
+ };
+ };
+
const getCount: TAccessApprovalRequestServiceFactory["getCount"] = async ({
projectSlug,
policyId,
@@ -1241,7 +1304,7 @@ export const accessApprovalRequestServiceFactory = ({
ProjectPermissionSub.ApprovalRequests
);
- const count = await accessApprovalRequestDAL.getCount({
+ const count = await $countRequestsAcrossSystems({
projectId: project.id,
policyId,
requestedByUserId: canReadAllApprovalRequests ? undefined : actorId
diff --git a/backend/src/server/routes/index.ts b/backend/src/server/routes/index.ts
index eb60de1395..243fc02271 100644
--- a/backend/src/server/routes/index.ts
+++ b/backend/src/server/routes/index.ts
@@ -2617,7 +2617,21 @@ export const registerRoutes = async (
approvalPolicyStepApproversDAL,
approvalPolicyBypassersDAL,
approvalPolicySecretEnvironmentDAL,
- secretAccessApprovalBridgeDAL
+ secretAccessApprovalBridgeDAL,
+ userGroupMembershipDAL,
+ approvalRequestDAL,
+ approvalRequestStepsDAL,
+ approvalRequestStepEligibleApproversDAL,
+ approvalRequestApprovalsDAL,
+ approvalRequestGrantsDAL,
+ additionalPrivilegeDAL,
+ smtpService,
+ notificationService,
+ kmsService,
+ projectSlackConfigDAL,
+ microsoftTeamsService,
+ projectMicrosoftTeamsConfigDAL,
+ queueService
});
const accessApprovalPolicyService = accessApprovalPolicyServiceFactory({
@@ -2634,6 +2648,7 @@ export const registerRoutes = async (
accessApprovalRequestReviewerDAL,
additionalPrivilegeDAL,
approvalPolicyDAL,
+ approvalPolicySecretEnvironmentDAL,
secretAccessApprovalBridge: secretAccessApprovalBridgeService
});
diff --git a/backend/src/services/approval-policy/secret-access/secret-access-policy-schemas.ts b/backend/src/services/approval-policy/secret-access/secret-access-policy-schemas.ts
index fecee38855..8d80eb380e 100644
--- a/backend/src/services/approval-policy/secret-access/secret-access-policy-schemas.ts
+++ b/backend/src/services/approval-policy/secret-access/secret-access-policy-schemas.ts
@@ -11,7 +11,14 @@ export const SecretAccessPolicyConstraintsSchema = z.object({
requestExpirationTime: z.string().nullable()
});
-export const SecretAccessPolicyRequestDataSchema = z.object({});
+export const SecretAccessPolicyRequestDataSchema = z.object({
+ envId: z.string().uuid(),
+ envSlug: z.string(),
+ secretPath: z.string(),
+ permissions: z.unknown(),
+ isTemporary: z.boolean(),
+ temporaryRange: z.string().nullable()
+});
export const SecretAccessPolicySchema = BaseApprovalPolicySchema.extend({
conditions: z.object({
diff --git a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-dal.ts b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-dal.ts
index 0f8f3354b6..46cac6dff8 100644
--- a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-dal.ts
+++ b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-dal.ts
@@ -2,11 +2,15 @@ import { Knex } from "knex";
import { z } from "zod";
import { TDbClient } from "@app/db";
-import { TableName, TUsers } from "@app/db/schemas";
+import { AccessScope, TableName, TUsers } from "@app/db/schemas";
import { ApproverType, BypasserType } from "@app/ee/services/access-approval-policy/access-approval-policy-types";
import { DatabaseError } from "@app/lib/errors";
import { selectAllTableCols, sqlNestRelationships } from "@app/lib/knex";
-import { ApprovalPolicyType } from "@app/services/approval-policy/approval-policy-enums";
+import {
+ ApprovalPolicyType,
+ ApprovalRequestGrantStatus,
+ ApprovalRequestStatus
+} from "@app/services/approval-policy/approval-policy-enums";
import { SecretAccessPolicyConstraintsSchema } from "@app/services/approval-policy/secret-access/secret-access-policy-schemas";
const StoredConstraintsSchema = z.object({ version: z.literal(1), constraints: SecretAccessPolicyConstraintsSchema });
@@ -167,5 +171,172 @@ export const secretAccessApprovalBridgeDALFactory = (db: TDbClient) => {
}
};
- return { findSecretAccessPolicies };
+ const findSecretAccessRequestById = async (requestId: string, tx?: Knex) => {
+ try {
+ const request = await (tx || db.replicaNode())(TableName.ApprovalRequests)
+ .where({ id: requestId, type: ApprovalPolicyType.SecretAccess })
+ .first();
+ if (!request) return null;
+
+ const grant = await (tx || db.replicaNode())(TableName.ApprovalRequestGrants)
+ .where({ requestId: request.id, type: ApprovalPolicyType.SecretAccess })
+ .orderBy("createdAt", "desc")
+ .first();
+
+ const privilege = grant
+ ? await (tx || db.replicaNode())(TableName.AdditionalPrivilege).where({ grantId: grant.id }).first()
+ : undefined;
+
+ return { ...request, grant: grant ?? null, privilegeId: privilege?.id ?? null };
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find secret access approval request by id" });
+ }
+ };
+
+ const findActiveGrants = async ({ projectId, granteeUserId }: { projectId: string; granteeUserId: string }) => {
+ try {
+ return await db
+ .replicaNode()(TableName.ApprovalRequestGrants)
+ .where({
+ projectId,
+ granteeUserId,
+ type: ApprovalPolicyType.SecretAccess,
+ status: ApprovalRequestGrantStatus.Active
+ })
+ .whereNull("revokedAt")
+ .where((qb) => {
+ void qb.whereNull("expiresAt").orWhere("expiresAt", ">", new Date());
+ });
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find active secret access grants" });
+ }
+ };
+
+ const findPendingRequests = async ({ policyId, requesterId }: { policyId: string; requesterId: string }) => {
+ try {
+ return await db
+ .replicaNode()(TableName.ApprovalRequests)
+ .where({ policyId, requesterId, type: ApprovalPolicyType.SecretAccess, status: ApprovalRequestStatus.Pending })
+ .where((qb) => {
+ void qb.whereNull("expiresAt").orWhere("expiresAt", ">", new Date());
+ });
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find pending secret access approval requests" });
+ }
+ };
+
+ const findSecretAccessRequests = async ({
+ projectId,
+ policyId,
+ requesterId
+ }: {
+ projectId: string;
+ policyId?: string;
+ requesterId?: string;
+ }) => {
+ try {
+ return await db
+ .replicaNode()(TableName.ApprovalRequests)
+ .where({ projectId, type: ApprovalPolicyType.SecretAccess })
+ .where((qb) => {
+ if (policyId) void qb.where("policyId", policyId);
+ if (requesterId) void qb.where("requesterId", requesterId);
+ })
+ .orderBy("createdAt", "desc");
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find secret access approval requests" });
+ }
+ };
+
+ const findGrantsByRequestIds = async (requestIds: string[]) => {
+ if (!requestIds.length) return [];
+ try {
+ return await db
+ .replicaNode()(TableName.ApprovalRequestGrants)
+ .whereIn("requestId", requestIds)
+ .where({ type: ApprovalPolicyType.SecretAccess })
+ .orderBy("createdAt", "desc");
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find secret access grants by request ids" });
+ }
+ };
+
+ const findPrivilegesByGrantIds = async (grantIds: string[]) => {
+ if (!grantIds.length) return [];
+ try {
+ return await db.replicaNode()(TableName.AdditionalPrivilege).whereIn("grantId", grantIds);
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find additional privileges by grant ids" });
+ }
+ };
+
+ const findApprovalsByRequestIds = async (requestIds: string[]) => {
+ if (!requestIds.length) return [];
+ try {
+ return await db
+ .replicaNode()(TableName.ApprovalRequestApprovals)
+ .join(
+ TableName.ApprovalRequestSteps,
+ `${TableName.ApprovalRequestApprovals}.stepId`,
+ `${TableName.ApprovalRequestSteps}.id`
+ )
+ .whereIn(`${TableName.ApprovalRequestSteps}.requestId`, requestIds)
+ .select(selectAllTableCols(TableName.ApprovalRequestApprovals))
+ .select(db.ref("requestId").withSchema(TableName.ApprovalRequestSteps))
+ .orderBy(`${TableName.ApprovalRequestApprovals}.createdAt`, "asc");
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find approvals by request ids" });
+ }
+ };
+
+ const findGroupMembers = async (groupIds: string[]) => {
+ if (!groupIds.length) return [];
+ try {
+ return await db
+ .replicaNode()(TableName.UserGroupMembership)
+ .whereIn("groupId", groupIds)
+ .select("groupId", "userId");
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find group members" });
+ }
+ };
+
+ const findUsersByIds = async (userIds: string[]) => {
+ if (!userIds.length) return [];
+ try {
+ return await db
+ .replicaNode()(TableName.Users)
+ .whereIn("id", userIds)
+ .select("id", "email", "username", "firstName", "lastName");
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find users by ids" });
+ }
+ };
+
+ const findOrgMembershipActivity = async (orgId: string, userIds: string[]) => {
+ if (!userIds.length) return [];
+ try {
+ return await db
+ .replicaNode()(TableName.Membership)
+ .where({ scope: AccessScope.Organization, scopeOrgId: orgId })
+ .whereIn("actorUserId", userIds)
+ .select("actorUserId", "isActive");
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find org membership activity" });
+ }
+ };
+
+ return {
+ findSecretAccessPolicies,
+ findSecretAccessRequestById,
+ findSecretAccessRequests,
+ findActiveGrants,
+ findPendingRequests,
+ findGrantsByRequestIds,
+ findPrivilegesByGrantIds,
+ findApprovalsByRequestIds,
+ findGroupMembers,
+ findUsersByIds,
+ findOrgMembershipActivity
+ };
};
diff --git a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-fns.ts b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-fns.ts
index dd1ddb1381..57e5101565 100644
--- a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-fns.ts
+++ b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-fns.ts
@@ -1,5 +1,62 @@
+import msFn from "ms";
+import { z } from "zod";
+
+import { TAdditionalPrivileges, TApprovalRequestGrants, TApprovalRequests, TUsers } from "@app/db/schemas";
import { TAccessApprovalPolicyDALFactory } from "@app/ee/services/access-approval-policy/access-approval-policy-dal";
+import { ApprovalStatus } from "@app/ee/services/access-approval-request/access-approval-request-types";
+import { getConfig } from "@app/lib/config/env";
+import { BadRequestError, NotFoundError } from "@app/lib/errors";
+import { logger } from "@app/lib/logger";
+import { ms } from "@app/lib/ms";
+import { triggerWorkflowIntegrationNotification } from "@app/lib/workflow-integrations/trigger-notification";
+import { TriggerFeature } from "@app/lib/workflow-integrations/types";
import { TApprovalPolicySecretEnvironmentDALFactory } from "@app/services/approval-policy/approval-policy-dal";
+import {
+ ApprovalRequestGrantStatus,
+ ApprovalRequestStatus,
+ ApproverType
+} from "@app/services/approval-policy/approval-policy-enums";
+import { ApprovalPolicyStep } from "@app/services/approval-policy/approval-policy-types";
+import { resolveStepApproverUserIds } from "@app/services/approval-policy/approval-request-fns";
+import { SecretAccessPolicyRequestDataSchema } from "@app/services/approval-policy/secret-access/secret-access-policy-schemas";
+import { TSecretAccessRequestData } from "@app/services/approval-policy/secret-access/secret-access-policy-types";
+import { NotificationType } from "@app/services/notification/notification-types";
+import { SmtpTemplates } from "@app/services/smtp/smtp-service";
+
+import { TSecretAccessApprovalBridgeDALFactory } from "./secret-access-approval-bridge-dal";
+import { TSecretAccessApprovalBridgeServiceFactoryDep } from "./secret-access-approval-bridge-types";
+
+const StoredRequestDataSchema = z.object({ version: z.literal(1), requestData: SecretAccessPolicyRequestDataSchema });
+
+export const parseSecretAccessRequestData = (requestData: unknown): TSecretAccessRequestData | null => {
+ const parsed = StoredRequestDataSchema.safeParse(requestData);
+ return parsed.success ? parsed.data.requestData : null;
+};
+
+// jsonb does not preserve object key order, so a stored permission set has to be
+// compared against the incoming one on a canonical form rather than raw JSON text.
+const canonicalize = (value: unknown): unknown => {
+ if (Array.isArray(value)) return value.map(canonicalize);
+ if (value && typeof value === "object") {
+ return Object.fromEntries(
+ Object.keys(value as Record<string, unknown>)
+ .sort()
+ .map((key) => [key, canonicalize((value as Record<string, unknown>)[key])])
+ );
+ }
+ return value;
+};
+
+export const hasSameAccessCriteria = (
+ data: TSecretAccessRequestData | null,
+ criteria: { permissions: unknown; isTemporary: boolean }
+) => {
+ if (!data) return false;
+ return (
+ data.isTemporary === criteria.isTemporary &&
+ JSON.stringify(canonicalize(data.permissions)) === JSON.stringify(canonicalize(criteria.permissions))
+ );
+};
type TSecretAccessApprovalPolicyExistsDep = {
accessApprovalPolicyDAL: Pick<TAccessApprovalPolicyDALFactory, "findPolicyByEnvIdAndSecretPath">;
@@ -23,3 +80,386 @@ export const secretAccessApprovalPolicyExists = async (
});
return Boolean(policy);
};
+
+export type TSecretAccessRequestRow = TApprovalRequests & {
+ grant: TApprovalRequestGrants | null;
+ privilegeId: string | null;
+};
+
+export const getSecretAccessRequestData = (
+ request: Pick<TSecretAccessRequestRow, "requestData">
+): TSecretAccessRequestData => {
+ const data = parseSecretAccessRequestData(request.requestData);
+ if (!data) {
+ throw new BadRequestError({ message: "The access request is malformed and cannot be processed" });
+ }
+ return data;
+};
+
+export const toLegacyAccessApprovalRequest = (
+ request: Pick<
+ TSecretAccessRequestRow,
+ | "id"
+ | "policyId"
+ | "requesterId"
+ | "requestData"
+ | "justification"
+ | "status"
+ | "expiresAt"
+ | "createdAt"
+ | "updatedAt"
+ | "grant"
+ | "privilegeId"
+ >,
+ approvedByUserId: string | null = null
+): {
+ id: string;
+ policyId: string;
+ requestedByUserId: string;
+ isTemporary: boolean;
+ temporaryRange: string | null;
+ permissions: unknown;
+ note: string | null;
+ privilegeId: string | null;
+ status: string;
+ expiresAt: Date | null;
+ approvedAt: Date | null;
+ approvedByUserId: string | null;
+ revokedAt: Date | null;
+ revokedByUserId: string | null;
+ createdAt: Date;
+ updatedAt: Date;
+ editedByUserId: null;
+ editNote: null;
+ bypassReason: null;
+ privilegeDeletedAt: null;
+} => {
+ if (!request.policyId) {
+ throw new BadRequestError({ message: "The policy associated with this access request has been deleted." });
+ }
+ if (!request.requesterId) {
+ throw new NotFoundError({ message: "The user who created this access request no longer exists" });
+ }
+
+ const data = getSecretAccessRequestData(request);
+ const { grant } = request;
+ const isRevoked = grant?.status === ApprovalRequestGrantStatus.Revoked;
+
+ let { status } = request;
+ if (isRevoked) status = ApprovalStatus.REVOKED;
+ else if (request.status === ApprovalRequestStatus.Cancelled) status = ApprovalStatus.REJECTED;
+
+ return {
+ id: request.id,
+ policyId: request.policyId,
+ requestedByUserId: request.requesterId,
+ isTemporary: data.isTemporary,
+ temporaryRange: data.temporaryRange,
+ permissions: data.permissions,
+ note: request.justification ?? null,
+ privilegeId: grant?.status === ApprovalRequestGrantStatus.Active ? request.privilegeId : null,
+ status,
+ expiresAt: request.expiresAt ?? null,
+ approvedAt: grant?.createdAt ?? null,
+ approvedByUserId,
+ revokedAt: grant?.revokedAt ?? null,
+ revokedByUserId: grant?.revokedByUserId ?? null,
+ createdAt: request.createdAt,
+ updatedAt: request.updatedAt,
+ editedByUserId: null,
+ editNote: null,
+ bypassReason: null,
+ privilegeDeletedAt: null
+ };
+};
+
+type TNotifySecretAccessStepApproversDep = Pick<
+ TSecretAccessApprovalBridgeServiceFactoryDep,
+ | "userDAL"
+ | "userGroupMembershipDAL"
+ | "projectDAL"
+ | "projectSlackConfigDAL"
+ | "kmsService"
+ | "microsoftTeamsService"
+ | "projectMicrosoftTeamsConfigDAL"
+ | "notificationService"
+ | "smtpService"
+>;
+
+export const notifySecretAccessStepApprovers = async (
+ {
+ step,
+ request,
+ project,
+ requestedByUser,
+ data
+ }: {
+ step: ApprovalPolicyStep;
+ request: TSecretAccessRequestRow;
+ project: { id: string; name: string; orgId: string };
+ requestedByUser: { firstName?: string | null; lastName?: string | null; email?: string | null };
+ data: TSecretAccessRequestData;
+ },
+ {
+ userDAL,
+ userGroupMembershipDAL,
+ projectDAL,
+ projectSlackConfigDAL,
+ kmsService,
+ microsoftTeamsService,
+ projectMicrosoftTeamsConfigDAL,
+ notificationService,
+ smtpService
+ }: TNotifySecretAccessStepApproversDep
+) => {
+ const cfg = getConfig();
+ const approverUserIds = await resolveStepApproverUserIds(step, userGroupMembershipDAL);
+ const approverUsers = approverUserIds.size ? await userDAL.find({ $in: { id: [...approverUserIds] } }) : [];
+
+ const requesterFullName = request.requesterName;
+ const projectPath = `/organizations/${project.orgId}/projects/secret-management/${project.id}`;
+ const approvalPath = `${projectPath}/approval?selectedTab=resource-requests&requestId=${encodeURIComponent(request.id)}`;
+ const approvalUrl = `${cfg.SITE_URL}${approvalPath}`;
+ const accessTypes = Array.isArray(data.permissions)
+ ? (data.permissions as unknown[][]).map((permission) => String(permission[0]))
+ : [];
+
+ try {
+ await triggerWorkflowIntegrationNotification({
+ input: {
+ notification: {
+ type: TriggerFeature.ACCESS_REQUEST,
+ payload: {
+ projectName: project.name,
+ projectPath,
+ requesterFullName,
+ isTemporary: data.isTemporary,
+ requesterEmail: request.requesterEmail,
+ secretPath: data.secretPath,
+ environment: data.envSlug,
+ permissions: accessTypes,
+ approvalUrl,
+ note: request.justification ?? undefined
+ }
+ },
+ projectId: project.id
+ },
+ dependencies: {
+ projectDAL,
+ projectSlackConfigDAL,
+ kmsService,
+ microsoftTeamsService,
+ projectMicrosoftTeamsConfigDAL
+ }
+ });
+
+ await notificationService.createUserNotifications(
+ approverUsers.map((approver) => ({
+ userId: approver.id,
+ orgId: request.organizationId,
+ type: NotificationType.ACCESS_APPROVAL_REQUEST,
+ title: "Access Approval Request",
+ body: `**${requesterFullName}** (${requestedByUser.email}) has requested ${data.isTemporary ? "temporary" : "permanent"} access to **${data.secretPath}** in the **${data.envSlug}** environment for project **${project.name}**.`,
+ link: approvalPath
+ }))
+ );
+
+ const recipients = approverUsers.filter((approver) => approver.email).map((approver) => approver.email!);
+ if (recipients.length) {
+ await smtpService.sendMail({
+ recipients,
+ subjectLine: "Access Approval Request",
+ substitutions: {
+ projectName: project.name,
+ requesterFullName,
+ requesterEmail: requestedByUser.email,
+ isTemporary: data.isTemporary,
+ ...(data.isTemporary && data.temporaryRange && { expiresIn: msFn(ms(data.temporaryRange), { long: true }) }),
+ secretPath: data.secretPath,
+ environment: data.envSlug,
+ permissions: accessTypes,
+ approvalUrl,
+ note: request.justification ?? undefined
+ },
+ template: SmtpTemplates.AccessApprovalRequest
+ });
+ }
+ } catch (error) {
+ logger.error(error, `Failed to notify access request approvers [requestId=${request.id}]`);
+ }
+};
+
+type TSecretAccessPolicyRow = Awaited<
+ ReturnType<TSecretAccessApprovalBridgeDALFactory["findSecretAccessPolicies"]>
+>[number];
+type TApprovalWithRequestId = Awaited<
+ ReturnType<TSecretAccessApprovalBridgeDALFactory["findApprovalsByRequestIds"]>
+>[number];
+
+export type TSecretAccessRequestListInput = {
+ requests: TApprovalRequests[];
+ policies: TSecretAccessPolicyRow[];
+ grants: TApprovalRequestGrants[];
+ privileges: TAdditionalPrivileges[];
+ approvals: TApprovalWithRequestId[];
+ groupMembers: { groupId: string; userId: string }[];
+ users: Pick<TUsers, "id" | "email" | "username" | "firstName" | "lastName">[];
+ orgMemberships: { actorUserId?: string | null; isActive: boolean }[];
+};
+
+export type TPolicySubject = { type: string; id?: string | null };
+
+export const isGroupSubject = (subject: TPolicySubject) => subject.type === ApproverType.Group;
+
+export const collectSecretAccessPolicyGroupIds = (policies: TSecretAccessPolicyRow[]) => [
+ ...new Set(
+ policies
+ .flatMap((policy) => [...policy.approvers, ...policy.bypassers])
+ .filter(isGroupSubject)
+ .map((subject) => subject.id)
+ .filter((id): id is string => Boolean(id))
+ )
+];
+
+export const isPolicySubjectMatch = (subjects: TPolicySubject[], actorId: string, actorGroupIds: Set<string>) =>
+ subjects.some((subject) => {
+ if (!subject.id) return false;
+ return isGroupSubject(subject) ? actorGroupIds.has(subject.id) : subject.id === actorId;
+ });
+
+export const collectSecretAccessRequestUserIds = ({
+ requests,
+ policies,
+ grants,
+ approvals,
+ groupMembers
+}: Pick<TSecretAccessRequestListInput, "requests" | "policies" | "grants" | "approvals" | "groupMembers">) => {
+ const userIds = new Set<string>();
+ requests.forEach((request) => {
+ if (request.requesterId) userIds.add(request.requesterId);
+ });
+ grants.forEach((grant) => {
+ if (grant.revokedByUserId) userIds.add(grant.revokedByUserId);
+ });
+ approvals.forEach((approval) => userIds.add(approval.approverUserId));
+ policies.forEach((policy) => {
+ policy.approvers.forEach((approver) => {
+ if (!isGroupSubject(approver) && approver.id) userIds.add(approver.id);
+ });
+ });
+ groupMembers.forEach((member) => userIds.add(member.userId));
+ return [...userIds];
+};
+
+export const composeSecretAccessRequestRows = ({
+ requests,
+ policies,
+ grants,
+ privileges,
+ approvals,
+ groupMembers,
+ users,
+ orgMemberships
+}: TSecretAccessRequestListInput) => {
+ const policiesById = new Map(policies.map((policy) => [policy.id, policy]));
+ const userById = new Map(users.map((user) => [user.id, user]));
+ const privilegeByGrantId = new Map(privileges.map((privilege) => [privilege.grantId as string, privilege]));
+ const isOrgMembershipActive = new Map(
+ orgMemberships.map((membership) => [membership.actorUserId as string, membership.isActive])
+ );
+
+ const grantByRequestId = new Map<string, TApprovalRequestGrants>();
+ grants.forEach((grant) => {
+ if (grant.requestId && !grantByRequestId.has(grant.requestId)) grantByRequestId.set(grant.requestId, grant);
+ });
+
+ const approvalsByRequestId = new Map<string, TApprovalWithRequestId[]>();
+ approvals.forEach((approval) => {
+ approvalsByRequestId.set(approval.requestId, [...(approvalsByRequestId.get(approval.requestId) ?? []), approval]);
+ });
+
+ const userIdsByGroupId = new Map<string, string[]>();
+ groupMembers.forEach((member) => {
+ userIdsByGroupId.set(member.groupId, [...(userIdsByGroupId.get(member.groupId) ?? []), member.userId]);
+ });
+ const expandSubject = (subject: TPolicySubject) => {
+ if (!subject.id) return [];
+ return isGroupSubject(subject) ? (userIdsByGroupId.get(subject.id) ?? []) : [subject.id];
+ };
+
+ const toUser = (userId: string | null | undefined) => {
+ if (!userId) return null;
+ const user = userById.get(userId);
+ return {
+ userId,
+ email: user?.email ?? null,
+ firstName: user?.firstName ?? null,
+ lastName: user?.lastName ?? null,
+ username: user?.username ?? ""
+ };
+ };
+
+ return requests.map((request) => {
+ const policy = request.policyId ? policiesById.get(request.policyId) : undefined;
+ const grant = grantByRequestId.get(request.id) ?? null;
+ const privilege = grant ? privilegeByGrantId.get(grant.id) : undefined;
+ const requestApprovals = approvalsByRequestId.get(request.id) ?? [];
+ const lastApproval = requestApprovals.filter((a) => a.decision === "approved").at(-1);
+
+ const approvers = (policy?.approvers ?? []).flatMap((approver) =>
+ expandSubject(approver).map((userId) => ({
+ userId,
+ sequence: approver.sequence ?? 1,
+ approvalsRequired: approver.approvalsRequired ?? 1,
+ email: userById.get(userId)?.email ?? null,
+ username: userById.get(userId)?.username ?? "",
+ isOrgMembershipActive: isOrgMembershipActive.get(userId) ?? false
+ }))
+ );
+ const bypassers = (policy?.bypassers ?? []).flatMap(expandSubject);
+
+ return {
+ request,
+ grant,
+ privilegeId: privilege?.id ?? null,
+ privilege: privilege
+ ? {
+ membershipId: privilege.projectId ?? "",
+ userId: privilege.actorUserId ?? "",
+ projectId: privilege.projectId ?? "",
+ isTemporary: privilege.isTemporary,
+ temporaryMode: privilege.temporaryMode,
+ temporaryRange: privilege.temporaryRange,
+ temporaryAccessStartTime: privilege.temporaryAccessStartTime,
+ temporaryAccessEndTime: privilege.temporaryAccessEndTime,
+ permissions: privilege.permissions
+ }
+ : null,
+ policy: policy
+ ? {
+ id: policy.id,
+ name: policy.name,
+ approvals: policy.approvals,
+ secretPath: policy.secretPath,
+ enforcementLevel: policy.enforcementLevel,
+ allowedSelfApprovals: policy.allowedSelfApprovals,
+ envId: policy.envId,
+ deletedAt: null,
+ maxTimePeriod: policy.maxTimePeriod,
+ requestExpirationTime: policy.requestExpirationTime,
+ approvers,
+ bypassers
+ }
+ : null,
+ environment: policy?.environment ?? null,
+ requestedByUser: toUser(request.requesterId),
+ approvedByUser: toUser(lastApproval?.approverUserId),
+ revokedByUser: toUser(grant?.revokedByUserId),
+ reviewers: requestApprovals.map((approval) => ({
+ userId: approval.approverUserId,
+ status: approval.decision,
+ isOrgMembershipActive: isOrgMembershipActive.get(approval.approverUserId) ?? false
+ }))
+ };
+ });
+};
diff --git a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-service.ts b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-service.ts
index c57c582f57..434fe8d1df 100644
--- a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-service.ts
+++ b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-service.ts
@@ -1,26 +1,65 @@
-import { ForbiddenError } from "@casl/ability";
+import { ForbiddenError, subject } from "@casl/ability";
+import slugify from "@sindresorhus/slugify";
import { Knex } from "knex";
-import { ActionProjectType } from "@app/db/schemas";
+import { ActionProjectType, ProjectMembershipRole, TemporaryPermissionMode } from "@app/db/schemas";
import { approvalPolicyMembershipVerifierFactory } from "@app/ee/services/access-approval-policy/access-approval-policy-fns";
import {
ApproverType,
BypasserType,
TCreateAccessApprovalPolicy
} from "@app/ee/services/access-approval-policy/access-approval-policy-types";
-import { ProjectPermissionActions, ProjectPermissionSub } from "@app/ee/services/permission/project-permission";
-import { BadRequestError, NotFoundError } from "@app/lib/errors";
+import { verifyRequestedPermissions } from "@app/ee/services/access-approval-request/access-approval-request-fns";
+import { ApprovalStatus } from "@app/ee/services/access-approval-request/access-approval-request-types";
+import { flattenActiveRolesFromMemberships } from "@app/ee/services/permission/permission-service";
+import {
+ ProjectPermissionActions,
+ ProjectPermissionMemberActions,
+ ProjectPermissionSub
+} from "@app/ee/services/permission/project-permission";
+import { getConfig } from "@app/lib/config/env";
+import { BadRequestError, ForbiddenRequestError, NotFoundError } from "@app/lib/errors";
import { groupBy } from "@app/lib/fn";
-import { ApprovalPolicyType } from "@app/services/approval-policy/approval-policy-enums";
+import { logger } from "@app/lib/logger";
+import { ms } from "@app/lib/ms";
+import { alphaNumericNanoId } from "@app/lib/nanoid";
+import { QueueJobs, QueueName } from "@app/queue";
+import {
+ ApprovalPolicyType,
+ ApprovalRequestApprovalDecision,
+ ApprovalRequestGrantStatus,
+ ApprovalRequestStatus,
+ ApprovalRequestStepStatus
+} from "@app/services/approval-policy/approval-policy-enums";
+import { createApprovalRequestWithSteps } from "@app/services/approval-policy/approval-request-fns";
+import { SecretAccessPolicyRequestDataSchema } from "@app/services/approval-policy/secret-access/secret-access-policy-schemas";
+import { TSecretAccessRequestData } from "@app/services/approval-policy/secret-access/secret-access-policy-types";
+import { ActorType } from "@app/services/auth/auth-type";
+import { AccessRequestWebhookAction, WebhookEvents } from "@app/services/webhook/webhook-types";
-import { secretAccessApprovalPolicyExists } from "./secret-access-approval-bridge-fns";
+import {
+ collectSecretAccessPolicyGroupIds,
+ collectSecretAccessRequestUserIds,
+ composeSecretAccessRequestRows,
+ getSecretAccessRequestData,
+ hasSameAccessCriteria,
+ isPolicySubjectMatch,
+ notifySecretAccessStepApprovers,
+ parseSecretAccessRequestData,
+ secretAccessApprovalPolicyExists,
+ toLegacyAccessApprovalRequest
+} from "./secret-access-approval-bridge-fns";
import {
TCountSecretAccessApprovalPoliciesDTO,
+ TCountSecretAccessApprovalRequestsDTO,
TCreateSecretAccessApprovalPolicyDTO,
TCreateSecretAccessApprovalRequestDTO,
TDeleteSecretAccessApprovalPolicyDTO,
TGetSecretAccessApprovalPolicyByIdDTO,
TListSecretAccessApprovalPoliciesDTO,
+ TListSecretAccessApprovalRequestsDTO,
+ TReviewSecretAccessApprovalRequestDTO,
+ TRevokeSecretAccessApprovalRequestDTO,
TSecretAccessApprovalBridgeServiceFactoryDep,
TUpdateSecretAccessApprovalPolicyDTO
} from "./secret-access-approval-bridge-types";
@@ -47,7 +86,21 @@ export const secretAccessApprovalBridgeServiceFactory = ({
approvalPolicyStepApproversDAL,
approvalPolicyBypassersDAL,
approvalPolicySecretEnvironmentDAL,
- secretAccessApprovalBridgeDAL
+ secretAccessApprovalBridgeDAL,
+ userGroupMembershipDAL,
+ approvalRequestDAL,
+ approvalRequestStepsDAL,
+ approvalRequestStepEligibleApproversDAL,
+ approvalRequestApprovalsDAL,
+ approvalRequestGrantsDAL,
+ additionalPrivilegeDAL,
+ smtpService,
+ notificationService,
+ kmsService,
+ projectSlackConfigDAL,
+ microsoftTeamsService,
+ projectMicrosoftTeamsConfigDAL,
+ queueService
}: TSecretAccessApprovalBridgeServiceFactoryDep) => {
const { verifyProjectSubjectsMembership } = approvalPolicyMembershipVerifierFactory({ projectDAL });
@@ -541,10 +594,609 @@ export const secretAccessApprovalBridgeServiceFactory = ({
return policies.length;
};
- const createAccessApprovalRequest: (dto: TCreateSecretAccessApprovalRequestDTO) => Promise<never> = async () => {
- throw new BadRequestError({
- message: "Secret access approval requests are not supported on the global approval system yet"
+ const $findRequestById = async (requestId: string) => {
+ const request = await secretAccessApprovalBridgeDAL.findSecretAccessRequestById(requestId);
+ if (!request) throw new NotFoundError({ message: `Access request with ID '${requestId}' not found` });
+ return request;
+ };
+
+ const $getActorGroupIds = async (actorId: string, orgId: string) => {
+ const groups = await userGroupMembershipDAL.findGroupMembershipsByUserIdInOrg(actorId, orgId);
+ return new Set(groups.map((group) => group.groupId));
+ };
+
+ const $loadRequestRows = async (filter: { projectId: string; policyId?: string; requesterId?: string }) => {
+ const requests = await secretAccessApprovalBridgeDAL.findSecretAccessRequests(filter);
+ if (!requests.length) return [];
+
+ const requestIds = requests.map((request) => request.id);
+ const [policies, grants, approvals] = await Promise.all([
+ secretAccessApprovalBridgeDAL.findSecretAccessPolicies({ projectId: filter.projectId }),
+ secretAccessApprovalBridgeDAL.findGrantsByRequestIds(requestIds),
+ secretAccessApprovalBridgeDAL.findApprovalsByRequestIds(requestIds)
+ ]);
+
+ const [privileges, groupMembers] = await Promise.all([
+ secretAccessApprovalBridgeDAL.findPrivilegesByGrantIds(grants.map((grant) => grant.id)),
+ secretAccessApprovalBridgeDAL.findGroupMembers(collectSecretAccessPolicyGroupIds(policies))
+ ]);
+
+ const userIds = collectSecretAccessRequestUserIds({ requests, policies, grants, approvals, groupMembers });
+ const [users, orgMemberships] = await Promise.all([
+ secretAccessApprovalBridgeDAL.findUsersByIds(userIds),
+ secretAccessApprovalBridgeDAL.findOrgMembershipActivity(requests[0].organizationId, userIds)
+ ]);
+
+ return composeSecretAccessRequestRows({
+ requests,
+ policies,
+ grants,
+ privileges,
+ approvals,
+ groupMembers,
+ users,
+ orgMemberships
+ });
+ };
+
+ const listAccessApprovalRequests = async ({ projectId }: TListSecretAccessApprovalRequestsDTO) => {
+ const rows = await $loadRequestRows({ projectId });
+
+ return rows.flatMap((row) => {
+ if (!row.policy || !row.environment || !row.requestedByUser) return [];
+ const data = parseSecretAccessRequestData(row.request.requestData);
+ if (!data) return [];
+
+ const legacy = toLegacyAccessApprovalRequest(
+ { ...row.request, grant: row.grant, privilegeId: row.privilegeId },
+ row.approvedByUser?.userId ?? null
+ );
+ const { approvers, bypassers, ...policy } = row.policy;
+
+ return [
+ {
+ ...legacy,
+ projectId,
+ environment: row.environment.slug,
+ environmentName: row.environment.name,
+ policy: { ...policy, approvers, bypassers },
+ requestedByUser: row.requestedByUser,
+ approvedByUser: row.approvedByUser,
+ revokedByUser: row.revokedByUser,
+ privilege: legacy.privilegeId ? row.privilege : null,
+ isApproved: legacy.status === ApprovalStatus.APPROVED,
+ reviewers: row.reviewers,
+ approvers,
+ bypassers
+ }
+ ];
+ });
+ };
+
+ const countAccessApprovalRequests = async ({
+ projectId,
+ policyId,
+ requesterId
+ }: TCountSecretAccessApprovalRequestsDTO) => {
+ const rows = await $loadRequestRows({ projectId, policyId, requesterId });
+ const now = new Date();
+
+ const isPending = (row: (typeof rows)[number]) =>
+ Boolean(row.policy) &&
+ row.request.status === ApprovalRequestStatus.Pending &&
+ !row.reviewers.some((reviewer) => reviewer.status === ApprovalRequestApprovalDecision.Rejected) &&
+ !(row.request.expiresAt && new Date(row.request.expiresAt) < now);
+
+ const pendingCount = rows.filter(isPending).length;
+ return { pendingCount, finalizedCount: rows.length - pendingCount };
+ };
+
+ const $queueAccessRequestCreatedWebhook = async ({
+ request,
+ project,
+ policy,
+ requestedByUser,
+ envId,
+ envSlug,
+ secretPath
+ }: {
+ request: ReturnType<typeof toLegacyAccessApprovalRequest>;
+ project: { id: string; name: string; orgId: string };
+ policy: Awaited<ReturnType<typeof $findPolicyById>>;
+ requestedByUser: {
+ id: string;
+ firstName?: string | null;
+ lastName?: string | null;
+ username: string;
+ email?: string | null;
+ };
+ envId: string;
+ envSlug: string;
+ secretPath: string;
+ }) => {
+ const { requestedPermissions } = verifyRequestedPermissions({ permissions: request.permissions });
+ const cfg = getConfig();
+
+ await queueService.queue(
+ QueueName.SecretWebhook,
+ QueueJobs.SecWebhook,
+ {
+ type: WebhookEvents.AccessRequestModified,
+ payload: {
+ projectId: project.id,
+ projectName: project.name,
+ environment: envSlug,
+ environmentName: policy.environments.find((env) => env.id === envId)?.name,
+ secretPath,
+ action: AccessRequestWebhookAction.Created,
+ request: {
+ id: request.id,
+ url: `${cfg.SITE_URL}/organizations/${project.orgId}/projects/secret-management/${project.id}/approval?selectedTab=resource-requests&requestId=${request.id}`,
+ status: request.status,
+ isBypassed: false,
+ policy: {
+ id: policy.id,
+ name: policy.name,
+ enforcementLevel: policy.enforcementLevel,
+ hasSequencedApprovers: policy.approvers.some((approver) => (approver.sequence ?? 1) > 1)
+ },
+ requestedAccess: {
+ isTemporary: request.isTemporary,
+ temporaryRange: request.temporaryRange,
+ permissions: requestedPermissions
+ },
+ requestedBy: {
+ type: ActorType.USER,
+ id: requestedByUser.id,
+ name:
+ [requestedByUser.firstName, requestedByUser.lastName].filter(Boolean).join(" ") ||
+ requestedByUser.username,
+ email: requestedByUser.email ?? null
+ },
+ expiresAt: request.expiresAt?.toISOString() ?? null,
+ approvedAt: null,
+ revokedAt: null,
+ createdAt: request.createdAt.toISOString(),
+ updatedAt: request.updatedAt.toISOString()
+ }
+ }
+ },
+ {
+ jobId: `access-request-webhook-${request.id}-${alphaNumericNanoId(6)}`,
+ removeOnFail: { count: 5 },
+ removeOnComplete: true,
+ delay: 1000,
+ attempts: 5,
+ backoff: { type: "exponential", delay: 3000 }
+ }
+ );
+ };
+
+ const isGlobalAccessApprovalRequest = async (requestId: string) =>
+ Boolean(await approvalRequestDAL.findOne({ id: requestId, type: ApprovalPolicyType.SecretAccess }));
+
+ const createAccessApprovalRequest = async ({
+ policy: policyRef,
+ projectId,
+ envId,
+ envSlug,
+ secretPath,
+ requestedByUserId,
+ actorOrgId,
+ permissions,
+ isTemporary,
+ temporaryRange,
+ note
+ }: TCreateSecretAccessApprovalRequestDTO) => {
+ const policy = await $findPolicyById(
+ policyRef.id,
+ `No policy in environment with slug '${envSlug}' and with secret path '${secretPath}' was found.`
+ );
+
+ if (policy.maxTimePeriod) {
+ if (!temporaryRange || ms(temporaryRange) > ms(policy.maxTimePeriod)) {
+ throw new BadRequestError({
+ message: `Requested access time range is limited to ${policy.maxTimePeriod} by policy`
+ });
+ }
+ }
+
+ const [requestedByUser, project, policySteps] = await Promise.all([
+ userDAL.findById(requestedByUserId),
+ projectDAL.findById(projectId),
+ approvalPolicyDAL.findStepsByPolicyId(policy.id)
+ ]);
+ if (!requestedByUser) throw new ForbiddenRequestError({ message: "User not found" });
+ if (!project) throw new NotFoundError({ message: `Project with ID '${projectId}' not found` });
+ if (!policySteps.length) {
+ throw new BadRequestError({ message: `Policy '${policy.name}' has no approvers configured` });
+ }
+
+ const activeGrants = await secretAccessApprovalBridgeDAL.findActiveGrants({
+ projectId,
+ granteeUserId: requestedByUserId
+ });
+ const activeGrant = activeGrants.find((grant) =>
+ hasSameAccessCriteria(SecretAccessPolicyRequestDataSchema.safeParse(grant.attributes).data ?? null, {
+ permissions,
+ isTemporary
+ })
+ );
+ if (activeGrant) {
+ throw new BadRequestError({ message: "You already have an active privilege with the same criteria" });
+ }
+
+ const pendingRequests = await secretAccessApprovalBridgeDAL.findPendingRequests({
+ policyId: policy.id,
+ requesterId: requestedByUserId
});
+ const pendingDuplicate = pendingRequests.find((request) =>
+ hasSameAccessCriteria(parseSecretAccessRequestData(request.requestData), { permissions, isTemporary })
+ );
+ if (pendingDuplicate) {
+ throw new BadRequestError({ message: "You already have a pending access request with the same criteria" });
+ }
+
+ const parsedMs = policy.requestExpirationTime ? ms(policy.requestExpirationTime) : null;
+ const expiresAt = parsedMs && !Number.isNaN(parsedMs) ? new Date(Date.now() + parsedMs) : null;
+
+ const requestData: TSecretAccessRequestData = {
+ envId,
+ envSlug,
+ secretPath,
+ permissions,
+ isTemporary,
+ temporaryRange: temporaryRange || null
+ };
+
+ const created = await approvalRequestDAL.transaction((tx) =>
+ createApprovalRequestWithSteps(
+ {
+ projectId,
+ organizationId: actorOrgId,
+ policyId: policy.id,
+ policyType: ApprovalPolicyType.SecretAccess,
+ policySteps,
+ requestData,
+ justification: note || null,
+ expiresAt,
+ requesterUserId: requestedByUserId,
+ requesterName:
+ `${requestedByUser.firstName ?? ""} ${requestedByUser.lastName ?? ""}`.trim() || requestedByUser.username,
+ requesterEmail: requestedByUser.email || requestedByUser.username
+ },
+ { approvalRequestDAL, approvalRequestStepsDAL, approvalRequestStepEligibleApproversDAL },
+ tx
+ )
+ );
+
+ const request = await $findRequestById(created.id);
+ await notifySecretAccessStepApprovers(
+ { step: policySteps[0], request, project, requestedByUser, data: requestData },
+ {
+ userDAL,
+ userGroupMembershipDAL,
+ projectDAL,
+ projectSlackConfigDAL,
+ kmsService,
+ microsoftTeamsService,
+ projectMicrosoftTeamsConfigDAL,
+ notificationService,
+ smtpService
+ }
+ );
+
+ const legacyRequest = toLegacyAccessApprovalRequest(request);
+
+ try {
+ await $queueAccessRequestCreatedWebhook({
+ request: legacyRequest,
+ project,
+ policy,
+ requestedByUser,
+ envId,
+ envSlug,
+ secretPath
+ });
+ } catch (error) {
+ logger.error(
+ error,
+ `Failed to queue access request webhook [requestId=${request.id}] [action=${AccessRequestWebhookAction.Created}]`
+ );
+ }
+
+ return { request: legacyRequest, projectId };
+ };
+
+ const reviewAccessApprovalRequest = async ({
+ requestId,
+ status,
+ bypassReason,
+ actor,
+ actorId,
+ actorOrgId,
+ actorAuthMethod
+ }: TReviewSecretAccessApprovalRequestDTO) => {
+ if (bypassReason !== undefined) {
+ throw new BadRequestError({ message: "Break-glass approvals are not supported for this request yet" });
+ }
+
+ const request = await $findRequestById(requestId);
+ if (!request.policyId) {
+ throw new BadRequestError({ message: "The policy associated with this access request has been deleted." });
+ }
+ const policy = await $findPolicyById(
+ request.policyId,
+ "The policy associated with this access request has been deleted."
+ );
+ if (!request.requesterId) {
+ throw new NotFoundError({ message: "The user who created this access request no longer exists" });
+ }
+
+ const { memberships } = await permissionService.getProjectPermission({
+ actor,
+ actorId,
+ projectId: request.projectId,
+ actorAuthMethod,
+ actorOrgId,
+ actionProjectType: ActionProjectType.SecretManager
+ });
+
+ const activeRoles = flattenActiveRolesFromMemberships(memberships, ProjectMembershipRole.Custom);
+ const hasOnlyNoAccessRole =
+ activeRoles.length > 0 && activeRoles.every((r) => r.role === ProjectMembershipRole.NoAccess);
+ if (hasOnlyNoAccessRole) {
+ throw new ForbiddenRequestError({ message: "You are not authorized to review this request" });
+ }
+
+ if (request.status !== ApprovalRequestStatus.Pending) {
+ throw new BadRequestError({ message: "The request has been closed" });
+ }
+ if (request.expiresAt && new Date(request.expiresAt) < new Date()) {
+ await approvalRequestDAL.updateById(requestId, { status: ApprovalRequestStatus.Expired });
+ throw new BadRequestError({ message: "This access request has expired and can no longer be reviewed" });
+ }
+
+ const data = getSecretAccessRequestData(request);
+ if (data.isTemporary && !data.temporaryRange) {
+ throw new BadRequestError({ message: "Temporary range is required for temporary access" });
+ }
+
+ const isSelfReview = actorId === request.requesterId;
+ const isApproving = status === ApprovalStatus.APPROVED;
+ if (isSelfReview && isApproving && !policy.allowedSelfApprovals) {
+ throw new BadRequestError({
+ message: "Failed to review access approval request. Users are not authorized to review their own request."
+ });
+ }
+
+ const actorGroupIds = await $getActorGroupIds(actorId, actorOrgId);
+
+ const project = await projectDAL.findById(request.projectId);
+ if (!project) {
+ throw new NotFoundError({ message: "The project associated with this access request was not found." });
+ }
+
+ const { approval, nextStep } = await approvalRequestDAL.transaction(async (tx) => {
+ const locked = await approvalRequestDAL.findByIdForUpdate(requestId, tx);
+ if (!locked || locked.status !== ApprovalRequestStatus.Pending) {
+ throw new BadRequestError({ message: "The request has been closed" });
+ }
+
+ const steps = await approvalRequestStepsDAL.find({ requestId }, { tx, sort: [["stepNumber", "asc"]] });
+ const currentStepIndex = steps.findIndex((step) => step.stepNumber === locked.currentStep);
+ const currentStep = steps[currentStepIndex];
+ if (!currentStep) throw new BadRequestError({ message: "Current step not found" });
+
+ const eligibleApprovers = await approvalRequestStepEligibleApproversDAL.find({ stepId: currentStep.id }, { tx });
+ const stepApprovers = eligibleApprovers.map((approver) => ({
+ type: approver.userId ? ApproverType.User : ApproverType.Group,
+ id: (approver.userId || approver.groupId) as string
+ }));
+
+ const isSelfRejection = isSelfReview && !isApproving;
+ if (!isSelfRejection && !isPolicySubjectMatch(stepApprovers, actorId, actorGroupIds)) {
+ throw new BadRequestError({ message: "You are not a reviewer in this step" });
+ }
+
+ const stepApprovals = await approvalRequestApprovalsDAL.find({ stepId: currentStep.id }, { tx });
+ if (stepApprovals.some((a) => a.approverUserId === actorId)) {
+ throw new BadRequestError({ message: "You have already reviewed this request" });
+ }
+
+ const createdApproval = await approvalRequestApprovalsDAL.create(
+ {
+ stepId: currentStep.id,
+ approverUserId: actorId,
+ decision: isApproving ? ApprovalRequestApprovalDecision.Approved : ApprovalRequestApprovalDecision.Rejected
+ },
+ tx
+ );
+
+ if (!isApproving) {
+ await approvalRequestDAL.updateById(requestId, { status: ApprovalRequestStatus.Rejected }, tx);
+ return { approval: createdApproval, nextStep: null };
+ }
+
+ const approvedCount =
+ stepApprovals.filter((a) => a.decision === ApprovalRequestApprovalDecision.Approved).length + 1;
+ if (approvedCount < currentStep.requiredApprovals) {
+ return { approval: createdApproval, nextStep: null };
+ }
+
+ await approvalRequestStepsDAL.updateById(
+ currentStep.id,
+ { status: ApprovalRequestStepStatus.Completed, completedAt: new Date() },
+ tx
+ );
+
+ const upcomingStep = steps[currentStepIndex + 1];
+ if (upcomingStep) {
+ await approvalRequestDAL.updateById(requestId, { currentStep: locked.currentStep + 1 }, tx);
+ await approvalRequestStepsDAL.updateById(
+ upcomingStep.id,
+ { status: ApprovalRequestStepStatus.InProgress, startedAt: new Date() },
+ tx
+ );
+ const upcomingApprovers = await approvalRequestStepEligibleApproversDAL.find(
+ { stepId: upcomingStep.id },
+ { tx }
+ );
+ return {
+ approval: createdApproval,
+ nextStep: {
+ requiredApprovals: upcomingStep.requiredApprovals,
+ approvers: upcomingApprovers.map((approver) => ({
+ type: approver.userId ? ApproverType.User : ApproverType.Group,
+ id: (approver.userId || approver.groupId) as string
+ }))
+ }
+ };
+ }
+
+ await approvalRequestDAL.updateById(requestId, { status: ApprovalRequestStatus.Approved }, tx);
+
+ const startTime = new Date();
+ const endTime = data.isTemporary ? new Date(startTime.getTime() + ms(data.temporaryRange!)) : null;
+
+ const grant = await approvalRequestGrantsDAL.create(
+ {
+ projectId: request.projectId,
+ requestId: request.id,
+ granteeUserId: request.requesterId,
+ status: ApprovalRequestGrantStatus.Active,
+ type: ApprovalPolicyType.SecretAccess,
+ attributes: data,
+ expiresAt: endTime
+ },
+ tx
+ );
+
+ await additionalPrivilegeDAL.create(
+ {
+ actorUserId: request.requesterId,
+ projectId: request.projectId,
+ name: `requested-privilege-${slugify(alphaNumericNanoId(12))}`,
+ permissions: JSON.stringify(data.permissions),
+ grantId: grant.id,
+ ...(data.isTemporary && {
+ isTemporary: true,
+ temporaryMode: TemporaryPermissionMode.Relative,
+ temporaryRange: data.temporaryRange!,
+ temporaryAccessStartTime: startTime,
+ temporaryAccessEndTime: endTime
+ })
+ },
+ tx
+ );
+
+ return { approval: createdApproval, nextStep: null };
+ });
+
+ if (nextStep) {
+ const requestedByUser = await userDAL.findById(request.requesterId);
+ if (requestedByUser) {
+ await notifySecretAccessStepApprovers(
+ { step: nextStep, request, project, requestedByUser, data },
+ {
+ userDAL,
+ userGroupMembershipDAL,
+ projectDAL,
+ projectSlackConfigDAL,
+ kmsService,
+ microsoftTeamsService,
+ projectMicrosoftTeamsConfigDAL,
+ notificationService,
+ smtpService
+ }
+ );
+ }
+ }
+
+ const createdAt = approval.createdAt ?? new Date();
+ return {
+ id: approval.id,
+ requestId,
+ reviewerUserId: approval.approverUserId,
+ status: approval.decision,
+ createdAt,
+ updatedAt: createdAt,
+ projectId: request.projectId,
+ policyId: policy.id,
+ isBypass: false
+ };
+ };
+
+ const revokeAccessApprovalRequest = async ({
+ requestId,
+ actor,
+ actorId,
+ actorOrgId,
+ actorAuthMethod
+ }: TRevokeSecretAccessApprovalRequestDTO) => {
+ const request = await $findRequestById(requestId);
+ if (!request.requesterId) {
+ throw new NotFoundError({ message: "The user who created this access request no longer exists" });
+ }
+
+ const { permission } = await permissionService.getProjectPermission({
+ actor,
+ actorId,
+ projectId: request.projectId,
+ actorAuthMethod,
+ actorOrgId,
+ actionProjectType: ActionProjectType.SecretManager
+ });
+
+ const targetUser = await userDAL.findById(request.requesterId);
+ if (!targetUser) throw new NotFoundError({ message: "Target user not found" });
+
+ const memberSubject = subject(ProjectPermissionSub.Member, { userEmail: targetUser.email ?? undefined });
+ const canAssignAdditionalPrivileges = permission.can(
+ ProjectPermissionMemberActions.AssignAdditionalPrivileges,
+ memberSubject
+ );
+ const canGrantPrivilegesLegacy = permission.can(ProjectPermissionMemberActions.GrantPrivileges, memberSubject);
+
+ let isApprover = false;
+ if (!canAssignAdditionalPrivileges && !canGrantPrivilegesLegacy && request.policyId) {
+ const [policy] = await secretAccessApprovalBridgeDAL.findSecretAccessPolicies({ policyId: request.policyId });
+ if (policy) {
+ const actorGroupIds = await $getActorGroupIds(actorId, actorOrgId);
+ isApprover = isPolicySubjectMatch(policy.approvers, actorId, actorGroupIds);
+ }
+ }
+
+ if (!canAssignAdditionalPrivileges && !canGrantPrivilegesLegacy && !isApprover) {
+ throw new ForbiddenRequestError({
+ message: "You do not have permission to revoke additional privileges for this user"
+ });
+ }
+
+ const { grant } = request;
+ if (
+ request.status !== ApprovalRequestStatus.Approved ||
+ !grant ||
+ grant.status !== ApprovalRequestGrantStatus.Active
+ ) {
+ throw new BadRequestError({ message: "Only approved requests can be revoked" });
+ }
+
+ await approvalRequestDAL.transaction(async (tx) => {
+ const locked = await approvalRequestGrantsDAL.findByIdForUpdate(grant.id, tx);
+ if (!locked || locked.status !== ApprovalRequestGrantStatus.Active) {
+ throw new BadRequestError({ message: "Only approved requests can be revoked" });
+ }
+ await approvalRequestGrantsDAL.updateById(
+ grant.id,
+ { status: ApprovalRequestGrantStatus.Revoked, revokedAt: new Date(), revokedByUserId: actorId },
+ tx
+ );
+ await additionalPrivilegeDAL.delete({ grantId: grant.id }, tx);
+ });
+
+ const revoked = await $findRequestById(requestId);
+ return { request: toLegacyAccessApprovalRequest(revoked), projectId: request.projectId };
};
return {
@@ -554,6 +1206,11 @@ export const secretAccessApprovalBridgeServiceFactory = ({
getAccessApprovalPolicyById,
listAccessApprovalPolicies,
countAccessApprovalPolicies,
- createAccessApprovalRequest
+ isGlobalAccessApprovalRequest,
+ listAccessApprovalRequests,
+ countAccessApprovalRequests,
+ createAccessApprovalRequest,
+ reviewAccessApprovalRequest,
+ revokeAccessApprovalRequest
};
};
diff --git a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-types.ts b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-types.ts
index c86c032f22..eab32ab4f2 100644
--- a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-types.ts
+++ b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-types.ts
@@ -5,8 +5,15 @@ import {
TGetAccessApprovalPolicyByIdDTO,
TUpdateAccessApprovalPolicy
} from "@app/ee/services/access-approval-policy/access-approval-policy-types";
+import {
+ TReviewAccessRequestDTO,
+ TRevokeAccessRequestDTO
+} from "@app/ee/services/access-approval-request/access-approval-request-types";
import { TGroupDALFactory } from "@app/ee/services/group/group-dal";
+import { TUserGroupMembershipDALFactory } from "@app/ee/services/group/user-group-membership-dal";
import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service-types";
+import { TQueueServiceFactory } from "@app/queue";
+import { TAdditionalPrivilegeDALFactory } from "@app/services/additional-privilege/additional-privilege-dal";
import {
TApprovalPolicyBypassersDALFactory,
TApprovalPolicyDALFactory,
@@ -14,20 +21,37 @@ import {
TApprovalPolicyStepApproversDALFactory,
TApprovalPolicyStepsDALFactory
} from "@app/services/approval-policy/approval-policy-dal";
+import {
+ TApprovalRequestApprovalsDALFactory,
+ TApprovalRequestDALFactory,
+ TApprovalRequestGrantsDALFactory,
+ TApprovalRequestStepEligibleApproversDALFactory,
+ TApprovalRequestStepsDALFactory
+} from "@app/services/approval-policy/approval-request-dal";
+import { TKmsServiceFactory } from "@app/services/kms/kms-service";
+import { TMicrosoftTeamsServiceFactory } from "@app/services/microsoft-teams/microsoft-teams-service";
+import { TProjectMicrosoftTeamsConfigDALFactory } from "@app/services/microsoft-teams/project-microsoft-teams-config-dal";
+import { TNotificationServiceFactory } from "@app/services/notification/notification-service";
import { TProjectDALFactory } from "@app/services/project/project-dal";
import { TProjectEnvDALFactory } from "@app/services/project-env/project-env-dal";
+import { TProjectSlackConfigDALFactory } from "@app/services/slack/project-slack-config-dal";
+import { TSmtpService } from "@app/services/smtp/smtp-service";
import { TUserDALFactory } from "@app/services/user/user-dal";
import { TSecretAccessApprovalBridgeDALFactory } from "./secret-access-approval-bridge-dal";
export type TSecretAccessApprovalBridgeServiceFactoryDep = {
- projectDAL: Pick<TProjectDALFactory, "findProjectBySlug" | "findEffectiveProjectSubjectsMembership">;
+ projectDAL: Pick<TProjectDALFactory, "findProjectBySlug" | "findEffectiveProjectSubjectsMembership" | "findById">;
permissionService: Pick<TPermissionServiceFactory, "getProjectPermission">;
projectEnvDAL: Pick<TProjectEnvDALFactory, "find">;
- userDAL: Pick<TUserDALFactory, "find">;
+ userDAL: Pick<TUserDALFactory, "find" | "findById">;
groupDAL: Pick<TGroupDALFactory, "find">;
+ userGroupMembershipDAL: Pick<TUserGroupMembershipDALFactory, "find" | "findGroupMembershipsByUserIdInOrg">;
accessApprovalPolicyDAL: Pick<TAccessApprovalPolicyDALFactory, "findPolicyByEnvIdAndSecretPath">;
- approvalPolicyDAL: Pick<TApprovalPolicyDALFactory, "create" | "transaction" | "updateById" | "deleteById">;
+ approvalPolicyDAL: Pick<
+ TApprovalPolicyDALFactory,
+ "create" | "transaction" | "updateById" | "deleteById" | "findStepsByPolicyId"
+ >;
approvalPolicyStepsDAL: Pick<TApprovalPolicyStepsDALFactory, "insertMany" | "delete">;
approvalPolicyStepApproversDAL: Pick<TApprovalPolicyStepApproversDALFactory, "insertMany">;
approvalPolicyBypassersDAL: Pick<TApprovalPolicyBypassersDALFactory, "insertMany" | "delete">;
@@ -35,7 +59,36 @@ export type TSecretAccessApprovalBridgeServiceFactoryDep = {
TApprovalPolicySecretEnvironmentDALFactory,
"insertMany" | "delete" | "findPolicyByEnvIdsAndSecretPath"
>;
- secretAccessApprovalBridgeDAL: Pick<TSecretAccessApprovalBridgeDALFactory, "findSecretAccessPolicies">;
+ approvalRequestDAL: Pick<
+ TApprovalRequestDALFactory,
+ "create" | "transaction" | "findOne" | "findByIdForUpdate" | "updateById"
+ >;
+ approvalRequestStepsDAL: Pick<TApprovalRequestStepsDALFactory, "create" | "find" | "updateById">;
+ approvalRequestStepEligibleApproversDAL: Pick<TApprovalRequestStepEligibleApproversDALFactory, "create" | "find">;
+ approvalRequestApprovalsDAL: Pick<TApprovalRequestApprovalsDALFactory, "create" | "find">;
+ approvalRequestGrantsDAL: Pick<TApprovalRequestGrantsDALFactory, "create" | "updateById" | "findByIdForUpdate">;
+ additionalPrivilegeDAL: Pick<TAdditionalPrivilegeDALFactory, "create" | "delete">;
+ secretAccessApprovalBridgeDAL: Pick<
+ TSecretAccessApprovalBridgeDALFactory,
+ | "findSecretAccessPolicies"
+ | "findSecretAccessRequestById"
+ | "findSecretAccessRequests"
+ | "findActiveGrants"
+ | "findPendingRequests"
+ | "findGrantsByRequestIds"
+ | "findPrivilegesByGrantIds"
+ | "findApprovalsByRequestIds"
+ | "findGroupMembers"
+ | "findUsersByIds"
+ | "findOrgMembershipActivity"
+ >;
+ smtpService: Pick<TSmtpService, "sendMail">;
+ notificationService: Pick<TNotificationServiceFactory, "createUserNotifications">;
+ kmsService: Pick<TKmsServiceFactory, "createCipherPairWithDataKey">;
+ projectSlackConfigDAL: Pick<TProjectSlackConfigDALFactory, "getIntegrationDetailsByProject">;
+ microsoftTeamsService: Pick<TMicrosoftTeamsServiceFactory, "sendNotification">;
+ projectMicrosoftTeamsConfigDAL: Pick<TProjectMicrosoftTeamsConfigDALFactory, "getIntegrationDetailsByProject">;
+ queueService: Pick<TQueueServiceFactory, "queue">;
};
export type TCreateSecretAccessApprovalPolicyDTO = TCreateAccessApprovalPolicy;
@@ -53,8 +106,14 @@ export type TCreateSecretAccessApprovalRequestDTO = {
envSlug: string;
secretPath: string;
requestedByUserId: string;
+ actorOrgId: string;
permissions: unknown;
isTemporary: boolean;
temporaryRange?: string;
note?: string;
};
+
+export type TListSecretAccessApprovalRequestsDTO = { projectId: string };
+export type TCountSecretAccessApprovalRequestsDTO = { projectId: string; policyId?: string; requesterId?: string };
+export type TReviewSecretAccessApprovalRequestDTO = TReviewAccessRequestDTO;
+export type TRevokeSecretAccessApprovalRequestDTO = TRevokeAccessRequestDTO;