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