Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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-approvaimport { 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.tsindex 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(