Skip to content

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

feat: add update and delete operations on the bridge

adilson4e6339387f8a
diff --git a/backend/e2e-test/routes/v1/secret-approval-policy-bridge.spec.ts b/backend/e2e-test/routes/v1/secret-approval-policy-bridge.spec.ts
new file mode 100644
index 0000000000..b6d556f117
--- /dev/null
+++ b/backend/e2e-test/routes/v1/secret-approval-policy-bridge.spec.ts
@@ -0,0 +1,198 @@
+import { Knex } from "knex";
+
+import { TableName } from "@app/db/schemas";
+import { seedData1 } from "@app/db/seed-data";
+import { ApproverType } from "@app/ee/services/access-approval-policy/access-approval-policy-types";
+import { ApprovalPolicyType } from "@app/services/approval-policy/approval-policy-enums";
+
+const getDb = () => (globalThis as unknown as { testDb: Knex }).testDb;
+
+const projectId = seedData1.projectV3.id;
+const envSlug = seedData1.environment.slug;
+const LEGACY_PATH = "/sap-policy-bridge-legacy";
+const NEW_PATH = "/sap-policy-bridge-new";
+const MOVED_PATH = "/sap-policy-bridge-moved";
+const authHeaders = () => ({ authorization: `Bearer ${jwtAuthToken}` });
+const approvers = [{ type: ApproverType.User, id: seedData1.id }];
+
+const createLegacyPolicy = (secretPath: string) =>
+ testServer.inject({
+ method: "POST",
+ url: "/api/v1/secret-approvals",
+ headers: authHeaders(),
+ body: { workspaceId: projectId, environment: envSlug, secretPath, approvers, approvals: 1, name: "legacy-policy" }
+ });
+
+const createBridgePolicy = (secretPath: string) =>
+ testServer.inject({
+ method: "POST",
+ url: "/api/v2/secret-approvals",
+ headers: authHeaders(),
+ body: { projectId, environment: envSlug, secretPath, approvers, approvals: 1, name: "bridge-policy" }
+ });
+
+const updatePolicy = (id: string, body: Record<string, unknown>) =>
+ testServer.inject({
+ method: "PATCH",
+ url: `/api/v2/secret-approvals/${id}`,
+ headers: authHeaders(),
+ body: { approvers, approvals: 1, ...body }
+ });
+
+const deletePolicy = (id: string) =>
+ testServer.inject({ method: "DELETE", url: `/api/v2/secret-approvals/${id}`, headers: authHeaders() });
+
+const listPolicies = () =>
+ testServer.inject({ method: "GET", url: `/api/v2/secret-approvals?projectId=${projectId}`, headers: authHeaders() });
+
+const legacyRow = (id: string) => getDb()(TableName.SecretApprovalPolicy).where({ id }).first();
+const bridgeRow = (id: string) => getDb()(TableName.ApprovalPolicies).where({ id }).first();
+const bridgeEnvRows = (policyId: string) => getDb()(TableName.ApprovalPolicySecretEnvironment).where({ policyId });
+const bridgeStep = (policyId: string) => getDb()(TableName.ApprovalPolicySteps).where({ policyId }).first();
+
+const seedPendingRequest = async (policyId: string) => {
+ const [request] = await getDb()(TableName.ApprovalRequests)
+ .insert({
+ projectId,
+ organizationId: seedData1.organization.id,
+ policyId,
+ requesterId: seedData1.id,
+ requesterName: "test",
+ requesterEmail: seedData1.email,
+ type: ApprovalPolicyType.SecretChange,
+ status: "pending",
+ currentStep: 0,
+ requestData: JSON.stringify({})
+ })
+ .returning("*");
+ return request.id;
+};
+
+describe("Secret approval policy bridge routing", () => {
+ const legacyIds: string[] = [];
+ const bridgeIds: string[] = [];
+ const requestIds: string[] = [];
+ let envId: string;
+
+ beforeAll(async () => {
+ const env = await getDb()(TableName.Environment).where({ projectId, slug: envSlug }).first();
+ if (!env) throw new Error("seeded environment not found");
+ envId = env.id;
+ });
+
+ afterAll(async () => {
+ const db = getDb();
+ await db(TableName.ApprovalRequests).whereIn("id", requestIds).del();
+ await db(TableName.SecretApprovalPolicy).whereIn("id", legacyIds).del();
+ await db(TableName.ApprovalPolicies).whereIn("id", bridgeIds).del();
+ });
+
+ test("a legacy policy stays on the legacy tables through update and is soft-deleted on delete", async () => {
+ const createRes = await createLegacyPolicy(LEGACY_PATH);
+ expect(createRes.statusCode).toBe(200);
+ const legacyId = createRes.json().approval.id as string;
+ legacyIds.push(legacyId);
+ expect(await legacyRow(legacyId)).toMatchObject({ secretPath: LEGACY_PATH, deletedAt: null });
+ expect(await bridgeRow(legacyId)).toBeUndefined();
+
+ const updateRes = await updatePolicy(legacyId, { name: "legacy-renamed" });
+ expect(updateRes.statusCode).toBe(200);
+ expect(updateRes.json().approval).toMatchObject({ id: legacyId, name: "legacy-renamed" });
+ expect(await legacyRow(legacyId)).toMatchObject({ name: "legacy-renamed", deletedAt: null });
+ expect(await bridgeRow(legacyId)).toBeUndefined();
+
+ const deleteRes = await deletePolicy(legacyId);
+ expect(deleteRes.statusCode).toBe(200);
+ expect(deleteRes.json().approval.id).toBe(legacyId);
+ const deleted = await legacyRow(legacyId);
+ expect(deleted?.deletedAt).toBeInstanceOf(Date);
+
+ const listRes = await listPolicies();
+ expect(listRes.statusCode).toBe(200);
+ expect(listRes.json().approvals.map((policy: { id: string }) => policy.id)).not.toContain(legacyId);
+ });
+
+ test("a policy created after the legacy one is deleted lands on the approval system tables", async () => {
+ const createRes = await createBridgePolicy(LEGACY_PATH);
+ expect(createRes.statusCode).toBe(200);
+ const bridgeId = createRes.json().approval.id as string;
+ bridgeIds.push(bridgeId);
+
+ expect(await bridgeRow(bridgeId)).toMatchObject({ type: ApprovalPolicyType.SecretChange, projectId });
+ expect(await bridgeEnvRows(bridgeId)).toMatchObject([{ policyId: bridgeId, envId, secretPath: LEGACY_PATH }]);
+ expect(await legacyRow(bridgeId)).toBeUndefined();
+ });
+
+ test("an update is refused when the path is governed by a policy on the other store", async () => {
+ const legacyRes = await createLegacyPolicy(NEW_PATH);
+ expect(legacyRes.statusCode).toBe(200);
+ const legacyId = legacyRes.json().approval.id as string;
+ legacyIds.push(legacyId);
+ const [bridgeId] = bridgeIds;
+
+ const legacyOntoBridge = await updatePolicy(legacyId, { secretPath: LEGACY_PATH });
+ expect(legacyOntoBridge.statusCode).toBe(400);
+ expect(legacyOntoBridge.json().message).toBe(
+ `A policy for secret path '${LEGACY_PATH}' already exists in environment '${envSlug}'`
+ );
+
+ const bridgeOntoLegacy = await updatePolicy(bridgeId, { secretPath: NEW_PATH });
+ expect(bridgeOntoLegacy.statusCode).toBe(400);
+ expect(bridgeOntoLegacy.json().message).toBe(
+ `A policy for secret path '${NEW_PATH}' already exists in environment '${envSlug}'`
+ );
+
+ const bridgeOntoItself = await updatePolicy(bridgeId, { name: "bridge-renamed" });
+ expect([bridgeOntoItself.statusCode, bridgeOntoItself.payload]).toEqual([200, expect.any(String)]);
+ expect(await bridgeRow(bridgeId)).toMatchObject({ name: "bridge-renamed" });
+ });
+
+ test("a policy on the approval system is updated in place and hard-deleted", async () => {
+ const [bridgeId] = bridgeIds;
+
+ const updateRes = await updatePolicy(bridgeId, {
+ name: "bridge-moved",
+ approvals: 1,
+ secretPath: MOVED_PATH,
+ allowedSelfApprovals: false
+ });
+ expect(updateRes.statusCode).toBe(200);
+ expect(updateRes.json().approval).toMatchObject({
+ id: bridgeId,
+ name: "bridge-moved",
+ secretPath: MOVED_PATH,
+ approvals: 1,
+ allowedSelfApprovals: false,
+ environment: { slug: envSlug }
+ });
+ expect(await bridgeRow(bridgeId)).toMatchObject({
+ name: "bridge-moved",
+ constraints: { version: 1, constraints: { allowedSelfApprovals: false } }
+ });
+ expect(await bridgeStep(bridgeId)).toMatchObject({ stepNumber: 1, requiredApprovals: 1 });
+ expect(await bridgeEnvRows(bridgeId)).toMatchObject([{ envId, secretPath: MOVED_PATH }]);
+ expect(await legacyRow(bridgeId)).toBeUndefined();
+
+ const requestId = await seedPendingRequest(bridgeId);
+ requestIds.push(requestId);
+
+ const deleteRes = await deletePolicy(bridgeId);
+ expect(deleteRes.statusCode).toBe(200);
+ expect(deleteRes.json().approval).toMatchObject({ id: bridgeId, secretPath: MOVED_PATH });
+ expect(deleteRes.json().approval.deletedAt).not.toBeNull();
+ expect(await bridgeRow(bridgeId)).toBeUndefined();
+ expect(await bridgeEnvRows(bridgeId)).toHaveLength(0);
+ expect(await bridgeStep(bridgeId)).toBeUndefined();
+
+ // Pins the current gap: the bridge does not cancel pending requests the way legacy closes open ones.
+ // Flip this to expect "cancelled" when secret change requests move onto the approval system.
+ expect(await getDb()(TableName.ApprovalRequests).where({ id: requestId }).first()).toMatchObject({
+ status: "pending",
+ policyId: null
+ });
+
+ const recreateRes = await createBridgePolicy(MOVED_PATH);
+ expect(recreateRes.statusCode).toBe(200);
+ bridgeIds.push(recreateRes.json().approval.id);
+ });
+});
diff --git a/backend/src/ee/services/secret-approval-policy/secret-approval-policy-service.ts b/backend/src/ee/services/secret-approval-policy/secret-approval-policy-service.ts
index 3b0c5f55bc..eb1628bf80 100644
--- a/backend/src/ee/services/secret-approval-policy/secret-approval-policy-service.ts
+++ b/backend/src/ee/services/secret-approval-policy/secret-approval-policy-service.ts
@@ -652,8 +652,6 @@ export const secretApprovalPolicyServiceFactory = ({
return resolvePolicyForPath(policies, removeTrailingSlash(path));
};
- // batched variant of getSecretApprovalPolicy: fetches the env policies once, then matches every supplied path in
- // memory. returns a Map keyed by the original input path, containing only paths governed by a policy.
const getSecretApprovalPolicyByPaths = async (
projectId: string,
environment: string,
diff --git a/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-fns.ts b/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-fns.ts
index b581c1ce7c..393e82c2ec 100644
--- a/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-fns.ts
+++ b/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-fns.ts
@@ -1,31 +1,82 @@
import { Knex } from "knex";
+import { z } from "zod";
-import { TProjectEnvironments } from "@app/db/schemas";
-import { BadRequestError } from "@app/lib/errors";
-import { TApprovalPolicyDALFactory } from "@app/services/approval-policy/approval-policy-dal";
+import { TApprovalPolicies, TProjectEnvironments } from "@app/db/schemas";
+import { BadRequestError, NotFoundError } from "@app/lib/errors";
+import {
+ TApprovalPolicyBypassersDALFactory,
+ TApprovalPolicyDALFactory,
+ TApprovalPolicyStepApproversDALFactory,
+ TApprovalPolicyStepsDALFactory
+} from "@app/services/approval-policy/approval-policy-dal";
import { ApprovalPolicyType } from "@app/services/approval-policy/approval-policy-enums";
import { TProjectDALFactory } from "@app/services/project/project-dal";
import { TUserDALFactory } from "@app/services/user/user-dal";
import { approvalPolicyMembershipVerifierFactory } from "../access-approval-policy/access-approval-policy-fns";
-import { BypasserType } from "../access-approval-policy/access-approval-policy-types";
+import { ApproverType, BypasserType } from "../access-approval-policy/access-approval-policy-types";
import { TSecretApprovalPolicyDALFactory } from "../secret-approval-policy/secret-approval-policy-dal";
-import { TCreateSapDTO } from "../secret-approval-policy/secret-approval-policy-types";
+import { TCreateSapDTO, TUpdateSapDTO } from "../secret-approval-policy/secret-approval-policy-types";
+import { TSecretChangePolicyEnvironment } from "./secret-change-policy-bridge-types";
import { TApprovalPolicySecretEnvironmentDALFactory } from "./secret-change-policy-environment-dal";
type TSecretChangePolicyFnsFactoryDep = {
- approvalPolicyDAL: Pick<TApprovalPolicyDALFactory, "findOne">;
+ approvalPolicyDAL: Pick<TApprovalPolicyDALFactory, "findOne" | "findByIdForUpdate" | "updateById" | "transaction">;
+ approvalPolicyStepsDAL: Pick<TApprovalPolicyStepsDALFactory, "findOne" | "create" | "updateById">;
+ approvalPolicyStepApproversDAL: Pick<TApprovalPolicyStepApproversDALFactory, "insertMany" | "delete">;
+ approvalPolicyBypassersDAL: Pick<TApprovalPolicyBypassersDALFactory, "insertMany" | "delete">;
approvalPolicySecretEnvironmentDAL: Pick<
TApprovalPolicySecretEnvironmentDALFactory,
- "findPolicyByEnvIdAndSecretPath"
+ "findPolicyByEnvIdAndSecretPath" | "findEnvironmentsByPolicyId" | "insertMany" | "delete"
>;
secretApprovalPolicyDAL: Pick<TSecretApprovalPolicyDALFactory, "findPolicyByEnvIdAndSecretPath">;
projectDAL: Pick<TProjectDALFactory, "findEffectiveProjectSubjectsMembership">;
userDAL: Pick<TUserDALFactory, "find">;
};
+type TUpdatePolicyInput = Pick<
+ TUpdateSapDTO,
+ "name" | "approvals" | "secretPath" | "enforcementLevel" | "allowedSelfApprovals" | "bypassForMachineIdentities"
+> & {
+ policy: TApprovalPolicies;
+ requestedEnvs?: TSecretChangePolicyEnvironment[];
+ approverCount: number;
+ userApproverIds: string[];
+ groupApprovers: string[];
+ bypasserUserIds: string[];
+ groupBypassers: string[];
+};
+
+const SecretChangePolicyConstraintsSchema = z
+ .object({
+ constraints: z.object({ allowedSelfApprovals: z.boolean().optional() }).passthrough().optional()
+ })
+ .passthrough();
+
+const readConstraints = (policy: TApprovalPolicies) => {
+ const parsed = SecretChangePolicyConstraintsSchema.safeParse(policy.constraints);
+ return parsed.success ? (parsed.data.constraints ?? {}) : {};
+};
+
+export const splitApprovers = (approvers: TCreateSapDTO["approvers"]) => ({
+ groupApprovers: approvers
+ .filter((approver) => approver.type === ApproverType.Group)
+ .map((approver) => approver.id)
+ .filter(Boolean) as string[],
+ userApprovers: approvers
+ .filter((approver) => approver.type === ApproverType.User)
+ .map((approver) => approver.id)
+ .filter(Boolean) as string[],
+ userApproverNames: approvers
+ .map((approver) => (approver.type === ApproverType.User ? approver.username : undefined))
+ .filter(Boolean) as string[]
+});
+
export const secretChangePolicyFnsFactory = ({
approvalPolicyDAL,
+ approvalPolicyStepsDAL,
+ approvalPolicyStepApproversDAL,
+ approvalPolicyBypassersDAL,
approvalPolicySecretEnvironmentDAL,
secretApprovalPolicyDAL,
projectDAL,
@@ -43,18 +94,24 @@ export const secretChangePolicyFnsFactory = ({
// Policies are being migrated onto the approval system, so a path is taken whether the policy that
// governs it still lives on the legacy secret approval tables or already lives on the new ones.
- const assertNoPolicyForSecretPath = async ({
- envs,
- secretPath
- }: {
- envs: Pick<TProjectEnvironments, "id" | "slug">[];
- secretPath: string;
- }) => {
+ const assertNoPolicyForSecretPath = async (
+ {
+ envs,
+ secretPath,
+ excludePolicyId
+ }: {
+ envs: Pick<TProjectEnvironments, "id" | "slug">[];
+ secretPath: string;
+ excludePolicyId?: string;
+ },
+ tx?: Knex
+ ) => {
const envIds = envs.map((env) => env.id);
- const [secretChangePolicy, legacyPolicy] = await Promise.all([
- approvalPolicySecretEnvironmentDAL.findPolicyByEnvIdAndSecretPath({ envIds, secretPath }),
- secretApprovalPolicyDAL.findPolicyByEnvIdAndSecretPath({ envIds, secretPath })
- ]);
+ const secretChangePolicy = await approvalPolicySecretEnvironmentDAL.findPolicyByEnvIdAndSecretPath(
+ { envIds, secretPath, excludePolicyId },
+ tx
+ );
+ const legacyPolicy = await secretApprovalPolicyDAL.findPolicyByEnvIdAndSecretPath({ envIds, secretPath }, tx);
const existingPolicy = secretChangePolicy || legacyPolicy;
if (!existingPolicy) return;
@@ -175,12 +232,124 @@ export const secretChangePolicyFnsFactory = ({
}
};
+ const getSecretChangePolicyState = async (policy: TApprovalPolicies, tx?: Knex) => {
+ const envRows = await approvalPolicySecretEnvironmentDAL.findEnvironmentsByPolicyId(policy.id, tx);
+ const step = await approvalPolicyStepsDAL.findOne({ policyId: policy.id }, tx);
+ if (!envRows.length) {
+ throw new NotFoundError({
+ message: `Secret approval policy with ID '${policy.id}' no longer governs any environment`
+ });
+ }
+
+ const constraints = readConstraints(policy);
+ return {
+ step,
+ envs: envRows.map(({ id, name, slug }) => ({ id, name, slug })),
+ secretPath: envRows[0].secretPath,
+ approvals: step?.requiredApprovals ?? 1,
+ allowedSelfApprovals: constraints.allowedSelfApprovals ?? true
+ };
+ };
+
+ const updatePolicy = ({
+ policy,
+ name,
+ approvals,
+ secretPath,
+ enforcementLevel,
+ allowedSelfApprovals,
+ bypassForMachineIdentities,
+ requestedEnvs,
+ approverCount,
+ userApproverIds,
+ groupApprovers,
+ bypasserUserIds,
+ groupBypassers
+ }: TUpdatePolicyInput) =>
+ approvalPolicyDAL.transaction(async (tx) => {
+ // Lock the policy row so concurrent updates serialize; the collision check and the
+ // delete-then-insert rewrites below are only safe against the state read under that lock.
+ const lockedPolicy = await approvalPolicyDAL.findByIdForUpdate(policy.id, tx);
+ if (!lockedPolicy) {
+ throw new NotFoundError({ message: `Secret approval policy with ID '${policy.id}' not found` });
+ }
+ const current = await getSecretChangePolicyState(lockedPolicy, tx);
+
+ const nextApprovals = approvals ?? current.approvals;
+ if (!groupApprovers.length && nextApprovals > approverCount)
+ throw new BadRequestError({ message: "Approvals cannot be greater than approvers" });
+
+ const envs = requestedEnvs ?? current.envs;
+ const nextSecretPath = secretPath ?? current.secretPath;
+ await assertNoPolicyForSecretPath({ envs, secretPath: nextSecretPath, excludePolicyId: policy.id }, tx);
+
+ const updateDoc: Parameters<typeof approvalPolicyDAL.updateById>[1] = {};
+ if (name !== undefined) updateDoc.name = name;
+ if (enforcementLevel !== undefined) updateDoc.enforcementLevel = enforcementLevel;
+ if (bypassForMachineIdentities !== undefined) updateDoc.bypassForMachineIdentities = bypassForMachineIdentities;
+ if (allowedSelfApprovals !== undefined) {
+ updateDoc.constraints = {
+ version: 1,
+ constraints: { ...readConstraints(lockedPolicy), allowedSelfApprovals }
+ };
+ }
+ const doc = Object.keys(updateDoc).length
+ ? await approvalPolicyDAL.updateById(policy.id, updateDoc, tx)
+ : lockedPolicy;
+
+ let { step } = current;
+ if (!step) {
+ step = await approvalPolicyStepsDAL.create(
+ { policyId: policy.id, stepNumber: 1, requiredApprovals: nextApprovals },
+ tx
+ );
+ } else if (approvals !== undefined) {
+ step = await approvalPolicyStepsDAL.updateById(step.id, { requiredApprovals: approvals }, tx);
+ }
+
+ await approvalPolicyStepApproversDAL.delete({ policyStepId: step.id }, tx);
+ await approvalPolicyStepApproversDAL.insertMany(
+ [
+ ...userApproverIds.map((userId) => ({ policyStepId: step.id, userId, groupId: null })),
+ ...groupApprovers.map((groupId) => ({ policyStepId: step.id, userId: null, groupId }))
+ ],
+ tx
+ );
+
+ if (requestedEnvs || secretPath !== undefined) {
+ await approvalPolicySecretEnvironmentDAL.delete({ policyId: policy.id }, tx);
+ await approvalPolicySecretEnvironmentDAL.insertMany(
+ envs.map((env) => ({ policyId: policy.id, envId: env.id, secretPath: nextSecretPath })),
+ tx
+ );
+ }
+
+ await approvalPolicyBypassersDAL.delete({ policyId: policy.id }, tx);
+ await approvalPolicyBypassersDAL.insertMany(
+ [
+ ...bypasserUserIds.map((userId) => ({ policyId: policy.id, userId, groupId: null })),
+ ...groupBypassers.map((groupId) => ({ policyId: policy.id, userId: null, groupId }))
+ ],
+ tx
+ );
+
+ return {
+ policy: doc,
+ envs,
+ approvals: nextApprovals,
+ secretPath: nextSecretPath,
+ allowedSelfApprovals: allowedSelfApprovals ?? current.allowedSelfApprovals
+ };
+ });
+
return {
findSecretChangePolicy,
findSecretChangePolicyBySecretPath,
assertNoPolicyForSecretPath,
resolveBypassers,
resolveApproverUserIds,
- verifyPolicyActorsMembership
+ verifyPolicyActorsMembership,
+ getSecretChangePolicyState,
+ updatePolicy
};
};
diff --git a/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-service.test.ts b/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-service.test.ts
index 69f5888ec2..ba6125b6f2 100644
--- a/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-service.test.ts
+++ b/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-service.test.ts
@@ -1,4 +1,5 @@
import { createMongoAbility, ForbiddenError } from "@casl/ability";
+import { Knex } from "knex";
import { describe, expect, test, vi } from "vitest";
import { conditionsMatcher } from "@app/lib/casl";
@@ -15,14 +16,46 @@ const ORG_ID = "org-1";
const PROJECT_ID = "project-1";
const ENV_DEV = { id: "env-dev", name: "Development", slug: "dev", projectId: PROJECT_ID };
const ENV_PROD = { id: "env-prod", name: "Production", slug: "prod", projectId: PROJECT_ID };
-const TX = { isTx: true };
+const TX = { isTx: true } as unknown as Knex;
const allowCreate = createMongoAbility<ProjectPermissionSet>(
[{ action: ProjectPermissionActions.Create, subject: ProjectPermissionSub.SecretApproval }],
{ conditionsMatcher }
);
+const allowEdit = createMongoAbility<ProjectPermissionSet>(
+ [{ action: ProjectPermissionActions.Edit, subject: ProjectPermissionSub.SecretApproval }],
+ { conditionsMatcher }
+);
+const allowDelete = createMongoAbility<ProjectPermissionSet>(
+ [{ action: ProjectPermissionActions.Delete, subject: ProjectPermissionSub.SecretApproval }],
+ { conditionsMatcher }
+);
const denyAll = createMongoAbility<ProjectPermissionSet>([], { conditionsMatcher });
+const POLICY_ROW = {
+ id: "policy-1",
+ projectId: PROJECT_ID,
+ organizationId: ORG_ID,
+ type: ApprovalPolicyType.SecretChange,
+ name: "dev-policy",
+ enforcementLevel: EnforcementLevel.Hard,
+ bypassForMachineIdentities: false,
+ conditions: { version: 1, conditions: [] },
+ constraints: { version: 1, constraints: { allowedSelfApprovals: true } },
+ createdAt: new Date("2026-01-01"),
+ updatedAt: new Date("2026-01-01"),
+ scopeType: null,
+ scopeId: null
+};
+const STEP_ROW = { id: "step-1", policyId: "policy-1", stepNumber: 1, requiredApprovals: 1 };
+const toEnvRow = (env: typeof ENV_DEV, secretPath = "/") => ({
+ id: env.id,
+ name: env.name,
+ slug: env.slug,
+ secretPath
+});
+const toPolicyEnv = (env: typeof ENV_DEV) => ({ id: env.id, name: env.name, slug: env.slug });
+
const ctx = {
actor: ActorType.USER,
actorId: "actor-1",
@@ -35,8 +68,9 @@ const ctx = {
type TMembership = { effectiveUserIds: string[]; effectiveGroupIds: string[] };
type TExistingPolicy = { id: string; environments: { id: string }[] };
+type TEnvRow = ReturnType<typeof toEnvRow>;
-// Only the collaborators createSecretChangePolicy touches; everything else is left undefined so an
+// Only the collaborators the service touches; everything else is left undefined so an
// unexpected reach shows up as a crash rather than a silent pass.
const buildService = ({
permission = allowCreate,
@@ -45,14 +79,18 @@ const buildService = ({
users = [] as { id: string; username: string }[],
existingPolicy = undefined as TExistingPolicy | undefined,
existingLegacyPolicy = undefined as TExistingPolicy | undefined,
- memberships = [{ effectiveUserIds: ["user-1"], effectiveGroupIds: [] }] as TMembership[]
+ memberships = [{ effectiveUserIds: ["user-1"], effectiveGroupIds: [] }] as TMembership[],
+ policyRow = undefined as typeof POLICY_ROW | undefined,
+ envRows = [toEnvRow(ENV_DEV)] as TEnvRow[],
+ step = STEP_ROW as typeof STEP_ROW | null
} = {}) => {
const findEffectiveProjectSubjectsMembership = vi.fn();
memberships.forEach((membership) => findEffectiveProjectSubjectsMembership.mockResolvedValueOnce(membership));
const deps = {
approvalPolicyDAL: {
- findOne: vi.fn().mockResolvedValue(undefined),
+ findOne: vi.fn().mockResolvedValue(policyRow),
+ findByIdForUpdate: vi.fn().mockResolvedValue(policyRow),
create: vi.fn((row: Record<string, unknown>) =>
Promise.resolve({
id: "policy-1",
@@ -61,16 +99,28 @@ const buildService = ({
...row
})
),
+ updateById: vi.fn((_id: string, row: Record<string, unknown>) => Promise.resolve({ ...policyRow, ...row })),
+ deleteById: vi.fn().mockResolvedValue(policyRow),
transaction: vi.fn((cb: (tx: unknown) => unknown) => Promise.resolve(cb(TX)))
},
approvalPolicyStepsDAL: {
- create: vi.fn((row: Record<string, unknown>) => Promise.resolve({ id: "step-1", ...row }))
+ create: vi.fn((row: Record<string, unknown>) => Promise.resolve({ id: "step-1", ...row })),
+ findOne: vi.fn().mockResolvedValue(step ?? undefined),
+ updateById: vi.fn((_id: string, row: Record<string, unknown>) => Promise.resolve({ ...step, ...row }))
+ },
+ approvalPolicyStepApproversDAL: {
+ insertMany: vi.fn((rows: unknown[]) => Promise.resolve(rows)),
+ delete: vi.fn().mockResolvedValue([])
+ },
+ approvalPolicyBypassersDAL: {
+ insertMany: vi.fn((rows: unknown[]) => Promise.resolve(rows)),
+ delete: vi.fn().mockResolvedValue([])
},
- approvalPolicyStepApproversDAL: { insertMany: vi.fn((rows: unknown[]) => Promise.resolve(rows)) },
- approvalPolicyBypassersDAL: { insertMany: vi.fn((rows: unknown[]) => Promise.resolve(rows)) },
approvalPolicySecretEnvironmentDAL: {
insertMany: vi.fn((rows: unknown[]) => Promise.resolve(rows)),
- findPolicyByEnvIdAndSecretPath: vi.fn().mockResolvedValue(existingPolicy)
+ delete: vi.fn().mockResolvedValue([]),
+ findPolicyByEnvIdAndSecretPath: vi.fn().mockResolvedValue(existingPolicy),
+ findEnvironmentsByPolicyId: vi.fn().mockResolvedValue(envRows)
},
secretApprovalPolicyDAL: { findPolicyByEnvIdAndSecretPath: vi.fn().mockResolvedValue(existingLegacyPolicy) },
projectEnvDAL: {
@@ -96,6 +146,25 @@ const buildService = ({
type TService = ReturnType<typeof buildService>["service"];
type TCreateInput = Parameters<TService["createSecretChangePolicy"]>[0];
+type TUpdateInput = Parameters<TService["updateSecretChangePolicy"]>[0];
+
+const update = (service: TService, overrides: Partial<TUpdateInput> = {}) =>
+ service.updateSecretChangePolicy({
+ ...ctx,
+ secretPolicyId: "policy-1",
+ approvers: [{ type: ApproverType.User, id: "user-1" }],
+ ...overrides
+ });
+
+const remove = (service: TService) => service.deleteSecretChangePolicy({ ...ctx, secretPolicyId: "policy-1" });
+
+const expectNoWrites = (deps: ReturnType<typeof buildService>["deps"]) => {
+ expect(deps.approvalPolicyDAL.updateById).not.toHaveBeenCalled();
+ expect(deps.approvalPolicyStepsDAL.updateById).not.toHaveBeenCalled();
+ expect(deps.approvalPolicyStepApproversDAL.delete).not.toHaveBeenCalled();
+ expect(deps.approvalPolicySecretEnvironmentDAL.delete).not.toHaveBeenCalled();
+ expect(deps.approvalPolicyBypassersDAL.delete).not.toHaveBeenCalled();
+};
const create = (service: TService, overrides: Partial<TCreateInput> = {}) =>
service.createSecretChangePolicy({
@@ -177,10 +246,10 @@ describe("secretChangePolicyBridge createSecretChangePolicy", () => {
});
await expect(create(service)).rejects.toThrow("A policy for secret path '/' already exists in environment 'dev'");
- expect(deps.approvalPolicySecretEnvironmentDAL.findPolicyByEnvIdAndSecretPath).toHaveBeenCalledWith({
- envIds: [ENV_DEV.id],
- secretPath: "/"
- });
+ expect(deps.approvalPolicySecretEnvironmentDAL.findPolicyByEnvIdAndSecretPath).toHaveBeenCalledWith(
+ { envIds: [ENV_DEV.id], secretPath: "/" },
+ undefined
+ );
expect(deps.approvalPolicyDAL.transaction).not.toHaveBeenCalled();
});
@@ -190,10 +259,10 @@ describe("secretChangePolicyBridge createSecretChangePolicy", () => {
});
await expect(create(service)).rejects.toThrow("A policy for secret path '/' already exists in environment 'dev'");
- expect(deps.secretApprovalPolicyDAL.findPolicyByEnvIdAndSecretPath).toHaveBeenCalledWith({
- envIds: [ENV_DEV.id],
- secretPath: "/"
- });
+ expect(deps.secretApprovalPolicyDAL.findPolicyByEnvIdAndSecretPath).toHaveBeenCalledWith(
+ { envIds: [ENV_DEV.id], secretPath: "/" },
+ undefined
+ );
expect(deps.approvalPolicyDAL.transaction).not.toHaveBeenCalled();
});
@@ -338,3 +407,295 @@ describe("secretChangePolicyBridge createSecretChangePolicy", () => {
});
});
});
+
+describe("secretChangePolicyBridge updateSecretChangePolicy", () => {
+ test("rejects a policy id that does not live on the approval system", async () => {
+ const { service, deps } = buildService({ permission: allowEdit });
+
+ const result = update(service);
+ await expect(result).rejects.toBeInstanceOf(NotFoundError);
+ await expect(result).rejects.toThrow("Secret approval policy with ID 'policy-1' not found");
+ expect(deps.approvalPolicyDAL.transaction).not.toHaveBeenCalled();
+ });
+
+ test("rejects an actor without edit permission on secret approvals", async () => {
+ const { service, deps } = buildService({ permission: denyAll, policyRow: POLICY_ROW });
+
+ await expect(update(service)).rejects.toBeInstanceOf(ForbiddenError);
+ expect(deps.approvalPolicyDAL.transaction).not.toHaveBeenCalled();
+ });
+
+ test("rejects when the plan does not include secret approvals", async () => {
+ const { service, deps } = buildService({
+ permission: allowEdit,
+ policyRow: POLICY_ROW,
+ plan: { secretApproval: false }
+ });
+
+ await expect(update(service)).rejects.toThrow(
+ "Failed to update secret approval policy due to plan restriction. Upgrade plan to update secret approval policy."
+ );
+ expect(deps.approvalPolicyDAL.transaction).not.toHaveBeenCalled();
+ });
+
+ test("rejects approvals greater than the number of user approvers", async () => {
+ const { service, deps } = buildService({ permission: allowEdit, policyRow: POLICY_ROW });
+
+ await expect(update(service, { approvals: 2 })).rejects.toThrow("Approvals cannot be greater than approvers");
+ expectNoWrites(deps);
+ });
+
+ test("rejects an environment slug that does not exist in the project", async () => {
+ const { service, deps } = buildService({ permission: allowEdit, policyRow: POLICY_ROW, envs: [ENV_DEV] });
+
+ const result = update(service, { environments: ["dev", "staging"] });
+ await expect(result).rejects.toBeInstanceOf(NotFoundError);
+ await expect(result).rejects.toThrow("One or more environments not found: staging");
+ expect(deps.approvalPolicyDAL.transaction).not.toHaveBeenCalled();
+ });
+
+ test("rejects an empty environment list", async () => {
+ const { service, deps } = buildService({ permission: allowEdit, policyRow: POLICY_ROW });
+
+ await expect(update(service, { environments: [] })).rejects.toThrow("At least one environment must be provided");
+ expect(deps.approvalPolicyDAL.transaction).not.toHaveBeenCalled();
+ });
+
+ test("rejects moving onto a path another approval system policy already governs, excluding itself", async () => {
+ const { service, deps } = buildService({
+ permission: allowEdit,
+ policyRow: POLICY_ROW,
+ existingPolicy: { id: "other-policy", environments: [{ id: ENV_DEV.id }] }
+ });
+
+ await expect(update(service, { secretPath: "/shared" })).rejects.toThrow(
+ "A policy for secret path '/shared' already exists in environment 'dev'"
+ );
+ expect(deps.approvalPolicySecretEnvironmentDAL.findPolicyByEnvIdAndSecretPath).toHaveBeenCalledWith(
+ { envIds: [ENV_DEV.id], secretPath: "/shared", excludePolicyId: "policy-1" },
+ TX
+ );
+ expectNoWrites(deps);
+ });
+
+ test("rejects moving onto a path the legacy secret approval tables already govern", async () => {
+ const { service, deps } = buildService({
+ permission: allowEdit,
+ policyRow: POLICY_ROW,
+ existingLegacyPolicy: { id: "legacy-policy", environments: [{ id: ENV_PROD.id }] }
+ });
+
+ await expect(update(service, { environments: ["dev", "prod"] })).rejects.toThrow(
+ "A policy for secret path '/' already exists in environment 'prod'"
+ );
+ expect(deps.secretApprovalPolicyDAL.findPolicyByEnvIdAndSecretPath).toHaveBeenCalledWith(
+ { envIds: [ENV_DEV.id, ENV_PROD.id], secretPath: "/" },
+ TX
+ );
+ expectNoWrites(deps);
+ });
+
+ test("rejects an approver who is not a project member", async () => {
+ const { service, deps } = buildService({
+ permission: allowEdit,
+ policyRow: POLICY_ROW,
+ memberships: [{ effectiveUserIds: [], effectiveGroupIds: [] }]
+ });
+
+ await expect(update(service)).rejects.toThrow("Some users are not members of the project: user-1");
+ expect(deps.approvalPolicyDAL.transaction).not.toHaveBeenCalled();
+ });
+
+ test("locks the policy row before reading its state and rewriting it", async () => {
+ const { service, deps } = buildService({ permission: allowEdit, policyRow: POLICY_ROW });
+
+ await update(service, { secretPath: "/moved" });
+
+ expect(deps.approvalPolicyDAL.findByIdForUpdate).toHaveBeenCalledWith("policy-1", TX);
+ const lockOrder = deps.approvalPolicyDAL.findByIdForUpdate.mock.invocationCallOrder[0];
+ expect(lockOrder).toBeLessThan(
+ deps.approvalPolicySecretEnvironmentDAL.findEnvironmentsByPolicyId.mock.invocationCallOrder[0]
+ );
+ expect(lockOrder).toBeLessThan(
+ deps.approvalPolicySecretEnvironmentDAL.findPolicyByEnvIdAndSecretPath.mock.invocationCallOrder[0]
+ );
+ expect(lockOrder).toBeLessThan(deps.approvalPolicyStepApproversDAL.delete.mock.invocationCallOrder[0]);
+ expect(deps.approvalPolicySecretEnvironmentDAL.findEnvironmentsByPolicyId).toHaveBeenCalledWith("policy-1", TX);
+ });
+
+ test("rejects when the policy is deleted between the lookup and the lock", async () => {
+ const { service, deps } = buildService({ permission: allowEdit, policyRow: POLICY_ROW });
+ deps.approvalPolicyDAL.findByIdForUpdate.mockResolvedValue(undefined);
+
+ await expect(update(service)).rejects.toBeInstanceOf(NotFoundError);
+ expectNoWrites(deps);
+ });
+
+ test("rewrites only approvers and bypassers when no policy field changes", async () => {
+ const { service, deps } = buildService({ permission: allowEdit, policyRow: POLICY_ROW });
+
+ const policy = await update(service);
+
+ expect(deps.approvalPolicyDAL.updateById).not.toHaveBeenCalled();
+ expect(deps.approvalPolicyStepsDAL.updateById).not.toHaveBeenCalled();
+ expect(deps.approvalPolicySecretEnvironmentDAL.delete).not.toHaveBeenCalled();
+ expect(deps.approvalPolicySecretEnvironmentDAL.insertMany).not.toHaveBeenCalled();
+ expect(deps.approvalPolicyStepApproversDAL.delete).toHaveBeenCalledWith({ policyStepId: "step-1" }, TX);
+ expect(deps.approvalPolicyStepApproversDAL.insertMany).toHaveBeenCalledWith(
+ [{ policyStepId: "step-1", userId: "user-1", groupId: null }],
+ TX
+ );
+ expect(deps.approvalPolicyBypassersDAL.delete).toHaveBeenCalledWith({ policyId: "policy-1" }, TX);
+ expect(deps.approvalPolicyBypassersDAL.insertMany).toHaveBeenCalledWith([], TX);
+ expect(policy).toMatchObject({
+ id: "policy-1",
+ secretPath: "/",
+ approvals: 1,
+ environments: [toPolicyEnv(ENV_DEV)]
+ });
+ });
+
+ test("rewrites the policy, step, approvers, environments and bypassers in one transaction", async () => {
+ const { service, deps } = buildService({
+ permission: allowEdit,
+ policyRow: POLICY_ROW,
+ users: [{ id: "user-2", username: "[email protected]" }],
+ memberships: [
+ { effectiveUserIds: ["user-1", "user-2"], effectiveGroupIds: ["g-1"] },
+ { effectiveUserIds: ["u-3"], effectiveGroupIds: [] }
+ ]
+ });
+
+ const policy = await update(service, {
+ name: "renamed",
+ approvals: 2,
+ enforcementLevel: EnforcementLevel.Soft,
+ allowedSelfApprovals: false,
+ bypassForMachineIdentities: true,
+ secretPath: "/new",
+ environments: ["dev", "prod"],
+ approvers: [
+ { type: ApproverType.User, id: "user-1" },
+ { type: ApproverType.User, username: "[email protected]" },
+ { type: ApproverType.Group, id: "g-1" }
+ ],
+ bypassers: [{ type: BypasserType.User, id: "u-3" }]
+ });
+
+ expect(deps.approvalPolicyDAL.updateById).toHaveBeenCalledWith(
+ "policy-1",
+ {
+ name: "renamed",
+ enforcementLevel: EnforcementLevel.Soft,
+ bypassForMachineIdentities: true,
+ constraints: { version: 1, constraints: { allowedSelfApprovals: false } }
+ },
+ TX
+ );
+ expect(deps.approvalPolicyStepsDAL.updateById).toHaveBeenCalledWith("step-1", { requiredApprovals: 2 }, TX);
+ expect(deps.approvalPolicyStepApproversDAL.delete).toHaveBeenCalledWith({ policyStepId: "step-1" }, TX);
+ expect(deps.approvalPolicyStepApproversDAL.insertMany).toHaveBeenCalledWith(
+ [
+ { policyStepId: "step-1", userId: "user-1", groupId: null },
+ { policyStepId: "step-1", userId: "user-2", groupId: null },
+ { policyStepId: "step-1", userId: null, groupId: "g-1" }
+ ],
+ TX
+ );
+ expect(deps.approvalPolicySecretEnvironmentDAL.delete).toHaveBeenCalledWith({ policyId: "policy-1" }, TX);
+ expect(deps.approvalPolicySecretEnvironmentDAL.insertMany).toHaveBeenCalledWith(
+ [
+ { policyId: "policy-1", envId: ENV_DEV.id, secretPath: "/new" },
+ { policyId: "policy-1", envId: ENV_PROD.id, secretPath: "/new" }
+ ],
+ TX
+ );
+ expect(deps.approvalPolicyBypassersDAL.delete).toHaveBeenCalledWith({ policyId: "policy-1" }, TX);
+ expect(deps.approvalPolicyBypassersDAL.insertMany).toHaveBeenCalledWith(
+ [{ policyId: "policy-1", userId: "u-3", groupId: null }],
+ TX
+ );
+ expect(policy).toEqual({
+ id: "policy-1",
+ name: "renamed",
+ secretPath: "/new",
+ approvals: 2,
+ envId: ENV_DEV.id,
+ createdAt: new Date("2026-01-01"),
+ updatedAt: new Date("2026-01-01"),
+ enforcementLevel: EnforcementLevel.Soft,
+ deletedAt: null,
+ allowedSelfApprovals: false,
+ bypassForMachineIdentities: true,
+ projectId: PROJECT_ID,
+ environments: [toPolicyEnv(ENV_DEV), toPolicyEnv(ENV_PROD)],
+ environment: toPolicyEnv(ENV_DEV)
+ });
+ });
+
+ test("rewrites the environment rows with the current environments when only the path changes", async () => {
+ const { service, deps } = buildService({
+ permission: allowEdit,
+ policyRow: POLICY_ROW,
+ envRows: [toEnvRow(ENV_DEV), toEnvRow(ENV_PROD)]
+ });
+
+ await update(service, { secretPath: "/moved" });
+
+ expect(deps.projectEnvDAL.find).not.toHaveBeenCalled();
+ expect(deps.approvalPolicySecretEnvironmentDAL.insertMany).toHaveBeenCalledWith(
+ [
+ { policyId: "policy-1", envId: ENV_DEV.id, secretPath: "/moved" },
+ { policyId: "policy-1", envId: ENV_PROD.id, secretPath: "/moved" }
+ ],
+ TX
+ );
+ });
+
+ test("recreates the approval step when the policy has none", async () => {
+ const { service, deps } = buildService({ permission: allowEdit, policyRow: POLICY_ROW, step: null });
+
+ await update(service, { approvals: 1 });
+
+ expect(deps.approvalPolicyStepsDAL.create).toHaveBeenCalledWith(
+ { policyId: "policy-1", stepNumber: 1, requiredApprovals: 1 },
+ TX
+ );
+ expect(deps.approvalPolicyStepsDAL.updateById).not.toHaveBeenCalled();
+ });
+});
+
+describe("secretChangePolicyBridge deleteSecretChangePolicy", () => {
+ test("rejects a policy id that does not live on the approval system", async () => {
+ const { service, deps } = buildService({ permission: allowDelete });
+
+ await expect(remove(service)).rejects.toBeInstanceOf(NotFoundError);
+ expect(deps.approvalPolicyDAL.transaction).not.toHaveBeenCalled();
+ });
+
+ test("rejects an actor without delete permission on secret approvals", async () => {
+ const { service, deps } = buildService({ permission: denyAll, policyRow: POLICY_ROW });
+
+ await expect(remove(service)).rejects.toBeInstanceOf(ForbiddenError);
+ expect(deps.approvalPolicyDAL.transaction).not.toHaveBeenCalled();
+ });
+
+ test("hard-deletes the policy and skips the plan check", async () => {
+ const { service, deps } = buildService({ permission: allowDelete, policyRow: POLICY_ROW });
+
+ const policy = await remove(service);
+
+ expect(deps.licenseService.getPlan).not.toHaveBeenCalled();
+ expect(deps.approvalPolicyDAL.deleteById).toHaveBeenCalledWith("policy-1");
+ expect(policy).toMatchObject({
+ id: "policy-1",
+ secretPath: "/",
+ approvals: 1,
+ allowedSelfApprovals: true,
+ projectId: PROJECT_ID,
+ environments: [toPolicyEnv(ENV_DEV)],
+ environment: toPolicyEnv(ENV_DEV)
+ });
+ expect(policy.deletedAt).toBeInstanceOf(Date);
+ });
+});
diff --git a/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-service.ts b/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-service.ts
index f824129495..edb178a7f6 100644
--- a/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-service.ts
+++ b/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-service.ts
@@ -1,6 +1,6 @@
import { ForbiddenError } from "@casl/ability";
-import { ActionProjectType, TApprovalPolicies, TProjectEnvironments } from "@app/db/schemas";
+import { ActionProjectType, TApprovalPolicies } from "@app/db/schemas";
import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service-types";
import { ProjectPermissionActions, ProjectPermissionSub } from "@app/ee/services/permission/project-permission";
import { BadRequestError, NotFoundError } from "@app/lib/errors";
@@ -15,21 +15,27 @@ import { TProjectDALFactory } from "@app/services/project/project-dal";
import { TProjectEnvDALFactory } from "@app/services/project-env/project-env-dal";
import { TUserDALFactory } from "@app/services/user/user-dal";
-import { ApproverType } from "../access-approval-policy/access-approval-policy-types";
import { TLicenseServiceFactory } from "../license/license-service";
import { TSecretApprovalPolicyDALFactory } from "../secret-approval-policy/secret-approval-policy-dal";
-import { secretChangePolicyFnsFactory } from "./secret-change-policy-bridge-fns";
-import { TSecretChangePolicy, TSecretChangePolicyBridgeMethods } from "./secret-change-policy-bridge-types";
+import { secretChangePolicyFnsFactory, splitApprovers } from "./secret-change-policy-bridge-fns";
+import {
+ TSecretChangePolicy,
+ TSecretChangePolicyBridgeMethods,
+ TSecretChangePolicyEnvironment
+} from "./secret-change-policy-bridge-types";
import { TApprovalPolicySecretEnvironmentDALFactory } from "./secret-change-policy-environment-dal";
type TSecretChangePolicyBridgeServiceFactoryDep = {
- approvalPolicyDAL: Pick<TApprovalPolicyDALFactory, "findOne" | "create" | "transaction">;
- approvalPolicyStepsDAL: Pick<TApprovalPolicyStepsDALFactory, "create">;
- approvalPolicyStepApproversDAL: Pick<TApprovalPolicyStepApproversDALFactory, "insertMany">;
- approvalPolicyBypassersDAL: Pick<TApprovalPolicyBypassersDALFactory, "insertMany">;
+ approvalPolicyDAL: Pick<
+ TApprovalPolicyDALFactory,
+ "findOne" | "findByIdForUpdate" | "create" | "updateById" | "deleteById" | "transaction"
+ >;
+ approvalPolicyStepsDAL: Pick<TApprovalPolicyStepsDALFactory, "create" | "findOne" | "updateById">;
+ approvalPolicyStepApproversDAL: Pick<TApprovalPolicyStepApproversDALFactory, "insertMany" | "delete">;
+ approvalPolicyBypassersDAL: Pick<TApprovalPolicyBypassersDALFactory, "insertMany" | "delete">;
approvalPolicySecretEnvironmentDAL: Pick<
TApprovalPolicySecretEnvironmentDALFactory,
- "insertMany" | "findPolicyByEnvIdAndSecretPath"
+ "insertMany" | "delete" | "findPolicyByEnvIdAndSecretPath" | "findEnvironmentsByPolicyId"
>;
secretApprovalPolicyDAL: Pick<TSecretApprovalPolicyDALFactory, "findPolicyByEnvIdAndSecretPath">;
projectEnvDAL: Pick<TProjectEnvDALFactory, "find">;
@@ -63,9 +69,14 @@ export const secretChangePolicyBridgeServiceFactory = ({
assertNoPolicyForSecretPath,
resolveBypassers,
resolveApproverUserIds,
- verifyPolicyActorsMembership
+ verifyPolicyActorsMembership,
+ getSecretChangePolicyState,
+ updatePolicy
} = secretChangePolicyFnsFactory({
approvalPolicyDAL,
+ approvalPolicyStepsDAL,
+ approvalPolicyStepApproversDAL,
+ approvalPolicyBypassersDAL,
approvalPolicySecretEnvironmentDAL,
secretApprovalPolicyDAL,
projectDAL,
@@ -78,8 +89,15 @@ export const secretChangePolicyBridgeServiceFactory = ({
envs,
approvals,
secretPath,
- allowedSelfApprovals
- }: { envs: TProjectEnvironments[]; approvals: number; secretPath: string; allowedSelfApprovals: boolean }
+ allowedSelfApprovals,
+ deletedAt = null
+ }: {
+ envs: TSecretChangePolicyEnvironment[];
+ approvals: number;
+ secretPath: string;
+ allowedSelfApprovals: boolean;
+ deletedAt?: Date | null;
+ }
): TSecretChangePolicy => ({
id: policy.id,
name: policy.name,
@@ -89,7 +107,7 @@ export const secretChangePolicyBridgeServiceFactory = ({
createdAt: policy.createdAt,
updatedAt: policy.updatedAt,
enforcementLevel: policy.enforcementLevel,
- deletedAt: null,
+ deletedAt,
allowedSelfApprovals,
bypassForMachineIdentities: policy.bypassForMachineIdentities ?? false,
projectId: policy.projectId,
@@ -97,6 +115,14 @@ export const secretChangePolicyBridgeServiceFactory = ({
environment: envs[0]
});
+ const $findSecretChangePolicyOrThrow = async (secretPolicyId: string) => {
+ const policy = await findSecretChangePolicy(secretPolicyId);
+ if (!policy) {
+ throw new NotFoundError({ message: `Secret approval policy with ID '${secretPolicyId}' not found` });
+ }
+ return policy;
+ };
+
const createSecretChangePolicy: TSecretChangePolicyBridgeMethods["createSecretChangePolicy"] = async ({
name,
actor,
@@ -114,17 +140,7 @@ export const secretChangePolicyBridgeServiceFactory = ({
allowedSelfApprovals,
bypassForMachineIdentities
}) => {
- const groupApprovers = approvers
- .filter((approver) => approver.type === ApproverType.Group)
- .map((approver) => approver.id)
- .filter(Boolean) as string[];
- const userApprovers = approvers
- .filter((approver) => approver.type === ApproverType.User)
- .map((approver) => approver.id)
- .filter(Boolean) as string[];
- const userApproverNames = approvers
- .map((approver) => (approver.type === ApproverType.User ? approver.username : undefined))
- .filter(Boolean) as string[];
+ const { groupApprovers, userApprovers, userApproverNames } = splitApprovers(approvers);
if (!groupApprovers.length && approvals > approvers.length)
throw new BadRequestError({ message: "Approvals cannot be greater than approvers" });
@@ -227,12 +243,124 @@ export const secretChangePolicyBridgeServiceFactory = ({
return $toSecretChangePolicy(policy, { envs, approvals, secretPath, allowedSelfApprovals });
};
- const updateSecretChangePolicy: TSecretChangePolicyBridgeMethods["updateSecretChangePolicy"] = async () => {
- throw notAvailable();
+ const updateSecretChangePolicy: TSecretChangePolicyBridgeMethods["updateSecretChangePolicy"] = async ({
+ secretPolicyId,
+ name,
+ actor,
+ actorId,
+ actorOrgId,
+ actorAuthMethod,
+ approvals,
+ approvers,
+ bypassers,
+ secretPath,
+ environments,
+ enforcementLevel,
+ allowedSelfApprovals,
+ bypassForMachineIdentities
+ }) => {
+ const { groupApprovers, userApprovers, userApproverNames } = splitApprovers(approvers);
+
+ const policy = await $findSecretChangePolicyOrThrow(secretPolicyId);
+
+ const { permission } = await permissionService.getProjectPermission({
+ actor,
+ actorId,
+ projectId: policy.projectId,
+ actorAuthMethod,
+ actorOrgId,
+ actionProjectType: ActionProjectType.SecretManager
+ });
+ ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Edit, ProjectPermissionSub.SecretApproval);
+
+ const plan = await licenseService.getPlan(actorOrgId);
+ if (!plan.secretApproval) {
+ throw new BadRequestError({
+ message:
+ "Failed to update secret approval policy due to plan restriction. Upgrade plan to update secret approval policy."
+ });
+ }
+
+ let requestedEnvs: TSecretChangePolicyEnvironment[] | undefined;
+ if (environments) {
+ const envSlugs = [...new Set(environments)];
+ if (!envSlugs.length) {
+ throw new BadRequestError({ message: "At least one environment must be provided" });
+ }
+ const foundEnvs = await projectEnvDAL.find({ $in: { slug: envSlugs }, projectId: policy.projectId });
+ if (foundEnvs.length !== envSlugs.length) {
+ const notFoundEnvs = envSlugs.filter((slug) => !foundEnvs.find((el) => el.slug === slug));
+ throw new NotFoundError({ message: `One or more environments not found: ${notFoundEnvs.join(", ")}` });
+ }
+ requestedEnvs = foundEnvs.map(({ id, slug, name: envName }) => ({ id, slug, name: envName }));
+ }
+
+ const { bypasserUserIds, groupBypassers } = await resolveBypassers(bypassers);
+ const userApproverIds = await resolveApproverUserIds({ userApprovers, userApproverNames });
+
+ await verifyPolicyActorsMembership({
+ userApproverIds,
+ groupApprovers,
+ bypasserUserIds,
+ groupBypassers,
+ orgId: actorOrgId,
+ projectId: policy.projectId
+ });
+
+ const updated = await updatePolicy({
+ policy,
+ name,
+ approvals,
+ secretPath,
+ enforcementLevel,
+ allowedSelfApprovals,
+ bypassForMachineIdentities,
+ requestedEnvs,
+ approverCount: approvers.length,
+ userApproverIds,
+ groupApprovers,
+ bypasserUserIds,
+ groupBypassers
+ });
+
+ return $toSecretChangePolicy(updated.policy, updated);
};
- const deleteSecretChangePolicy: TSecretChangePolicyBridgeMethods["deleteSecretChangePolicy"] = async () => {
- throw notAvailable();
+ const deleteSecretChangePolicy: TSecretChangePolicyBridgeMethods["deleteSecretChangePolicy"] = async ({
+ secretPolicyId,
+ actor,
+ actorId,
+ actorOrgId,
+ actorAuthMethod
+ }) => {
+ const policy = await $findSecretChangePolicyOrThrow(secretPolicyId);
+
+ const { permission } = await permissionService.getProjectPermission({
+ actor,
+ actorId,
+ projectId: policy.projectId,
+ actorAuthMethod,
+ actorOrgId,
+ actionProjectType: ActionProjectType.SecretManager
+ });
+ ForbiddenError.from(permission).throwUnlessCan(
+ ProjectPermissionActions.Delete,
+ ProjectPermissionSub.SecretApproval
+ );
+
+ const current = await getSecretChangePolicyState(policy);
+
+ // Legacy delete closes the policy's open requests. Secret change requests are not created on the
+ // approval system yet, so cancelling them moves with the request migration.
+ await approvalPolicyDAL.deleteById(policy.id);
+
+ return $toSecretChangePolicy(policy, {
+ envs: current.envs,
+ approvals: current.approvals,
+ secretPath: current.secretPath,
+ allowedSelfApprovals: current.allowedSelfApprovals,
+ deletedAt: new Date()
+ });
};
const getSecretChangePolicy: TSecretChangePolicyBridgeMethods["getSecretChangePolicy"] = async () => {
diff --git a/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-types.ts b/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-types.ts
index c17fb6a46a..9d9e6ad08b 100644
--- a/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-types.ts
+++ b/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-bridge-types.ts
@@ -11,10 +11,12 @@ import {
TUpdateSapDTO
} from "../secret-approval-policy/secret-approval-policy-types";
+export type TSecretChangePolicyEnvironment = Pick<TProjectEnvironments, "id" | "name" | "slug">;
+
export type TSecretChangePolicy = TSecretApprovalPolicies & {
projectId: string;
- environments: TProjectEnvironments[];
- environment: TProjectEnvironments;
+ environments: TSecretChangePolicyEnvironment[];
+ environment: TSecretChangePolicyEnvironment;
};
export type TSecretChangePolicyBridgeMethods = {
diff --git a/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-environment-dal.ts b/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-environment-dal.ts
index 2110e5bcff..6aa2479717 100644
--- a/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-environment-dal.ts
+++ b/backend/src/ee/services/secret-change-policy-bridge/secret-change-policy-environment-dal.ts
@@ -57,5 +57,26 @@ export const approvalPolicySecretEnvironmentDALFactory = (db: TDbClient) => {
}
};
- return { ...orm, findPolicyByEnvIdAndSecretPath };
+ const findEnvironmentsByPolicyId = async (policyId: string, tx?: Knex) => {
+ try {
+ const docs = await (tx || db.replicaNode())(TableName.ApprovalPolicySecretEnvironment)
+ .join(TableName.Environment, function joinActiveEnvForSecretChangePolicy() {
+ this.on(`${TableName.ApprovalPolicySecretEnvironment}.envId`, `${TableName.Environment}.id`).andOnNull(
+ `${TableName.Environment}.deleteAfter`
+ );
+ })
+ .where(`${TableName.ApprovalPolicySecretEnvironment}.policyId`, policyId)
+ .select(db.ref("id").withSchema(TableName.Environment))
+ .select(db.ref("name").withSchema(TableName.Environment))
+ .select(db.ref("slug").withSchema(TableName.Environment))
+ .select(db.ref("secretPath").withSchema(TableName.ApprovalPolicySecretEnvironment))
+ .orderBy(`${TableName.Environment}.position`, "asc");
+
+ return docs as { id: string; name: string; slug: string; secretPath: string }[];
+ } catch (error) {
+ throw new DatabaseError({ error, name: "findEnvironmentsByPolicyId" });
+ }
+ };
+
+ return { ...orm, findPolicyByEnvIdAndSecretPath, findEnvironmentsByPolicyId };
};
diff --git a/backend/src/services/approval-policy/approval-policy-dal.ts b/backend/src/services/approval-policy/approval-policy-dal.ts
index 9b3f044403..5a176e9f80 100644
--- a/backend/src/services/approval-policy/approval-policy-dal.ts
+++ b/backend/src/services/approval-policy/approval-policy-dal.ts
@@ -13,6 +13,14 @@ export type TApprovalPolicyDALFactory = ReturnType<typeof approvalPolicyDALFacto
export const approvalPolicyDALFactory = (db: TDbClient) => {
const orm = ormify(db, TableName.ApprovalPolicies);
+ const findByIdForUpdate = async (id: string, tx: Knex) => {
+ try {
+ return await tx(TableName.ApprovalPolicies).where({ id }).forUpdate().first();
+ } catch (error) {
+ throw new DatabaseError({ error, name: "FindApprovalPolicyByIdForUpdate" });
+ }
+ };
+
const findStepsByPolicyId = async (policyId: string) => {
try {
const dbInstance = db.replicaNode();
@@ -486,6 +494,7 @@ export const approvalPolicyDALFactory = (db: TDbClient) => {
return {
...orm,
+ findByIdForUpdate,
findStepsByPolicyId,
findBypassersByPolicyId,
findBypassersByPolicyIds,