Skip to content

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

keep the same behavior for when an access needs just one approval and has two possible approvers

adilson463347fab0f9
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 1435f30588..5c71c1bc7b 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
@@ -1,8 +1,9 @@
import { Knex } from "knex";
-import { TableName } from "@app/db/schemas";
+import { AccessScope, OrgMembershipRole, OrgMembershipStatus, ProjectMembershipRole, TableName } from "@app/db/schemas";
import { seedData1 } from "@app/db/seed-data";
import { ApproverType, BypasserType } from "@app/ee/services/access-approval-policy/access-approval-policy-types";
+import { alphaNumericNanoId } from "@app/lib/nanoid";
import { EnforcementLevel } from "@app/lib/types";
const getDb = () => (globalThis as unknown as { testDb: Knex }).testDb;
@@ -390,3 +391,126 @@ describe("Access approval policy routing", () => {
await expectNoLegacyRow(globalPolicy.id);
});
});
+
+const seedProjectMember = async () => {
+ const db = getDb();
+ const username = `policy-routing-approver-${alphaNumericNanoId(8)}@example.com`.toLowerCase();
+ const [user] = await db(TableName.Users)
+ .insert({ username, email: username, isGhost: false, isAccepted: true, authMethods: ["email"] })
+ .returning("*");
+
+ const [orgMembership] = await db(TableName.Membership)
+ .insert({
+ scope: AccessScope.Organization,
+ scopeOrgId: seedData1.organization.id,
+ actorUserId: user.id,
+ status: OrgMembershipStatus.Accepted,
+ isActive: true
+ })
+ .returning("*");
+ await db(TableName.MembershipRole).insert({ membershipId: orgMembership.id, role: OrgMembershipRole.Member });
+
+ const [projectMembership] = await db(TableName.Membership)
+ .insert({
+ scope: AccessScope.Project,
+ scopeOrgId: seedData1.organization.id,
+ scopeProjectId: seedData1.project.id,
+ actorUserId: user.id
+ })
+ .returning("*");
+ await db(TableName.MembershipRole).insert({ membershipId: projectMembership.id, role: ProjectMembershipRole.Member });
+
+ return user.id;
+};
+
+describe("Access approval policy required approvals per step", () => {
+ let otherApproverId: string;
+
+ beforeAll(async () => {
+ otherApproverId = await seedProjectMember();
+ });
+
+ afterEach(async () => {
+ const db = getDb();
+ const legacyIds = legacyPolicyIds.splice(0);
+ const globalIds = globalPolicyIds.splice(0);
+
+ if (legacyIds.length) {
+ await db(TableName.AccessApprovalPolicyApprover).whereIn("policyId", legacyIds).del();
+ await db(TableName.AccessApprovalPolicyBypasser).whereIn("policyId", legacyIds).del();
+ await db(TableName.AccessApprovalPolicyEnvironment).whereIn("policyId", legacyIds).del();
+ await db(TableName.AccessApprovalPolicy).whereIn("id", legacyIds).del();
+ }
+ if (globalIds.length) {
+ await db(TableName.ApprovalPolicies).whereIn("id", globalIds).del();
+ }
+ });
+
+ afterAll(async () => {
+ const db = getDb();
+ await db(TableName.Membership).where({ actorUserId: otherApproverId }).del();
+ await db(TableName.Users).where({ id: otherApproverId }).del();
+ });
+
+ const getStepRequirements = async (policyId: string) =>
+ (await getDb()(TableName.ApprovalPolicySteps).where({ policyId }).orderBy("stepNumber", "asc")).map(
+ (step) => step.requiredApprovals
+ );
+
+ test("Updating without approvalsRequired resets every step to one approval", async () => {
+ const policy = await createGlobalPolicy({ name: "policy-routing-required-reset", secretPath: "/required-reset" });
+ const approvers = [
+ { type: ApproverType.User, id: seedData1.id, sequence: 1 },
+ { type: ApproverType.User, id: otherApproverId, sequence: 1 }
+ ];
+
+ const withEntry = await patchPolicy(policy.id, {
+ approvers,
+ approvals: 2,
+ approvalsRequired: [{ stepNumber: 1, numberOfApprovals: 2 }]
+ });
+ expect(withEntry.statusCode).toBe(200);
+ expect(await getStepRequirements(policy.id)).toEqual([2]);
+
+ const withoutEntry = await patchPolicy(policy.id, { approvers, approvals: 2 });
+ expect(withoutEntry.statusCode).toBe(200);
+ expect(await getStepRequirements(policy.id)).toEqual([1]);
+
+ const getRes = await getPolicy(policy.id);
+ expect(getRes.statusCode).toBe(200);
+ expect(
+ getRes.json().approval.approvers.map((approver: { approvalsRequired: number }) => approver.approvalsRequired)
+ ).toEqual([1, 1]);
+ });
+
+ test("The same update stores the same effective requirement on legacy and global", async () => {
+ const db = getDb();
+ const legacyPolicy = await createLegacyPolicy({
+ name: "policy-routing-required-legacy",
+ secretPath: "/required-parity-legacy"
+ });
+ const globalPolicy = await createGlobalPolicy({
+ name: "policy-routing-required-global",
+ secretPath: "/required-parity-global"
+ });
+ const body = {
+ approvers: [
+ { type: ApproverType.User, id: seedData1.id, sequence: 1 },
+ { type: ApproverType.User, id: otherApproverId, sequence: 2 }
+ ],
+ approvals: 2,
+ approvalsRequired: [{ stepNumber: 1, numberOfApprovals: 1 }]
+ };
+
+ expect((await patchPolicy(legacyPolicy.id, body)).statusCode).toBe(200);
+ expect((await patchPolicy(globalPolicy.id, body)).statusCode).toBe(200);
+
+ const legacyApprovers = await db(TableName.AccessApprovalPolicyApprover)
+ .where({ policyId: legacyPolicy.id })
+ .orderBy("sequence", "asc");
+ const legacyEffective = legacyApprovers.map((approver) => approver.approvalsRequired || 1);
+
+ expect(legacyEffective).toEqual([1, 1]);
+ expect(await getStepRequirements(globalPolicy.id)).toEqual(legacyEffective);
+ });
+});
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
index 20d7b023d5..63e5451625 100644
--- 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
@@ -1,8 +1,13 @@
+import jwt from "jsonwebtoken";
import { Knex } from "knex";
-import { TableName } from "@app/db/schemas";
+import { AccessScope, OrgMembershipRole, OrgMembershipStatus, ProjectMembershipRole, 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";
+import { getConfig, initEnvConfig } from "@app/lib/config/env";
+import { initLogger, logger } from "@app/lib/logger";
+import { alphaNumericNanoId } from "@app/lib/nanoid";
+import { AuthMethod, AuthTokenType } from "@app/services/auth/auth-type";
const getDb = () => (globalThis as unknown as { testDb: Knex }).testDb;
@@ -276,3 +281,327 @@ describe("Access approval request lifecycle on the global system", () => {
expect(bypassRes.json().message).toBe("Break-glass approvals are not supported for this request yet");
});
});
+
+type TApprover = { userId: string; token: string };
+
+const createApproverUser = async (): Promise<TApprover> => {
+ const db = getDb();
+ const username = `access-approver-${alphaNumericNanoId(8)}@example.com`.toLowerCase();
+ const [user] = await db(TableName.Users)
+ .insert({ username, email: username, isGhost: false, isAccepted: true, authMethods: [AuthMethod.EMAIL] })
+ .returning("*");
+
+ const [orgMembership] = await db(TableName.Membership)
+ .insert({
+ scope: AccessScope.Organization,
+ scopeOrgId: seedData1.organization.id,
+ actorUserId: user.id,
+ status: OrgMembershipStatus.Accepted,
+ isActive: true
+ })
+ .returning("*");
+ await db(TableName.MembershipRole).insert({ membershipId: orgMembership.id, role: OrgMembershipRole.Member });
+
+ const [projectMembership] = await db(TableName.Membership)
+ .insert({
+ scope: AccessScope.Project,
+ scopeOrgId: seedData1.organization.id,
+ scopeProjectId: seedData1.project.id,
+ actorUserId: user.id
+ })
+ .returning("*");
+ await db(TableName.MembershipRole).insert({
+ membershipId: projectMembership.id,
+ role: ProjectMembershipRole.Member
+ });
+
+ const [session] = await db(TableName.AuthTokenSession)
+ .insert({
+ userId: user.id,
+ ip: "127.0.0.1",
+ userAgent: "e2e-access-approval-required-approvals",
+ accessVersion: 1,
+ refreshVersion: 1,
+ lastUsed: new Date()
+ } as never)
+ .returning("*");
+
+ return {
+ userId: user.id,
+ token: jwt.sign(
+ {
+ authTokenType: AuthTokenType.ACCESS_TOKEN,
+ userId: user.id,
+ tokenVersionId: session.id,
+ authMethod: AuthMethod.EMAIL,
+ organizationId: seedData1.organization.id,
+ accessVersion: 1
+ },
+ getConfig().AUTH_SECRET,
+ { expiresIn: 3600 }
+ )
+ };
+};
+
+const reviewAs = (approver: TApprover, requestId: string) =>
+ testServer.inject({
+ method: "POST",
+ url: `/api/v1/access-approvals/requests/${requestId}/review`,
+ headers: { authorization: `Bearer ${approver.token}` },
+ body: { status: "approved" }
+ });
+
+const createPolicyWithApprovers = async (body: {
+ secretPath: string;
+ approvers: { type: ApproverType; id: string; sequence?: number }[];
+ approvals: number;
+ approvalsRequired?: { stepNumber: number; numberOfApprovals: number }[];
+}) => {
+ 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: `required-${body.secretPath.slice(1)}`,
+ allowedSelfApprovals: false,
+ ...body
+ }
+ });
+ expect(res.statusCode).toBe(200);
+ const { approval } = res.json();
+ globalPolicyIds.push(approval.id);
+ return approval as { id: string };
+};
+
+const getPolicySteps = (policyId: string) =>
+ getDb()(TableName.ApprovalPolicySteps).where({ policyId }).orderBy("stepNumber", "asc");
+
+const getRequestState = async (requestId: string) => {
+ const db = getDb();
+ const request = await db(TableName.ApprovalRequests).where({ id: requestId }).first();
+ const grant = await db(TableName.ApprovalRequestGrants).where({ requestId }).first();
+ const privilege = grant ? await db(TableName.AdditionalPrivilege).where({ grantId: grant.id }).first() : undefined;
+ return { status: request?.status, currentStep: request?.currentStep, grant, privilege };
+};
+
+const openRequest = async (secretPath: string) => {
+ const res = await createAccessRequest(secretPath);
+ expect(res.statusCode).toBe(200);
+ return res.json().approval.id as string;
+};
+
+describe("Per-step required approvals on the global system", () => {
+ const approvers: TApprover[] = [];
+ const groupIds: string[] = [];
+ let a: TApprover;
+ let b: TApprover;
+ let c: TApprover;
+
+ beforeAll(async () => {
+ initLogger();
+ await initEnvConfig(testHsmService, testKmsRootConfigDAL, testSuperAdminDAL, logger);
+ a = await createApproverUser();
+ b = await createApproverUser();
+ c = await createApproverUser();
+ approvers.push(a, b, c);
+ });
+
+ 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();
+ }
+ });
+
+ afterAll(async () => {
+ const db = getDb();
+ const userIds = approvers.map((approver) => approver.userId);
+ await db(TableName.UserGroupMembership).whereIn("userId", userIds).del();
+ if (groupIds.length) {
+ await db(TableName.Membership).whereIn("actorGroupId", groupIds).del();
+ await db(TableName.Groups).whereIn("id", groupIds).del();
+ }
+ await db(TableName.AuthTokenSession).whereIn("userId", userIds).del();
+ await db(TableName.Membership).whereIn("actorUserId", userIds).del();
+ await db(TableName.Users).whereIn("id", userIds).del();
+ });
+
+ test("Two of three approvers complete a step that needs two approvals", async () => {
+ const secretPath = "/required-two-of-three";
+ const policy = await createPolicyWithApprovers({
+ secretPath,
+ approvers: [a, b, c].map((approver) => ({ type: ApproverType.User, id: approver.userId })),
+ approvals: 1,
+ approvalsRequired: [{ stepNumber: 1, numberOfApprovals: 2 }]
+ });
+
+ const steps = await getPolicySteps(policy.id);
+ expect(steps.map((step) => step.requiredApprovals)).toEqual([2]);
+
+ const requestId = await openRequest(secretPath);
+
+ expect((await reviewAs(a, requestId)).statusCode).toBe(200);
+ const afterFirst = await getRequestState(requestId);
+ expect(afterFirst.status).toBe("pending");
+ expect(afterFirst.grant).toBeUndefined();
+
+ expect((await reviewAs(b, requestId)).statusCode).toBe(200);
+ const afterSecond = await getRequestState(requestId);
+ expect(afterSecond.status).toBe("approved");
+ expect(afterSecond.grant?.status).toBe("active");
+ expect(afterSecond.privilege?.actorUserId).toBe(seedData1.id);
+
+ const lateReview = await reviewAs(c, requestId);
+ expect(lateReview.statusCode).toBe(400);
+ expect(lateReview.json().message).toBe("The request has been closed");
+ });
+
+ test("With two approvers and one required approval, the first approval approves the request", async () => {
+ const secretPath = "/required-one-of-two";
+ const policy = await createPolicyWithApprovers({
+ secretPath,
+ approvers: [a, b].map((approver) => ({ type: ApproverType.User, id: approver.userId })),
+ approvals: 1,
+ approvalsRequired: [{ stepNumber: 1, numberOfApprovals: 1 }]
+ });
+
+ const steps = await getPolicySteps(policy.id);
+ expect(steps.map((step) => step.requiredApprovals)).toEqual([1]);
+
+ const requestId = await openRequest(secretPath);
+
+ expect((await reviewAs(b, requestId)).statusCode).toBe(200);
+ const state = await getRequestState(requestId);
+ expect(state.status).toBe("approved");
+ expect(state.grant?.status).toBe("active");
+ expect(state.privilege?.actorUserId).toBe(seedData1.id);
+
+ const secondReview = await reviewAs(a, requestId);
+ expect(secondReview.statusCode).toBe(400);
+ expect(secondReview.json().message).toBe("The request has been closed");
+ });
+
+ test("A step with no approvalsRequired entry needs one approval, whatever approvals says", async () => {
+ const secretPath = "/required-default-one";
+ const policy = await createPolicyWithApprovers({
+ secretPath,
+ approvers: [{ type: ApproverType.User, id: a.userId }],
+ approvals: 3
+ });
+
+ const steps = await getPolicySteps(policy.id);
+ expect(steps.map((step) => step.requiredApprovals)).toEqual([1]);
+
+ const requestId = await openRequest(secretPath);
+ expect((await reviewAs(a, requestId)).statusCode).toBe(200);
+
+ const state = await getRequestState(requestId);
+ expect(state.status).toBe("approved");
+ expect(state.privilege).toBeDefined();
+ });
+
+ test("The second step starts only after the first and needs its own two approvals", async () => {
+ const secretPath = "/required-two-steps";
+ const policy = await createPolicyWithApprovers({
+ secretPath,
+ approvers: [
+ { type: ApproverType.User, id: a.userId, sequence: 1 },
+ { type: ApproverType.User, id: b.userId, sequence: 2 },
+ { type: ApproverType.User, id: c.userId, sequence: 2 }
+ ],
+ approvals: 1,
+ approvalsRequired: [
+ { stepNumber: 1, numberOfApprovals: 1 },
+ { stepNumber: 2, numberOfApprovals: 2 }
+ ]
+ });
+
+ const steps = await getPolicySteps(policy.id);
+ expect(steps.map((step) => step.requiredApprovals)).toEqual([1, 2]);
+
+ const requestId = await openRequest(secretPath);
+
+ const early = await reviewAs(b, requestId);
+ expect(early.statusCode).toBe(400);
+ expect(early.json().message).toBe("You are not a reviewer in this step");
+
+ expect((await reviewAs(a, requestId)).statusCode).toBe(200);
+ const afterStepOne = await getRequestState(requestId);
+ expect(afterStepOne.status).toBe("pending");
+ expect(afterStepOne.currentStep).toBe(2);
+
+ expect((await reviewAs(b, requestId)).statusCode).toBe(200);
+ const afterOneOfTwo = await getRequestState(requestId);
+ expect(afterOneOfTwo.status).toBe("pending");
+ expect(afterOneOfTwo.grant).toBeUndefined();
+
+ expect((await reviewAs(c, requestId)).statusCode).toBe(200);
+ const approved = await getRequestState(requestId);
+ expect(approved.status).toBe("approved");
+ expect(approved.privilege).toBeDefined();
+ });
+
+ test("Each approving group member counts as one approval", async () => {
+ const db = getDb();
+ const secretPath = "/required-group";
+ const slug = `required-group-${alphaNumericNanoId(6).toLowerCase()}`;
+ const [group] = await db(TableName.Groups)
+ .insert({ orgId: seedData1.organization.id, name: slug, slug })
+ .returning("*");
+ groupIds.push(group.id);
+ await db(TableName.UserGroupMembership).insert([
+ { userId: a.userId, groupId: group.id, isPending: false },
+ { userId: b.userId, groupId: group.id, isPending: false }
+ ]);
+ const [groupOrgMembership, groupProjectMembership] = await db(TableName.Membership)
+ .insert([
+ {
+ actorGroupId: group.id,
+ scope: AccessScope.Organization,
+ scopeOrgId: seedData1.organization.id,
+ isActive: true
+ },
+ {
+ actorGroupId: group.id,
+ scope: AccessScope.Project,
+ scopeOrgId: seedData1.organization.id,
+ scopeProjectId: seedData1.project.id,
+ isActive: true
+ }
+ ])
+ .returning("*");
+ await db(TableName.MembershipRole).insert([
+ { membershipId: groupOrgMembership.id, role: OrgMembershipRole.Member },
+ { membershipId: groupProjectMembership.id, role: ProjectMembershipRole.Member }
+ ]);
+
+ await createPolicyWithApprovers({
+ secretPath,
+ approvers: [{ type: ApproverType.Group, id: group.id }],
+ approvals: 1,
+ approvalsRequired: [{ stepNumber: 1, numberOfApprovals: 2 }]
+ });
+
+ const requestId = await openRequest(secretPath);
+
+ expect((await reviewAs(a, requestId)).statusCode).toBe(200);
+ expect((await getRequestState(requestId)).status).toBe("pending");
+
+ expect((await reviewAs(b, requestId)).statusCode).toBe(200);
+ const state = await getRequestState(requestId);
+ expect(state.status).toBe("approved");
+ expect(state.privilege).toBeDefined();
+ });
+});
diff --git a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-fns.test.ts b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-fns.test.ts
new file mode 100644
index 0000000000..1cf042b6ca
--- /dev/null
+++ b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-fns.test.ts
@@ -0,0 +1,90 @@
+import { describe, expect, test } from "vitest";
+
+import { buildSecretAccessPolicySteps } from "./secret-access-approval-bridge-fns";
+
+type TApprovalsRequired = { numberOfApprovals: number; stepNumber: number }[];
+
+const user = (id: string, sequence = 1) => ({ type: "user", id, sequence });
+const group = (id: string, sequence = 1) => ({ type: "group", id, sequence });
+
+// Mirrors the legacy path: the approver row stores the step's numberOfApprovals (null when the step has no
+// entry), and review reads it as `approvalsRequired || 1`.
+const legacyRequiredApprovals = (sequence: number, approvalsRequired?: TApprovalsRequired) =>
+ approvalsRequired?.find((el) => el.stepNumber === sequence)?.numberOfApprovals || 1;
+
+describe("buildSecretAccessPolicySteps", () => {
+ test("uses the step's numberOfApprovals when present", () => {
+ const steps = buildSecretAccessPolicySteps(
+ [user("a"), user("b"), user("c")],
+ [{ stepNumber: 1, numberOfApprovals: 2 }]
+ );
+
+ expect(steps).toHaveLength(1);
+ expect(steps[0].requiredApprovals).toBe(2);
+ expect(steps[0].approvers.map((el) => el.id)).toEqual(["a", "b", "c"]);
+ });
+
+ test("a step with no approvalsRequired entry needs one approval", () => {
+ const steps = buildSecretAccessPolicySteps([user("a"), user("b"), user("c")]);
+
+ expect(steps).toEqual([expect.objectContaining({ requiredApprovals: 1 })]);
+ });
+
+ test("returns steps in sequence order with their own requirement", () => {
+ const steps = buildSecretAccessPolicySteps(
+ [user("b", 2), user("c", 2), user("a", 1)],
+ [
+ { stepNumber: 2, numberOfApprovals: 2 },
+ { stepNumber: 1, numberOfApprovals: 1 }
+ ]
+ );
+
+ expect(steps.map((step) => step.requiredApprovals)).toEqual([1, 2]);
+ expect(steps[0].approvers.map((el) => el.id)).toEqual(["a"]);
+ expect(steps[1].approvers.map((el) => el.id)).toEqual(["b", "c"]);
+ });
+
+ test("user and group approvers in the same sequence share one step", () => {
+ const steps = buildSecretAccessPolicySteps([user("a"), group("g")], [{ stepNumber: 1, numberOfApprovals: 2 }]);
+
+ expect(steps).toHaveLength(1);
+ expect(steps[0].approvers).toEqual([user("a"), group("g")]);
+ expect(steps[0].requiredApprovals).toBe(2);
+ });
+
+ test.each([
+ { name: "single step, no entries", approvers: [user("a"), user("b")], approvalsRequired: undefined },
+ {
+ name: "single step with an entry",
+ approvers: [user("a"), user("b"), user("c")],
+ approvalsRequired: [{ stepNumber: 1, numberOfApprovals: 2 }]
+ },
+ {
+ name: "two steps, entry only for the first",
+ approvers: [user("a", 1), user("b", 2), user("c", 2)],
+ approvalsRequired: [{ stepNumber: 1, numberOfApprovals: 1 }]
+ },
+ {
+ name: "two steps, entry only for the second",
+ approvers: [user("a", 1), group("g", 2)],
+ approvalsRequired: [{ stepNumber: 2, numberOfApprovals: 3 }]
+ },
+ {
+ name: "zero numberOfApprovals",
+ approvers: [user("a"), user("b")],
+ approvalsRequired: [{ stepNumber: 1, numberOfApprovals: 0 }]
+ },
+ {
+ name: "entry for a step that has no approvers",
+ approvers: [user("a", 1)],
+ approvalsRequired: [{ stepNumber: 2, numberOfApprovals: 2 }]
+ }
+ ])("matches the legacy effective requirement: $name", ({ approvers, approvalsRequired }) => {
+ const steps = buildSecretAccessPolicySteps(approvers, approvalsRequired);
+ const sequences = [...new Set(approvers.map((el) => el.sequence))].sort((a, b) => a - b);
+
+ expect(steps.map((step) => step.requiredApprovals)).toEqual(
+ sequences.map((sequence) => legacyRequiredApprovals(sequence, approvalsRequired))
+ );
+ });
+});
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 57e5101565..3f01ee79d5 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
@@ -6,6 +6,7 @@ import { TAccessApprovalPolicyDALFactory } from "@app/ee/services/access-approva
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 { groupBy } from "@app/lib/fn";
import { logger } from "@app/lib/logger";
import { ms } from "@app/lib/ms";
import { triggerWorkflowIntegrationNotification } from "@app/lib/workflow-integrations/trigger-notification";
@@ -81,6 +82,23 @@ export const secretAccessApprovalPolicyExists = async (
return Boolean(policy);
};
+// Legacy stores null on approver rows for a step with no approvalsRequired entry and reviews it as 1,
+// so the top-level `approvals` must not leak into a step's requirement.
+export const buildSecretAccessPolicySteps = <T extends { sequence: number }>(
+ approvers: T[],
+ approvalsRequired?: { numberOfApprovals: number; stepNumber: number }[]
+) => {
+ const approvalsRequiredByStepNumber = groupBy(approvalsRequired || [], (i) => i.stepNumber);
+ const approversBySequence = groupBy(approvers, (el) => el.sequence);
+ return Object.keys(approversBySequence)
+ .map(Number)
+ .sort((a, b) => a - b)
+ .map((sequence) => ({
+ requiredApprovals: approvalsRequiredByStepNumber[sequence]?.[0]?.numberOfApprovals || 1,
+ approvers: approversBySequence[sequence]
+ }));
+};
+
export type TSecretAccessRequestRow = TApprovalRequests & {
grant: TApprovalRequestGrants | null;
privilegeId: string | null;
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 434fe8d1df..578edb9471 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
@@ -38,6 +38,7 @@ import { ActorType } from "@app/services/auth/auth-type";
import { AccessRequestWebhookAction, WebhookEvents } from "@app/services/webhook/webhook-types";
import {
+ buildSecretAccessPolicySteps,
collectSecretAccessPolicyGroupIds,
collectSecretAccessRequestUserIds,
composeSecretAccessRequestRows,
@@ -234,30 +235,19 @@ export const secretAccessApprovalBridgeServiceFactory = ({
const $buildSteps = ({
approverUserIds,
groupApprovers,
- approvals,
approvalsRequired
}: {
approverUserIds: TSequencedSubject[];
groupApprovers: TSequencedSubject[];
- approvals: number;
approvalsRequired?: { numberOfApprovals: number; stepNumber: number }[];
- }): TPolicyStep[] => {
- const approvalsRequiredGroupByStepNumber = groupBy(approvalsRequired || [], (i) => i.stepNumber);
- const stepApproversBySequence = groupBy(
+ }): TPolicyStep[] =>
+ buildSecretAccessPolicySteps(
[
...approverUserIds.map((el) => ({ type: ApproverType.User, id: el.id, sequence: el.sequence ?? 1 })),
...groupApprovers.map((el) => ({ type: ApproverType.Group, id: el.id, sequence: el.sequence ?? 1 }))
],
- (el) => el.sequence
+ approvalsRequired
);
- return Object.keys(stepApproversBySequence)
- .map(Number)
- .sort((a, b) => a - b)
- .map((sequence) => ({
- requiredApprovals: approvalsRequiredGroupByStepNumber?.[sequence]?.[0]?.numberOfApprovals ?? approvals,
- approvers: stepApproversBySequence[sequence]
- }));
- };
const $insertStepsAndBypassers = async (
{
@@ -386,7 +376,7 @@ export const secretAccessApprovalBridgeServiceFactory = ({
const scope = { projectId: project.id, orgId: project.orgId };
const { approverUserIds, groupApprovers } = await $resolveApprovers(approvers, scope);
const { bypasserUserIds, groupBypassers } = await $resolveBypassers(bypassers, scope);
- const steps = $buildSteps({ approverUserIds, groupApprovers, approvals, approvalsRequired });
+ const steps = $buildSteps({ approverUserIds, groupApprovers, approvalsRequired });
const policy = await approvalPolicyDAL.transaction(async (tx) => {
const doc = await approvalPolicyDAL.create(
@@ -501,7 +491,7 @@ export const secretAccessApprovalBridgeServiceFactory = ({
const scope = { projectId: policy.projectId, orgId: actorOrgId };
const { approverUserIds, groupApprovers } = await $resolveApprovers(approvers, scope);
const { bypasserUserIds, groupBypassers } = await $resolveBypassers(bypassers, scope);
- const steps = $buildSteps({ approverUserIds, groupApprovers, approvals: currentApprovals, approvalsRequired });
+ const steps = $buildSteps({ approverUserIds, groupApprovers, approvalsRequired });
return approvalPolicyDAL.transaction(async (tx) => {
await approvalPolicyDAL.updateById(