Skip to content

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

fix count on requests and approval drift on response

adilsoncd30bbb0f9ea
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 83aec777bc..35f97b06e1 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
@@ -457,7 +457,7 @@ describe("Access approval policy required approvals per step", () => {
(step) => step.requiredApprovals
);
- test("Updating without approvalsRequired resets every step to one approval", async () => {
+ test("Updating without approvalsRequired takes approvals for the first step", async () => {
const policy = await createGlobalPolicy({ name: "policy-routing-required-reset", secretPath: "/required-reset" });
const approvers = [
{ type: ApproverType.User, id: seedData1.id, sequence: 1 },
@@ -472,7 +472,7 @@ describe("Access approval policy required approvals per step", () => {
expect(withEntry.statusCode).toBe(200);
expect(await getStepRequirements(policy.id)).toEqual([2]);
- const withoutEntry = await patchPolicy(policy.id, { approvers, approvals: 2 });
+ const withoutEntry = await patchPolicy(policy.id, { approvers, approvals: 1 });
expect(withoutEntry.statusCode).toBe(200);
expect(await getStepRequirements(policy.id)).toEqual([1]);
@@ -552,6 +552,50 @@ describe("Access approval policy required approvals per step", () => {
expect(await getDb()(TableName.ApprovalPolicies).where({ name }).first()).toBeUndefined();
});
+ test("approvals reads back as written when no approvalsRequired is sent", async () => {
+ const approvers = [
+ { type: ApproverType.User, id: seedData1.id, sequence: 1 },
+ { type: ApproverType.User, id: otherApproverId, sequence: 1 }
+ ];
+ const createRes = await createPolicyRaw({
+ name: "policy-routing-approvals-round-trip",
+ secretPath: "/approvals-round-trip",
+ approvers,
+ approvals: 2
+ });
+ expect(createRes.statusCode).toBe(200);
+ const policyId = createRes.json().approval.id as string;
+ globalPolicyIds.push(policyId);
+
+ expect(createRes.json().approval.approvals).toBe(2);
+ expect(await getStepRequirements(policyId)).toEqual([2]);
+ expect((await getPolicy(policyId)).json().approval.approvals).toBe(2);
+
+ const withoutApprovals = await patchPolicy(policyId, { approvers, approvals: undefined });
+ expect(withoutApprovals.statusCode).toBe(200);
+ expect(withoutApprovals.json().approval.approvals).toBe(2);
+ expect(await getStepRequirements(policyId)).toEqual([2]);
+
+ const lowered = await patchPolicy(policyId, { approvers, approvals: 1 });
+ expect(lowered.statusCode).toBe(200);
+ expect((await getPolicy(policyId)).json().approval.approvals).toBe(1);
+ expect(await getStepRequirements(policyId)).toEqual([1]);
+ });
+
+ test("Creating with more approvals than the first step's user approvers is rejected", async () => {
+ const name = "policy-routing-approvals-too-many";
+ const res = await createPolicyRaw({
+ name,
+ secretPath: "/approvals-too-many",
+ approvers: [{ type: ApproverType.User, id: seedData1.id, sequence: 1 }],
+ approvals: 2
+ });
+
+ expect(res.statusCode).toBe(400);
+ expect(res.json().message).toContain("Step 1 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" });
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 3e9d8c69e1..6dc8c492a2 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
@@ -14,6 +14,7 @@ const getDb = () => (globalThis as unknown as { testDb: Knex }).testDb;
const SECRET_ACCESS_TYPE = "secret-access";
const globalPolicyIds: string[] = [];
+const policylessRequestIds: string[] = [];
const authHeaders = () => ({ authorization: `Bearer ${jwtAuthToken}` });
@@ -82,6 +83,13 @@ const countAccessRequests = () =>
headers: authHeaders()
});
+const deletePolicy = (policyId: string) =>
+ testServer.inject({
+ method: "DELETE",
+ url: `/api/v1/access-approvals/policies/${policyId}`,
+ headers: authHeaders()
+ });
+
const createApprovedTemporaryRequest = async (secretPath: string) => {
const policy = await createGlobalPolicy({ name: `lifecycle-${secretPath.slice(1)}`, secretPath });
@@ -111,6 +119,10 @@ describe("Access approval request lifecycle on the global system", () => {
await db(TableName.ApprovalRequests).whereIn("policyId", globalIds).del();
await db(TableName.ApprovalPolicies).whereIn("id", globalIds).del();
}
+ const requestIds = policylessRequestIds.splice(0);
+ if (requestIds.length) {
+ await db(TableName.ApprovalRequests).whereIn("id", requestIds).del();
+ }
});
test("Approving a request creates a grant and a privilege that references it", async () => {
@@ -201,6 +213,46 @@ describe("Access approval request lifecycle on the global system", () => {
expect(secondRevoke.json().message).toBe("Only approved requests can be revoked");
});
+ test("Deleting a policy keeps its requests listed and the count in step", async () => {
+ const { policy, requestId: approvedId } = await createApprovedTemporaryRequest("/lifecycle-deleted-policy");
+ const pendingRes = await createAccessRequest("/lifecycle-deleted-policy", { isTemporary: false });
+ expect(pendingRes.statusCode).toBe(200);
+ const pendingId = pendingRes.json().approval.id as string;
+ policylessRequestIds.push(approvedId, pendingId);
+
+ const countBefore = (await countAccessRequests()).json();
+
+ expect((await deletePolicy(policy.id)).statusCode).toBe(200);
+
+ 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).toBeNull();
+ expect(approved.policy.id).toBeNull();
+ expect(approved.policy.deletedAt).toBeTruthy();
+ expect(approved.policy.secretPath).toBe("/lifecycle-deleted-policy");
+ expect(approved.environment).toBe(seedData1.environment.slug);
+ expect(approved.status).toBe("revoked");
+ expect(approved.privilege).toBeNull();
+
+ const pending = requests.find((request: { id: string }) => request.id === pendingId);
+ expect(pending).toBeDefined();
+ expect(pending.policyId).toBeNull();
+ expect(pending.policy.deletedAt).toBeTruthy();
+ expect(pending.status).toBe("pending");
+
+ const countAfter = (await countAccessRequests()).json();
+ expect(countAfter.pendingCount).toBe(countBefore.pendingCount - 1);
+ expect(countAfter.finalizedCount).toBe(countBefore.finalizedCount + 1);
+
+ const reviewRes = await reviewAccessRequest(pendingId, { status: "approved" });
+ expect(reviewRes.statusCode).toBe(400);
+ expect(reviewRes.json().message).toBe("The policy associated with this access request has been deleted.");
+ });
+
test("Rejecting a request creates no grant and no privilege", async () => {
const db = getDb();
const secretPath = "/lifecycle-reject";
@@ -725,20 +777,25 @@ describe("Per-step required approvals on the global system", () => {
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";
+ test("A first step with no approvalsRequired entry needs the policy's approvals", async () => {
+ const secretPath = "/required-from-approvals";
const policy = await createPolicyWithApprovers({
secretPath,
- approvers: [{ type: ApproverType.User, id: a.userId }],
- approvals: 3
+ approvers: [
+ { type: ApproverType.User, id: a.userId },
+ { type: ApproverType.User, id: b.userId }
+ ],
+ approvals: 2
});
const steps = await getPolicySteps(policy.id);
- expect(steps.map((step) => step.requiredApprovals)).toEqual([1]);
+ expect(steps.map((step) => step.requiredApprovals)).toEqual([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/ee/routes/v1/access-approval-request-router.ts b/backend/src/ee/routes/v1/access-approval-request-router.ts
index a6a150b8e1..2b26b6f491 100644
--- a/backend/src/ee/routes/v1/access-approval-request-router.ts
+++ b/backend/src/ee/routes/v1/access-approval-request-router.ts
@@ -151,6 +151,8 @@ export const registerAccessApprovalRequestRouter = async (server: FastifyZodProv
response: {
200: z.object({
requests: AccessApprovalRequestsSchema.extend({
+ // A global policy is hard-deleted, so its requests keep their history without a policy id.
+ policyId: z.string().uuid().nullable(),
environmentName: z.string(),
isApproved: z.boolean(),
privilege: z
@@ -165,7 +167,7 @@ export const registerAccessApprovalRequestRouter = async (server: FastifyZodProv
})
.nullable(),
policy: z.object({
- id: z.string(),
+ id: z.string().nullable(),
name: z.string(),
approvals: z.number(),
approvers: z
diff --git a/backend/src/ee/services/access-approval-request/access-approval-request-types.ts b/backend/src/ee/services/access-approval-request/access-approval-request-types.ts
index d3aa7eefcf..a7fb54820e 100644
--- a/backend/src/ee/services/access-approval-request/access-approval-request-types.ts
+++ b/backend/src/ee/services/access-approval-request/access-approval-request-types.ts
@@ -108,7 +108,7 @@ export interface TAccessApprovalRequestServiceFactory {
}
)[];
bypassers: string[];
- id: string;
+ id: string | null;
name: string;
approvals: number;
secretPath: string | null | undefined;
@@ -159,7 +159,7 @@ export interface TAccessApprovalRequestServiceFactory {
id: string;
createdAt: Date;
updatedAt: Date;
- policyId: string;
+ policyId: string | null;
isTemporary: boolean;
requestedByUserId: string;
privilegeId?: string | null | undefined;
diff --git a/backend/src/server/routes/index.ts b/backend/src/server/routes/index.ts
index 529826e944..76ce51dacb 100644
--- a/backend/src/server/routes/index.ts
+++ b/backend/src/server/routes/index.ts
@@ -2501,6 +2501,7 @@ export const registerRoutes = async (
const secretAccessApprovalGlobalRequestBridgeService = secretAccessApprovalGlobalRequestBridgeServiceFactory({
projectDAL,
+ projectEnvDAL,
permissionService,
userDAL,
userGroupMembershipDAL,
diff --git a/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-fns.test.ts b/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-fns.test.ts
index 217c8a08c8..ce4bd082ad 100644
--- a/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-fns.test.ts
+++ b/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-fns.test.ts
@@ -98,6 +98,38 @@ describe("buildSecretAccessPolicySteps", () => {
).toThrow(BadRequestError);
});
+ test("the first step falls back to approvals when it has no entry", () => {
+ const steps = buildSecretAccessPolicySteps([user("a"), user("b"), user("c", 2)], undefined, 2);
+
+ expect(steps.map((step) => step.requiredApprovals)).toEqual([2, 1]);
+ });
+
+ test("an explicit entry for the first step wins over approvals", () => {
+ const steps = buildSecretAccessPolicySteps(
+ [user("a"), user("b"), user("c")],
+ [{ stepNumber: 1, numberOfApprovals: 3 }],
+ 2
+ );
+
+ expect(steps[0].requiredApprovals).toBe(3);
+ });
+
+ test("approvals only stands in for the first step", () => {
+ const steps = buildSecretAccessPolicySteps(
+ [user("a", 1), user("b", 2), user("c", 2)],
+ [{ stepNumber: 1, numberOfApprovals: 1 }],
+ 2
+ );
+
+ expect(steps.map((step) => step.requiredApprovals)).toEqual([1, 1]);
+ });
+
+ test("approvals above the first step's user approvers is rejected", () => {
+ expect(() => buildSecretAccessPolicySteps([user("a")], undefined, 2)).toThrow(
+ "Step 1 requires 2 approvals but only has 1 approver."
+ );
+ });
+
test("a step containing a group approver is never rejected for its size", () => {
const steps = buildSecretAccessPolicySteps([user("a"), group("g")], [{ stepNumber: 1, numberOfApprovals: 10 }]);
diff --git a/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-fns.ts b/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-fns.ts
index 9da10d99f2..1256520b9a 100644
--- a/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-fns.ts
+++ b/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-fns.ts
@@ -38,11 +38,12 @@ export const secretAccessApprovalGlobalPolicyExists = async (
return policy?.envId;
};
-// 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.
+// Reads report `approvals` as the first step's requirement, so that step falls back to it when it has no
+// approvalsRequired entry; otherwise a caller that only sets `approvals` would read back a different value.
export const buildSecretAccessPolicySteps = <T extends { type: ApproverType; id: string; sequence: number }>(
approvers: T[],
- approvalsRequired?: { numberOfApprovals: number; stepNumber: number }[]
+ approvalsRequired?: { numberOfApprovals: number; stepNumber: number }[],
+ approvals?: number
) => {
const approvalsRequiredByStepNumber = groupBy(approvalsRequired || [], (i) => i.stepNumber);
const approversBySequence = groupBy(approvers, (el) => el.sequence);
@@ -57,7 +58,8 @@ export const buildSecretAccessPolicySteps = <T extends { type: ApproverType; id:
seen.add(key);
return true;
});
- const requiredApprovals = approvalsRequiredByStepNumber[sequence]?.[0]?.numberOfApprovals || 1;
+ const requiredApprovals =
+ approvalsRequiredByStepNumber[sequence]?.[0]?.numberOfApprovals || (index === 0 ? approvals : undefined) || 1;
const hasGroupApprover = stepApprovers.some((approver) => approver.type === ApproverType.Group);
if (!hasGroupApprover && requiredApprovals > stepApprovers.length) {
diff --git a/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-service.ts b/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-service.ts
index db526f4a80..a8efdd26ec 100644
--- a/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-service.ts
+++ b/backend/src/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-service.ts
@@ -193,18 +193,21 @@ export const secretAccessApprovalGlobalPolicyBridgeServiceFactory = ({
const $buildSteps = ({
approverUserIds,
groupApprovers,
- approvalsRequired
+ approvalsRequired,
+ approvals
}: {
approverUserIds: TSequencedSubject[];
groupApprovers: TSequencedSubject[];
approvalsRequired?: { numberOfApprovals: number; stepNumber: number }[];
+ approvals?: number;
}): 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 }))
],
- approvalsRequired
+ approvalsRequired,
+ approvals
);
const $insertStepsAndBypassers = async (
@@ -369,7 +372,7 @@ export const secretAccessApprovalGlobalPolicyBridgeServiceFactory = ({
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, approvalsRequired });
+ const steps = $buildSteps({ approverUserIds, groupApprovers, approvalsRequired, approvals });
await $assertNoConflictingPolicy({ envs, secretPath });
@@ -411,7 +414,7 @@ export const secretAccessApprovalGlobalPolicyBridgeServiceFactory = ({
id: policy.id,
name: policy.name,
secretPath,
- approvals,
+ approvals: steps[0]?.requiredApprovals ?? 1,
envId: envs[0].id,
createdAt: policy.createdAt,
updatedAt: policy.updatedAt,
@@ -437,6 +440,7 @@ export const secretAccessApprovalGlobalPolicyBridgeServiceFactory = ({
actor,
actorOrgId,
actorAuthMethod,
+ approvals,
enforcementLevel,
allowedSelfApprovals,
approvalsRequired,
@@ -478,7 +482,12 @@ export const secretAccessApprovalGlobalPolicyBridgeServiceFactory = ({
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, approvalsRequired });
+ const steps = $buildSteps({
+ approverUserIds,
+ groupApprovers,
+ approvalsRequired,
+ approvals: approvals ?? policy.approvals
+ });
return approvalPolicyDAL.transaction(async (tx) => {
await approvalPolicyDAL.updateById(
diff --git a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.test.ts b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.test.ts
index e8e9a70553..9782c7b2a7 100644
--- a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.test.ts
+++ b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.test.ts
@@ -13,8 +13,10 @@ import {
import {
collectSecretAccessRequestUserIds,
composeSecretAccessRequestRows,
+ isPendingSecretAccessRequestItem,
isPolicySubjectMatch,
toLegacyAccessApprovalRequest,
+ toSecretAccessRequestListItem,
TSecretAccessRequestListInput
} from "./secret-access-approval-global-request-bridge-fns";
@@ -400,3 +402,102 @@ describe("composeSecretAccessRequestRows", () => {
expect(row.requestedByUser).toBeNull();
});
});
+
+describe("toSecretAccessRequestListItem", () => {
+ const environmentsBySlug = new Map([["dev", { id: ENV_ID, name: "Development", slug: "dev" }]]);
+ const toItem = (input: Partial<TSecretAccessRequestListInput>, envs = environmentsBySlug) => {
+ const [row] = composeSecretAccessRequestRows(listInput(input));
+ return toSecretAccessRequestListItem(row, { projectId: "project-1", environmentsBySlug: envs });
+ };
+
+ test("a request with a policy reports that policy and its environment", () => {
+ const item = toItem({});
+
+ expect(item?.policyId).toBe("policy-1");
+ expect(item?.policy.id).toBe("policy-1");
+ expect(item?.policy.deletedAt).toBeNull();
+ expect(item?.environment).toBe("dev");
+ expect(item?.environmentName).toBe("Development");
+ expect(item?.status).toBe(ApprovalStatus.PENDING);
+ expect(item?.approvers).toEqual(item?.policy.approvers);
+ });
+
+ test("a request cancelled by its policy's deletion reads as pending under a deleted policy", () => {
+ const item = toItem({ requests: [request({ policyId: null, status: ApprovalRequestStatus.Cancelled })] });
+
+ expect(item?.policyId).toBeNull();
+ expect(item?.policy).toEqual({
+ id: null,
+ name: "",
+ approvals: 0,
+ secretPath: "/app",
+ enforcementLevel: "hard",
+ allowedSelfApprovals: false,
+ envId: ENV_ID,
+ deletedAt: updatedAt,
+ maxTimePeriod: null,
+ requestExpirationTime: null,
+ approvers: [],
+ bypassers: []
+ });
+ expect(item?.environment).toBe("dev");
+ expect(item?.status).toBe(ApprovalStatus.PENDING);
+ expect(item?.isApproved).toBe(false);
+ });
+
+ test("a grant revoked by the policy's deletion reads as revoked", () => {
+ const item = toItem({
+ requests: [request({ policyId: null, status: ApprovalRequestStatus.Approved })],
+ grants: [grant({ status: ApprovalRequestGrantStatus.Revoked, revokedByUserId: "admin" })]
+ });
+
+ expect(item?.policy.deletedAt).toEqual(updatedAt);
+ expect(item?.status).toBe(ApprovalStatus.REVOKED);
+ expect(item?.privilege).toBeNull();
+ });
+
+ test("a request is hidden when its policy and environment are both gone", () => {
+ expect(toItem({ requests: [request({ policyId: null })] }, new Map())).toBeNull();
+ });
+
+ test("a request is hidden when its requester is gone", () => {
+ expect(toItem({ requests: [request({ requesterId: null })] })).toBeNull();
+ });
+
+ test("a request is hidden when its data is malformed", () => {
+ expect(toItem({ requests: [request({ requestData: { version: 2 } })] })).toBeNull();
+ });
+});
+
+describe("isPendingSecretAccessRequestItem", () => {
+ const now = new Date("2026-01-05T00:00:00.000Z");
+ const pendingItem = {
+ policy: { deletedAt: null },
+ status: ApprovalStatus.PENDING,
+ reviewers: [{ userId: "approver-a", status: ApprovalRequestApprovalDecision.Approved, isOrgMembershipActive: true }],
+ expiresAt: null
+ };
+
+ test("an open request under a live policy is pending", () => {
+ expect(isPendingSecretAccessRequestItem(pendingItem, now)).toBe(true);
+ });
+
+ test("a deleted policy, a rejection, a closed status or an expiry finalizes it", () => {
+ expect(isPendingSecretAccessRequestItem({ ...pendingItem, policy: { deletedAt: now } }, now)).toBe(false);
+ expect(
+ isPendingSecretAccessRequestItem(
+ {
+ ...pendingItem,
+ reviewers: [
+ { userId: "approver-a", status: ApprovalRequestApprovalDecision.Rejected, isOrgMembershipActive: true }
+ ]
+ },
+ now
+ )
+ ).toBe(false);
+ expect(isPendingSecretAccessRequestItem({ ...pendingItem, status: ApprovalStatus.APPROVED }, now)).toBe(false);
+ expect(
+ isPendingSecretAccessRequestItem({ ...pendingItem, expiresAt: new Date("2026-01-04T00:00:00.000Z") }, now)
+ ).toBe(false);
+ });
+});
diff --git a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.ts b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.ts
index 3686b34e49..c9aad69175 100644
--- a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.ts
+++ b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.ts
@@ -1,6 +1,7 @@
import msFn from "ms";
import { TAdditionalPrivileges, TApprovalRequestGrants, TApprovalRequests, TUsers } from "@app/db/schemas";
+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 { getConfig } from "@app/lib/config/env";
import { BadRequestError, NotFoundError } from "@app/lib/errors";
@@ -9,13 +10,18 @@ import { ms } from "@app/lib/ms";
import { triggerWorkflowIntegrationNotification } from "@app/lib/workflow-integrations/trigger-notification";
import { TriggerFeature } from "@app/lib/workflow-integrations/types";
import {
+ ApprovalRequestApprovalDecision,
ApprovalRequestGrantStatus,
ApprovalRequestStatus,
- ApproverType
+ ApproverType,
+ EnforcementLevel
} 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 { getSecretAccessRequestData } from "@app/services/approval-policy/secret-access/secret-access-policy-fns";
+import {
+ getSecretAccessRequestData,
+ parseSecretAccessRequestData
+} from "@app/services/approval-policy/secret-access/secret-access-policy-fns";
import { TSecretAccessRequestData } from "@app/services/approval-policy/secret-access/secret-access-policy-types";
import { NotificationType } from "@app/services/notification/notification-types";
import { TSecretAccessApprovalGlobalPolicyBridgeDALFactory } from "@app/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-dal";
@@ -29,25 +35,27 @@ export type TSecretAccessRequestRow = TApprovalRequests & {
privilegeId: string | null;
};
-export const toLegacyAccessApprovalRequest = (
- request: Pick<
- TSecretAccessRequestRow,
- | "id"
- | "policyId"
- | "requesterId"
- | "requestData"
- | "justification"
- | "status"
- | "expiresAt"
- | "createdAt"
- | "updatedAt"
- | "grant"
- | "privilegeId"
- >,
+type TLegacyAccessApprovalRequestInput = Pick<
+ TSecretAccessRequestRow,
+ | "id"
+ | "policyId"
+ | "requesterId"
+ | "requestData"
+ | "justification"
+ | "status"
+ | "expiresAt"
+ | "createdAt"
+ | "updatedAt"
+ | "grant"
+ | "privilegeId"
+>;
+
+export const toLegacyAccessApprovalRequestFields = (
+ request: TLegacyAccessApprovalRequestInput,
approvedByUserId: string | null = null
): {
id: string;
- policyId: string;
+ policyId: string | null;
requestedByUserId: string;
isTemporary: boolean;
temporaryRange: string | null;
@@ -67,9 +75,6 @@ export const toLegacyAccessApprovalRequest = (
bypassReason: string | 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" });
}
@@ -84,7 +89,7 @@ export const toLegacyAccessApprovalRequest = (
return {
id: request.id,
- policyId: request.policyId,
+ policyId: request.policyId ?? null,
requestedByUserId: request.requesterId,
isTemporary: data.isTemporary,
temporaryRange: data.temporaryRange,
@@ -106,6 +111,16 @@ export const toLegacyAccessApprovalRequest = (
};
};
+export const toLegacyAccessApprovalRequest = (
+ request: TLegacyAccessApprovalRequestInput,
+ approvedByUserId: string | null = null
+) => {
+ if (!request.policyId) {
+ throw new BadRequestError({ message: "The policy associated with this access request has been deleted." });
+ }
+ return { ...toLegacyAccessApprovalRequestFields(request, approvedByUserId), policyId: request.policyId };
+};
+
type TNotifySecretAccessStepApproversDep = Pick<
TSecretAccessApprovalGlobalRequestBridgeServiceFactoryDep,
| "userDAL"
@@ -474,3 +489,95 @@ export const composeSecretAccessRequestRows = ({
};
});
};
+
+type TSecretAccessRequestComposedRow = ReturnType<typeof composeSecretAccessRequestRows>[number];
+type TSecretAccessRequestListPolicy = Omit<NonNullable<TSecretAccessRequestComposedRow["policy"]>, "id" | "deletedAt"> & {
+ id: string | null;
+ deletedAt: Date | null;
+};
+
+export const toSecretAccessRequestListItem = (
+ row: TSecretAccessRequestComposedRow,
+ {
+ projectId,
+ environmentsBySlug
+ }: { projectId: string; environmentsBySlug: Map<string, { id: string; slug: string; name: string }> }
+) => {
+ if (!row.requestedByUser) return null;
+ const data = parseSecretAccessRequestData(row.request.requestData);
+ if (!data) return null;
+
+ const legacy = toLegacyAccessApprovalRequestFields(
+ { ...row.request, grant: row.grant, privilegeId: row.privilegeId },
+ row.approvedByUser?.userId ?? null
+ );
+
+ let { status } = legacy;
+ let environment: { slug: string; name: string };
+ let policy: TSecretAccessRequestListPolicy;
+ if (row.policy) {
+ if (!row.environment) return null;
+ environment = row.environment;
+ policy = row.policy;
+ } else {
+ let requested: { envSlug: string; secretPath: string };
+ try {
+ requested = verifyRequestedPermissions({ permissions: data.permissions });
+ } catch {
+ return null;
+ }
+ const requestedEnvironment = environmentsBySlug.get(requested.envSlug);
+ if (!requestedEnvironment) return null;
+
+ environment = requestedEnvironment;
+ policy = {
+ id: null,
+ name: "",
+ approvals: 0,
+ secretPath: requested.secretPath,
+ enforcementLevel: EnforcementLevel.Hard,
+ allowedSelfApprovals: false,
+ envId: requestedEnvironment.id,
+ // A hard delete leaves no deletion time behind; the UI only needs a non-null marker here.
+ deletedAt: row.request.updatedAt,
+ maxTimePeriod: null,
+ requestExpirationTime: null,
+ approvers: [],
+ bypassers: []
+ };
+ // Legacy left a deleted policy's open requests pending, and the UI shows "Policy Deleted" only for a
+ // request that was neither approved nor rejected.
+ if (row.request.status === ApprovalRequestStatus.Cancelled) status = ApprovalStatus.PENDING;
+ }
+
+ return {
+ ...legacy,
+ status,
+ projectId,
+ environment: environment.slug,
+ environmentName: environment.name,
+ policy,
+ requestedByUser: row.requestedByUser,
+ approvedByUser: row.approvedByUser,
+ revokedByUser: row.revokedByUser,
+ privilege: legacy.privilegeId ? row.privilege : null,
+ isApproved: status === ApprovalStatus.APPROVED,
+ reviewers: row.reviewers,
+ approvers: policy.approvers,
+ bypassers: policy.bypassers
+ };
+};
+
+export const isPendingSecretAccessRequestItem = (
+ item: {
+ policy: { deletedAt: Date | null };
+ status: string;
+ reviewers: { status: string }[];
+ expiresAt: Date | null;
+ },
+ now: Date
+) =>
+ !item.policy.deletedAt &&
+ item.status === ApprovalStatus.PENDING &&
+ !item.reviewers.some((reviewer) => reviewer.status === ApprovalRequestApprovalDecision.Rejected) &&
+ !(item.expiresAt && new Date(item.expiresAt) < now);
diff --git a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-service.ts b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-service.ts
index 8009714ba9..2c1469b0eb 100644
--- a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-service.ts
+++ b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-service.ts
@@ -36,10 +36,12 @@ import {
collectSecretAccessPolicyGroupIds,
collectSecretAccessRequestUserIds,
composeSecretAccessRequestRows,
+ isPendingSecretAccessRequestItem,
isPolicySubjectMatch,
notifySecretAccessBypass,
notifySecretAccessStepApprovers,
- toLegacyAccessApprovalRequest
+ toLegacyAccessApprovalRequest,
+ toSecretAccessRequestListItem
} from "./secret-access-approval-global-request-bridge-fns";
import {
TCountSecretAccessApprovalGlobalRequestsDTO,
@@ -56,6 +58,7 @@ export type TSecretAccessApprovalGlobalRequestBridgeServiceFactory = ReturnType<
export const secretAccessApprovalGlobalRequestBridgeServiceFactory = ({
projectDAL,
+ projectEnvDAL,
permissionService,
userDAL,
userGroupMembershipDAL,
@@ -135,56 +138,32 @@ export const secretAccessApprovalGlobalRequestBridgeServiceFactory = ({
});
};
- const listAccessApprovalRequests = async ({ projectId }: TListSecretAccessApprovalGlobalRequestsDTO) => {
- const rows = await $loadRequestRows({ projectId });
+ const $listRequestItems = async (filter: { projectId: string; policyId?: string; requesterId?: string }) => {
+ const rows = await $loadRequestRows(filter);
+ const environments = rows.some((row) => !row.policy)
+ ? await projectEnvDAL.find({ projectId: filter.projectId })
+ : [];
+ const environmentsBySlug = new Map(environments.map((environment) => [environment.slug, environment]));
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 item = toSecretAccessRequestListItem(row, { projectId: filter.projectId, environmentsBySlug });
+ return item ? [item] : [];
});
};
+ const listAccessApprovalRequests = ({ projectId }: TListSecretAccessApprovalGlobalRequestsDTO) =>
+ $listRequestItems({ projectId });
+
const countAccessApprovalRequests = async ({
projectId,
policyId,
requesterId
}: TCountSecretAccessApprovalGlobalRequestsDTO) => {
- const rows = await $loadRequestRows({ projectId, policyId, requesterId });
+ const items = await $listRequestItems({ 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 pendingCount = items.filter((item) => isPendingSecretAccessRequestItem(item, now)).length;
+ return { pendingCount, finalizedCount: items.length - pendingCount };
};
const $queueAccessRequestWebhook = async ({
diff --git a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-types.ts b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-types.ts
index 6e4b911672..4e92f58f16 100644
--- a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-types.ts
+++ b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-types.ts
@@ -20,6 +20,7 @@ import { TMicrosoftTeamsServiceFactory } from "@app/services/microsoft-teams/mic
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 { TSecretAccessApprovalGlobalPolicyBridgeDALFactory } from "@app/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-dal";
import { TProjectSlackConfigDALFactory } from "@app/services/slack/project-slack-config-dal";
import { TSmtpService } from "@app/services/smtp/smtp-service";
@@ -29,6 +30,7 @@ import { TSecretAccessApprovalGlobalRequestBridgeDALFactory } from "./secret-acc
export type TSecretAccessApprovalGlobalRequestBridgeServiceFactoryDep = {
projectDAL: Pick<TProjectDALFactory, "findById">;
+ projectEnvDAL: Pick<TProjectEnvDALFactory, "find">;
permissionService: Pick<TPermissionServiceFactory, "getProjectPermission">;
userDAL: Pick<TUserDALFactory, "find" | "findById">;
userGroupMembershipDAL: Pick<TUserGroupMembershipDALFactory, "find" | "findGroupMembershipsByUserIdInOrg">;
diff --git a/frontend/src/hooks/api/accessApproval/types.ts b/frontend/src/hooks/api/accessApproval/types.ts
index 51f57aff34..9a0d62eaef 100644
--- a/frontend/src/hooks/api/accessApproval/types.ts
+++ b/frontend/src/hooks/api/accessApproval/types.ts
@@ -73,7 +73,7 @@ export type TApprovalPolicyBypasserInput =
export type TAccessApprovalRequest = {
id: string;
- policyId: string;
+ policyId: string | null;
privilegeId: string | null;
requestedByUserId: string;
requestedByUser: {
@@ -108,7 +108,7 @@ export type TAccessApprovalRequest = {
// Set when the request was approved via break-glass without the required reviews.
bypassReason?: string | null;
policy: {
- id: string;
+ id: string | null;
name: string;
approvals: number;
approvers: {