Skip to content

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

fix step approvals to keep same behavior

adilson2e212ae1a836
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 5c71c1bc7b..83aec777bc 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
@@ -483,6 +483,120 @@ describe("Access approval policy required approvals per step", () => {
).toEqual([1, 1]);
});
+ const createPolicyRaw = (body: Record<string, unknown>) =>
+ testServer.inject({
+ method: "POST",
+ url: "/api/v1/access-approvals/policies",
+ headers: authHeaders(),
+ body: {
+ projectSlug: seedData1.project.slug,
+ environment: seedData1.environment.slug,
+ approvals: 1,
+ ...body
+ }
+ });
+
+ const approverViews = (approvers: { id: string; sequence: number; approvalsRequired: number }[]) =>
+ approvers
+ .map(({ id, sequence, approvalsRequired }) => ({ id, sequence, approvalsRequired }))
+ .sort((a, b) => a.sequence - b.sequence || a.id.localeCompare(b.id));
+
+ test("A user who approves in two steps is returned once per step", async () => {
+ const res = await createPolicyRaw({
+ name: "policy-routing-user-in-two-steps",
+ secretPath: "/user-in-two-steps",
+ approvers: [
+ { type: ApproverType.User, id: seedData1.id, sequence: 1 },
+ { type: ApproverType.User, id: otherApproverId, sequence: 1 },
+ { type: ApproverType.User, id: otherApproverId, sequence: 2 }
+ ],
+ approvalsRequired: [
+ { stepNumber: 1, numberOfApprovals: 2 },
+ { stepNumber: 2, numberOfApprovals: 1 }
+ ]
+ });
+ expect(res.statusCode).toBe(200);
+ const policyId = res.json().approval.id as string;
+ globalPolicyIds.push(policyId);
+
+ expect(await getStepRequirements(policyId)).toEqual([2, 1]);
+
+ const getRes = await getPolicy(policyId);
+ expect(getRes.statusCode).toBe(200);
+ expect(approverViews(getRes.json().approval.approvers)).toEqual(
+ approverViews([
+ { id: seedData1.id, sequence: 1, approvalsRequired: 2 },
+ { id: otherApproverId, sequence: 1, approvalsRequired: 2 },
+ { id: otherApproverId, sequence: 2, approvalsRequired: 1 }
+ ])
+ );
+ });
+
+ test("Creating a step that requires more approvals than it has approvers is rejected", async () => {
+ const name = "policy-routing-step-too-small";
+ const res = await createPolicyRaw({
+ name,
+ secretPath: "/step-too-small",
+ approvers: [
+ { type: ApproverType.User, id: seedData1.id, sequence: 1 },
+ { type: ApproverType.User, id: otherApproverId, sequence: 2 }
+ ],
+ approvalsRequired: [
+ { stepNumber: 1, numberOfApprovals: 1 },
+ { stepNumber: 2, numberOfApprovals: 2 }
+ ]
+ });
+
+ expect(res.statusCode).toBe(400);
+ expect(res.json().message).toContain("Step 2 requires 2 approvals but only has 1 approver");
+ expect(await getDb()(TableName.ApprovalPolicies).where({ name }).first()).toBeUndefined();
+ });
+
+ test("Updating a policy into a step with too few approvers is rejected and leaves it untouched", async () => {
+ const policy = await createGlobalPolicy({ name: "policy-routing-step-too-small-update", secretPath: "/too-small" });
+
+ const res = await patchPolicy(policy.id, {
+ approvers: [{ type: ApproverType.User, id: seedData1.id, sequence: 1 }],
+ approvals: 2,
+ approvalsRequired: [{ stepNumber: 1, numberOfApprovals: 2 }]
+ });
+
+ expect(res.statusCode).toBe(400);
+ expect(res.json().message).toContain("Step 1 requires 2 approvals but only has 1 approver");
+ expect(await getStepRequirements(policy.id)).toEqual([1]);
+ });
+
+ test("A legacy policy also returns a user once per step", async () => {
+ const legacyPolicy = await createLegacyPolicy({
+ name: "policy-routing-legacy-user-in-two-steps",
+ secretPath: "/legacy-user-in-two-steps"
+ });
+
+ const res = await patchPolicy(legacyPolicy.id, {
+ approvers: [
+ { type: ApproverType.User, id: seedData1.id, sequence: 1 },
+ { type: ApproverType.User, id: otherApproverId, sequence: 1 },
+ { type: ApproverType.User, id: otherApproverId, sequence: 2 }
+ ],
+ approvals: 2,
+ approvalsRequired: [
+ { stepNumber: 1, numberOfApprovals: 2 },
+ { stepNumber: 2, numberOfApprovals: 1 }
+ ]
+ });
+ expect(res.statusCode).toBe(200);
+
+ const getRes = await getPolicy(legacyPolicy.id);
+ expect(getRes.statusCode).toBe(200);
+ expect(approverViews(getRes.json().approval.approvers)).toEqual(
+ approverViews([
+ { id: seedData1.id, sequence: 1, approvalsRequired: 2 },
+ { id: otherApproverId, sequence: 1, approvalsRequired: 2 },
+ { id: otherApproverId, sequence: 2, approvalsRequired: 1 }
+ ])
+ );
+ });
+
test("The same update stores the same effective requirement on legacy and global", async () => {
const db = getDb();
const legacyPolicy = await createLegacyPolicy({
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 331c6afbe6..fd49f4dcea 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
@@ -372,6 +372,35 @@ describe("Access approval request lifecycle on the global system", () => {
const rejectRes = await reviewAccessRequest(requestId, { status: "rejected" });
expect(rejectRes.statusCode).toBe(200);
});
+
+ test("An expired request cannot be approved or rejected and is marked expired", async () => {
+ const db = getDb();
+ const secretPath = "/lifecycle-expired";
+ await createGlobalPolicy({ name: "lifecycle-expired", secretPath }, { requestExpirationTime: "1h" });
+
+ const createRes = await createAccessRequest(secretPath);
+ expect(createRes.statusCode).toBe(200);
+ const requestId = createRes.json().approval.id as string;
+ const created = await db(TableName.ApprovalRequests).where({ id: requestId }).first();
+ expect(created?.expiresAt).toBeTruthy();
+
+ await db(TableName.ApprovalRequests)
+ .where({ id: requestId })
+ .update({ expiresAt: new Date(Date.now() - 60_000) });
+
+ const approveRes = await reviewAccessRequest(requestId, { status: "approved" });
+ expect(approveRes.statusCode).toBe(400);
+ expect(approveRes.json().message).toBe("This access request has expired and can no longer be reviewed");
+
+ const request = await db(TableName.ApprovalRequests).where({ id: requestId }).first();
+ expect(request?.status).toBe("expired");
+ const grants = await db(TableName.ApprovalRequestGrants).where({ requestId });
+ expect(grants).toHaveLength(0);
+
+ const rejectRes = await reviewAccessRequest(requestId, { status: "rejected" });
+ expect(rejectRes.statusCode).toBe(400);
+ expect(rejectRes.json().message).toBe("The request has been closed");
+ });
});
type TApprover = { userId: string; token: string };
diff --git a/backend/src/ee/services/access-approval-policy/access-approval-policy-dal.ts b/backend/src/ee/services/access-approval-policy/access-approval-policy-dal.ts
index c44ad8b739..daeec2c9a0 100644
--- a/backend/src/ee/services/access-approval-policy/access-approval-policy-dal.ts
+++ b/backend/src/ee/services/access-approval-policy/access-approval-policy-dal.ts
@@ -433,6 +433,7 @@ export const accessApprovalPolicyDALFactory = (db: TDbClient): TAccessApprovalPo
)
.select(tx.ref("username").withSchema(TableName.Users).as("approverUsername"))
.select(tx.ref("username").withSchema("bypasserUsers").as("bypasserUsername"))
+ .select(tx.ref("id").withSchema(TableName.AccessApprovalPolicyApprover).as("approverRowId"))
.select(tx.ref("approverUserId").withSchema(TableName.AccessApprovalPolicyApprover))
.select(tx.ref("approverGroupId").withSchema(TableName.AccessApprovalPolicyApprover))
.select(tx.ref("sequence").withSchema(TableName.AccessApprovalPolicyApprover).as("approverSequence"))
@@ -467,24 +468,12 @@ export const accessApprovalPolicyDALFactory = (db: TDbClient): TAccessApprovalPo
}),
childrenMapper: [
{
- key: "approverUserId",
+ key: "approverRowId",
label: "approvers" as const,
- mapper: ({ approverUserId: id, approverSequence, approvalsRequired }) => ({
- id,
- type: "user",
- sequence: approverSequence,
- approvalsRequired
- })
- },
- {
- key: "approverGroupId",
- label: "approvers" as const,
- mapper: ({ approverGroupId: id, approverSequence, approvalsRequired }) => ({
- id,
- type: "group",
- sequence: approverSequence,
- approvalsRequired
- })
+ mapper: ({ approverUserId, approverGroupId, approverSequence, approvalsRequired }) =>
+ approverUserId
+ ? { id: approverUserId, type: "user", sequence: approverSequence, approvalsRequired }
+ : { id: approverGroupId, type: "group", sequence: approverSequence, approvalsRequired }
},
{
key: "environmentId",
@@ -522,25 +511,23 @@ export const accessApprovalPolicyDALFactory = (db: TDbClient): TAccessApprovalPo
}),
childrenMapper: [
{
- key: "approverUserId",
+ key: "approverRowId",
label: "approvers" as const,
- mapper: ({ approverUserId: id, approverUsername, approverSequence, approvalsRequired }) => ({
- id,
- type: ApproverType.User as const,
- name: approverUsername,
- sequence: approverSequence,
- approvalsRequired
- })
- },
- {
- key: "approverGroupId",
- label: "approvers" as const,
- mapper: ({ approverGroupId: id, approverSequence, approvalsRequired }) => ({
- id,
- type: ApproverType.Group as const,
- sequence: approverSequence,
- approvalsRequired
- })
+ mapper: ({ approverUserId, approverGroupId, approverUsername, approverSequence, approvalsRequired }) =>
+ approverUserId
+ ? {
+ id: approverUserId,
+ type: ApproverType.User as const,
+ name: approverUsername,
+ sequence: approverSequence,
+ approvalsRequired
+ }
+ : {
+ id: approverGroupId,
+ type: ApproverType.Group as const,
+ sequence: approverSequence,
+ approvalsRequired
+ }
},
{
key: "bypasserUserId",
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 c7a1ee4028..ae4b23857c 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
@@ -75,13 +75,15 @@ export const secretAccessApprovalBridgeDALFactory = (db: TDbClient) => {
db.ref("id").withSchema(TableName.ApprovalPolicySteps).as("stepId"),
db.ref("stepNumber").withSchema(TableName.ApprovalPolicySteps),
db.ref("requiredApprovals").withSchema(TableName.ApprovalPolicySteps),
+ db.ref("id").withSchema(TableName.ApprovalPolicyStepApprovers).as("approverRowId"),
db.ref("userId").withSchema(TableName.ApprovalPolicyStepApprovers).as("approverUserId"),
db.ref("groupId").withSchema(TableName.ApprovalPolicyStepApprovers).as("approverGroupId"),
db.ref("username").withSchema(TableName.Users).as("approverUsername"),
db.ref("userId").withSchema(TableName.ApprovalPolicyBypassers).as("bypasserUserId"),
db.ref("groupId").withSchema(TableName.ApprovalPolicyBypassers).as("bypasserGroupId"),
db.ref("username").withSchema("bypasserUsers").as("bypasserUsername")
- );
+ )
+ .orderBy(`${TableName.ApprovalPolicySteps}.stepNumber`, "asc");
const formattedDocs = sqlNestRelationships({
data: docs,
@@ -111,25 +113,23 @@ export const secretAccessApprovalBridgeDALFactory = (db: TDbClient) => {
mapper: ({ stepId: id, stepNumber, requiredApprovals }) => ({ id, stepNumber, requiredApprovals })
},
{
- key: "approverUserId",
- label: "approvers" as const,
- mapper: ({ approverUserId: id, approverUsername, stepNumber, requiredApprovals }) => ({
- id,
- type: ApproverType.User as const,
- name: approverUsername,
- sequence: stepNumber,
- approvalsRequired: requiredApprovals
- })
- },
- {
- key: "approverGroupId",
+ key: "approverRowId",
label: "approvers" as const,
- mapper: ({ approverGroupId: id, stepNumber, requiredApprovals }) => ({
- id,
- type: ApproverType.Group as const,
- sequence: stepNumber,
- approvalsRequired: requiredApprovals
- })
+ mapper: ({ approverUserId, approverGroupId, approverUsername, stepNumber, requiredApprovals }) =>
+ approverUserId
+ ? {
+ id: approverUserId,
+ type: ApproverType.User as const,
+ name: approverUsername,
+ sequence: stepNumber,
+ approvalsRequired: requiredApprovals
+ }
+ : {
+ id: approverGroupId,
+ type: ApproverType.Group as const,
+ sequence: stepNumber,
+ approvalsRequired: requiredApprovals
+ }
},
{
key: "bypasserUserId",
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
index 1cf042b6ca..b2e92cc895 100644
--- 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
@@ -1,11 +1,14 @@
import { describe, expect, test } from "vitest";
+import { BadRequestError } from "@app/lib/errors";
+import { ApproverType } from "@app/services/approval-policy/approval-policy-enums";
+
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 });
+const user = (id: string, sequence = 1) => ({ type: ApproverType.User, id, sequence });
+const group = (id: string, sequence = 1) => ({ type: ApproverType.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`.
@@ -52,6 +55,55 @@ describe("buildSecretAccessPolicySteps", () => {
expect(steps[0].requiredApprovals).toBe(2);
});
+ test("the same user may approve in two different steps", () => {
+ const steps = buildSecretAccessPolicySteps(
+ [user("a", 1), user("b", 1), user("b", 2)],
+ [
+ { stepNumber: 1, numberOfApprovals: 2 },
+ { stepNumber: 2, numberOfApprovals: 1 }
+ ]
+ );
+
+ expect(steps).toHaveLength(2);
+ expect(steps[0].approvers.map((el) => el.id)).toEqual(["a", "b"]);
+ expect(steps[0].requiredApprovals).toBe(2);
+ expect(steps[1].approvers.map((el) => el.id)).toEqual(["b"]);
+ expect(steps[1].requiredApprovals).toBe(1);
+ });
+
+ test("the same approver listed twice in one step counts once", () => {
+ const steps = buildSecretAccessPolicySteps([user("a"), user("a"), group("g"), group("g")]);
+
+ expect(steps[0].approvers).toEqual([user("a"), group("g")]);
+ });
+
+ test("a step that requires more approvals than it has user approvers is rejected", () => {
+ expect(() =>
+ buildSecretAccessPolicySteps(
+ [user("a", 1), user("b", 1), user("c", 2)],
+ [
+ { stepNumber: 1, numberOfApprovals: 2 },
+ { stepNumber: 2, numberOfApprovals: 2 }
+ ]
+ )
+ ).toThrow(BadRequestError);
+ expect(() =>
+ buildSecretAccessPolicySteps([user("a", 1), user("c", 2)], [{ stepNumber: 2, numberOfApprovals: 3 }])
+ ).toThrow("Step 2 requires 3 approvals but only has 1 approver.");
+ });
+
+ test("a duplicate approver does not count toward the step's requirement", () => {
+ expect(() =>
+ buildSecretAccessPolicySteps([user("a"), user("a")], [{ stepNumber: 1, numberOfApprovals: 2 }])
+ ).toThrow(BadRequestError);
+ });
+
+ test("a step containing a group approver is never rejected for its size", () => {
+ const steps = buildSecretAccessPolicySteps([user("a"), group("g")], [{ stepNumber: 1, numberOfApprovals: 10 }]);
+
+ expect(steps[0].requiredApprovals).toBe(10);
+ });
+
test.each([
{ name: "single step, no entries", approvers: [user("a"), user("b")], approvalsRequired: undefined },
{
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 06747e88ea..025042cf0b 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
@@ -51,7 +51,7 @@ export const secretAccessApprovalPolicyExists = async (
// 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 }>(
+export const buildSecretAccessPolicySteps = <T extends { type: ApproverType; id: string; sequence: number }>(
approvers: T[],
approvalsRequired?: { numberOfApprovals: number; stepNumber: number }[]
) => {
@@ -60,10 +60,25 @@ export const buildSecretAccessPolicySteps = <T extends { sequence: number }>(
return Object.keys(approversBySequence)
.map(Number)
.sort((a, b) => a - b)
- .map((sequence) => ({
- requiredApprovals: approvalsRequiredByStepNumber[sequence]?.[0]?.numberOfApprovals || 1,
- approvers: approversBySequence[sequence]
- }));
+ .map((sequence, index) => {
+ const seen = new Set<string>();
+ const stepApprovers = approversBySequence[sequence].filter((approver) => {
+ const key = `${approver.type}:${approver.id}`;
+ if (seen.has(key)) return false;
+ seen.add(key);
+ return true;
+ });
+ const requiredApprovals = approvalsRequiredByStepNumber[sequence]?.[0]?.numberOfApprovals || 1;
+
+ const hasGroupApprover = stepApprovers.some((approver) => approver.type === ApproverType.Group);
+ if (!hasGroupApprover && requiredApprovals > stepApprovers.length) {
+ throw new BadRequestError({
+ message: `Step ${index + 1} requires ${requiredApprovals} approvals but only has ${stepApprovers.length} approver${stepApprovers.length === 1 ? "" : "s"}. Add approvers to the step or lower its required approvals.`
+ });
+ }
+
+ return { requiredApprovals, approvers: stepApprovers };
+ });
};
export type TSecretAccessRequestRow = TApprovalRequests & {
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 245d5067c2..57054d4eda 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
@@ -449,7 +449,6 @@ export const secretAccessApprovalBridgeServiceFactory = ({
actor,
actorOrgId,
actorAuthMethod,
- approvals,
enforcementLevel,
allowedSelfApprovals,
approvalsRequired,
@@ -468,12 +467,6 @@ export const secretAccessApprovalBridgeServiceFactory = ({
});
ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Edit, ProjectPermissionSub.SecretApproval);
- const { groupApprovers: groupApproverInputs, userApprovers, userApproverNames } = $splitApprovers(approvers);
- const currentApprovals = approvals || policy.approvals;
- if (groupApproverInputs.length === 0 && currentApprovals > userApprovers.length + userApproverNames.length) {
- throw new BadRequestError({ message: "Approvals cannot be greater than approvers" });
- }
-
let envs: { id: string; slug: string }[] = policy.environments;
if (environments) {
envs = await projectEnvDAL.find({ $in: { slug: environments }, projectId: policy.projectId });