Skip to content

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

feat: add implementation for review secret change

adilsonbaf096b98987
diff --git a/backend/e2e-test/routes/v1/secret-approval-request-bridge.spec.ts b/backend/e2e-test/routes/v1/secret-approval-request-bridge.spec.ts
index 1fcb10432b..4a35328949 100644
--- a/backend/e2e-test/routes/v1/secret-approval-request-bridge.spec.ts
+++ b/backend/e2e-test/routes/v1/secret-approval-request-bridge.spec.ts
@@ -233,14 +233,20 @@ describe("Secret approval request bridge routing", () => {
{ approverUserId: seedData1.id, decision: ApprovalStatus.APPROVED }
]);
- const responses = await Promise.all([
- getRequest(approval.id),
- setRequestStatus(approval.id, RequestState.Closed),
- mergeRequest(approval.id)
- ]);
- responses.forEach((res) => {
+ for await (const res of [getRequest(approval.id), setRequestStatus(approval.id, RequestState.Closed)]) {
expect(res.statusCode).toBe(400);
expect(res.json().message).toBe(BRIDGE_MESSAGE);
+ }
+
+ const mergeRes = await mergeRequest(approval.id);
+ expect(mergeRes.statusCode).toBe(200);
+ expect(mergeRes.json().approval).toMatchObject({ hasMerged: true, status: RequestState.Closed });
+ expect(await db(TableName.ApprovalRequests).where({ id: approval.id }).first()).toMatchObject({
+ status: ApprovalRequestStatus.Closed
+ });
+ expect(await db(TableName.SecretChangeRequests).where({ approvalRequestId: approval.id }).first()).toMatchObject({
+ hasMerged: true,
+ statusChangedByUserId: seedData1.id
});
});
});
diff --git a/backend/e2e-test/routes/v1/secret-approval-request-lifecycle.spec.ts b/backend/e2e-test/routes/v1/secret-approval-request-lifecycle.spec.ts
index 47c9e5a2c0..35f246344c 100644
--- a/backend/e2e-test/routes/v1/secret-approval-request-lifecycle.spec.ts
+++ b/backend/e2e-test/routes/v1/secret-approval-request-lifecycle.spec.ts
@@ -261,19 +261,109 @@ describe("Secret change request lifecycle on a policy on the global approval sys
]);
});
- test("reading details and merging are refused until the bridge supports them", async () => {
+ test("reading details is refused until the bridge supports it", async () => {
for await (const requestId of requestIds) {
- const responses = await Promise.all([getRequest(requestId), mergeRequest(requestId)]);
- for (const res of responses) {
- expect(res.statusCode).toBe(400);
- expect(res.json().message).toBe(BRIDGE_MESSAGE);
- }
-
- expect(await getDb()(TableName.ApprovalRequests).where({ id: requestId }).first()).toMatchObject({
- status: ApprovalRequestStatus.Open
- });
+ const res = await getRequest(requestId);
+ expect(res.statusCode).toBe(400);
+ expect(res.json().message).toBe(BRIDGE_MESSAGE);
}
});
+
+ test("a request without enough approvals cannot be merged", async () => {
+ const [createRequestId] = requestIds;
+ const db = getDb();
+
+ const mergeRes = await mergeRequest(createRequestId);
+ expect(mergeRes.statusCode).toBe(400);
+ expect(mergeRes.json().message).toMatch(/needs 1 approval\(s\) on step 1 and has 0/);
+
+ expect(await db(TableName.ApprovalRequests).where({ id: createRequestId }).first()).toMatchObject({
+ status: ApprovalRequestStatus.Open
+ });
+ expect(
+ await db(TableName.SecretChangeRequests).where({ approvalRequestId: createRequestId }).first()
+ ).toMatchObject({ hasMerged: false, statusChangedByUserId: null });
+ });
+
+ test("merging the approved create request closes it on the global tables and creates the secret", async () => {
+ const [createRequestId] = requestIds;
+ const db = getDb();
+
+ expect((await reviewRequest(createRequestId, ApprovalStatus.APPROVED)).statusCode).toBe(200);
+
+ const mergeRes = await mergeRequest(createRequestId);
+ expect(mergeRes.statusCode).toBe(200);
+ expect(mergeRes.json().approval).toMatchObject({
+ id: createRequestId,
+ hasMerged: true,
+ status: RequestState.Closed,
+ statusChangedByUserId: seedData1.id,
+ conflicts: []
+ });
+
+ expect(await db(TableName.ApprovalRequests).where({ id: createRequestId }).first()).toMatchObject({
+ status: ApprovalRequestStatus.Closed
+ });
+ const change = await db(TableName.SecretChangeRequests).where({ approvalRequestId: createRequestId }).first();
+ expect(change).toMatchObject({ hasMerged: true, statusChangedByUserId: seedData1.id, conflicts: [] });
+
+ const secretRes = await getSecret(secretPath, NEW_KEY);
+ expect(secretRes.statusCode).toBe(200);
+ expect(secretRes.json().secret.secretValue).toBe("value");
+
+ const [commit] = await db(TableName.SecretApprovalRequestSecretV2).where({ secretChangeId: change?.id });
+ expect(commit.secretId).toBe(secretRes.json().secret.id);
+ });
+
+ test("a merged request cannot be merged again", async () => {
+ const [createRequestId] = requestIds;
+
+ const mergeRes = await mergeRequest(createRequestId);
+ expect(mergeRes.statusCode).toBe(400);
+ expect(mergeRes.json().message).toBe("This secret approval request has already been merged.");
+ });
+
+ test("merging the approved update request changes the secret value", async () => {
+ const [, updateRequestId] = requestIds;
+
+ const mergeRes = await mergeRequest(updateRequestId);
+ expect(mergeRes.statusCode).toBe(200);
+ expect(mergeRes.json().approval).toMatchObject({ hasMerged: true, status: RequestState.Closed, conflicts: [] });
+
+ expect((await getSecret(secretPath, BASE_KEY)).json().secret.secretValue).toBe("changed");
+ });
+
+ test("merging the delete request removes the secret and a later update on it merges with a conflict", async () => {
+ const [, , deleteRequestId] = requestIds;
+ const db = getDb();
+
+ const staleUpdateRes = await updateSecret(secretPath, BASE_KEY, "stale");
+ expect(staleUpdateRes.statusCode).toBe(200);
+ const staleUpdateRequestId = staleUpdateRes.json().approval.id as string;
+ requestIds.push(staleUpdateRequestId);
+ expect((await reviewRequest(staleUpdateRequestId, ApprovalStatus.APPROVED)).statusCode).toBe(200);
+ const staleChange = await db(TableName.SecretChangeRequests)
+ .where({ approvalRequestId: staleUpdateRequestId })
+ .first();
+ const [staleCommit] = await db(TableName.SecretApprovalRequestSecretV2).where({ secretChangeId: staleChange?.id });
+
+ const deleteMergeRes = await mergeRequest(deleteRequestId);
+ expect(deleteMergeRes.statusCode).toBe(200);
+ expect(deleteMergeRes.json().approval).toMatchObject({ hasMerged: true, status: RequestState.Closed });
+ expect((await getSecret(secretPath, BASE_KEY)).statusCode).toBe(404);
+
+ const staleMergeRes = await mergeRequest(staleUpdateRequestId);
+ expect(staleMergeRes.statusCode).toBe(200);
+ expect(staleMergeRes.json().approval).toMatchObject({
+ hasMerged: true,
+ status: RequestState.Closed,
+ conflicts: [{ op: SecretOperations.Update, secretId: staleCommit.id }]
+ });
+ expect(
+ await db(TableName.SecretChangeRequests).where({ approvalRequestId: staleUpdateRequestId }).first()
+ ).toMatchObject({ hasMerged: true, conflicts: [{ op: SecretOperations.Update, secretId: staleCommit.id }] });
+ expect((await getSecret(secretPath, BASE_KEY)).statusCode).toBe(404);
+ });
});
describe("Secret approval request lifecycle on a policy on the legacy approval system", () => {
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-creation-fns.test.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-creation-fns.test.ts
index 9853e03848..180d4c154c 100644
--- a/backend/src/ee/services/secret-approval-request/secret-approval-request-creation-fns.test.ts
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-creation-fns.test.ts
@@ -6,6 +6,7 @@ import { ActorType } from "@app/services/auth/auth-type";
import { SecretOperations } from "@app/services/secret/secret-types";
import { secretApprovalRequestCreationFnsFactory } from "./secret-approval-request-creation-fns";
+import { TSecretApprovalRequestCommit } from "./secret-approval-request-types";
const TX = { isTx: "caller" } as unknown as Knex;
const OWN_TX = { isTx: "own" } as unknown as Knex;
@@ -151,7 +152,9 @@ describe("createSecretApprovalRequestV2Bridge", () => {
});
describe("createSecretApprovalRequest", () => {
- const commits = [{ op: SecretOperations.Delete, secretBlindIndex: "blind-1", secretId: "secret-1" }];
+ const commits = [
+ { op: SecretOperations.Delete, secretBlindIndex: "blind-1", secretId: "secret-1" }
+ ] as unknown as TSecretApprovalRequestCommit[];
test("writes the request and its v1 commits inside the caller's transaction", async () => {
const { fns, secretApprovalRequestDAL, secretApprovalRequestSecretDAL } = build();
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-merge-fns.test.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-merge-fns.test.ts
new file mode 100644
index 0000000000..8ac7cafef7
--- /dev/null
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-merge-fns.test.ts
@@ -0,0 +1,170 @@
+import { describe, expect, test, vi } from "vitest";
+
+import { EventType } from "@app/ee/services/audit-log/audit-log-types";
+import { AUDIT_LOG_SENSITIVE_VALUE } from "@app/lib/config/const";
+import { ActorType } from "@app/services/auth/auth-type";
+import { SecretOperations } from "@app/services/secret/secret-types";
+
+import {
+ buildRequestedByActor,
+ buildSecretMutationEvents,
+ secretApprovalRequestMergeFnsFactory,
+ TMergedSecretsV2Bridge,
+ TSecretApprovalBridgeCommit
+} from "./secret-approval-request-merge-fns";
+
+const commit = (overrides: Record<string, unknown>) =>
+ ({
+ id: `commit-${String(overrides.key)}`,
+ tags: [],
+ secretVersion: undefined,
+ secret: undefined,
+ ...overrides
+ }) as unknown as TSecretApprovalBridgeCommit;
+
+const buildFns = (liveSecrets: { id: string; key: string }[]) => {
+ const secretV2BridgeDAL = { findBySecretKeys: vi.fn().mockResolvedValue(liveSecrets) };
+ const fns = secretApprovalRequestMergeFnsFactory({
+ secretV2BridgeDAL
+ } as unknown as Parameters<typeof secretApprovalRequestMergeFnsFactory>[0]);
+ return { fns, secretV2BridgeDAL };
+};
+
+describe("detectSecretApprovalCommitConflicts", () => {
+ test("splits commits by operation and keeps deletes unchecked", async () => {
+ const { fns, secretV2BridgeDAL } = buildFns([]);
+ const creates = commit({ op: SecretOperations.Create, key: "A" });
+ const deletes = commit({ op: SecretOperations.Delete, key: "B", secretId: "secret-b" });
+
+ const result = await fns.detectSecretApprovalCommitConflicts({ folderId: "folder-1", commits: [creates, deletes] });
+
+ expect(result).toEqual({ conflicts: [], creates: [creates], updates: [], deletes: [deletes] });
+ expect(secretV2BridgeDAL.findBySecretKeys).toHaveBeenCalledTimes(1);
+ });
+
+ test("marks a create whose key now exists as a conflict keyed by the commit row", async () => {
+ const { fns } = buildFns([{ id: "secret-a", key: "A" }]);
+ const taken = commit({ op: SecretOperations.Create, key: "A" });
+ const free = commit({ op: SecretOperations.Create, key: "C" });
+
+ const result = await fns.detectSecretApprovalCommitConflicts({ folderId: "folder-1", commits: [taken, free] });
+
+ expect(result.conflicts).toEqual([{ op: SecretOperations.Create, secretId: "commit-A" }]);
+ expect(result.creates).toEqual([free]);
+ });
+
+ test("marks an update whose secret was deleted or whose key moved to another secret as a conflict", async () => {
+ const { fns } = buildFns([
+ { id: "secret-other", key: "A" },
+ { id: "secret-b", key: "B" }
+ ]);
+ const deletedTarget = commit({ op: SecretOperations.Update, key: "Z", secretId: null, secret: undefined });
+ const keyTaken = commit({
+ op: SecretOperations.Update,
+ key: "A",
+ secretId: "secret-a",
+ secret: { id: "secret-a", key: "A" }
+ });
+ const clean = commit({
+ op: SecretOperations.Update,
+ key: "B",
+ secretId: "secret-b",
+ secret: { id: "secret-b", key: "B" },
+ secretVersion: { id: "version-b", key: "B" }
+ });
+
+ const result = await fns.detectSecretApprovalCommitConflicts({
+ folderId: "folder-1",
+ commits: [deletedTarget, keyTaken, clean]
+ });
+
+ expect(result.conflicts).toEqual([
+ { op: SecretOperations.Update, secretId: "commit-Z" },
+ { op: SecretOperations.Update, secretId: "commit-A" }
+ ]);
+ expect(result.updates).toEqual([clean]);
+ });
+});
+
+describe("buildSecretMutationEvents", () => {
+ const secret = (id: string, key: string, version = 2) => ({
+ id,
+ key,
+ version,
+ tags: [{ name: "team" }],
+ secretMetadata: [
+ { key: "owner", value: "alice" },
+ { key: "token", encryptedValue: "ZW5j" }
+ ]
+ });
+ const secrets = (overrides: Record<string, unknown[]>) =>
+ ({ created: [], updated: [], deleted: [], ...overrides }) as unknown as TMergedSecretsV2Bridge;
+
+ test("emits singular events for one secret and masks encrypted metadata", () => {
+ const events = buildSecretMutationEvents({
+ environment: "dev",
+ secretPath: "/app",
+ secrets: secrets({ created: [secret("s1", "A")], deleted: [secret("s2", "B", 5)] })
+ });
+
+ expect(events).toEqual([
+ {
+ type: EventType.CREATE_SECRET,
+ metadata: {
+ environment: "dev",
+ secretPath: "/app",
+ secretId: "s1",
+ secretVersion: 1,
+ secretKey: "A",
+ secretMetadata: [
+ { key: "owner", isEncrypted: false, value: "alice" },
+ { key: "token", isEncrypted: true, value: AUDIT_LOG_SENSITIVE_VALUE }
+ ],
+ secretTags: ["team"]
+ }
+ },
+ {
+ type: EventType.DELETE_SECRET,
+ metadata: { environment: "dev", secretPath: "/app", secretId: "s2", secretVersion: 5, secretKey: "B" }
+ }
+ ]);
+ });
+
+ test("emits plural events for several secrets", () => {
+ const events = buildSecretMutationEvents({
+ environment: "dev",
+ secretPath: "/",
+ secrets: secrets({ updated: [secret("s1", "A", 3), secret("s2", "B", 4)] })
+ });
+
+ expect(events).toHaveLength(1);
+ expect(events[0]).toMatchObject({
+ type: EventType.UPDATE_SECRETS,
+ metadata: {
+ secrets: [
+ { secretId: "s1", secretVersion: 3, secretKey: "A" },
+ { secretId: "s2", secretVersion: 4, secretKey: "B" }
+ ]
+ }
+ });
+ });
+
+ test("emits nothing when nothing changed", () => {
+ expect(buildSecretMutationEvents({ environment: "dev", secretPath: "/", secrets: secrets({}) })).toEqual([]);
+ });
+});
+
+describe("buildRequestedByActor", () => {
+ test("prefers the committing user, then the committing identity, then nothing", () => {
+ expect(
+ buildRequestedByActor({ committerUserId: "user-1", committerUser: { email: "[email protected]", username: "[email protected]" } })
+ ).toEqual({ type: ActorType.USER, metadata: { userId: "user-1", email: "[email protected]", username: "[email protected]" } });
+
+ expect(buildRequestedByActor({ committerIdentity: { identityId: "identity-1", name: "ci" } })).toEqual({
+ type: ActorType.IDENTITY,
+ metadata: { identityId: "identity-1", name: "ci" }
+ });
+
+ expect(buildRequestedByActor({})).toBeUndefined();
+ });
+});
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-merge-fns.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-merge-fns.ts
new file mode 100644
index 0000000000..2dfabbebbe
--- /dev/null
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-merge-fns.ts
@@ -0,0 +1,680 @@
+import { MongoAbility } from "@casl/ability";
+import { Knex } from "knex";
+
+import { SecretType } from "@app/db/schemas";
+import { Actor, Event, EventType } from "@app/ee/services/audit-log/audit-log-types";
+import { AUDIT_LOG_SENSITIVE_VALUE } from "@app/lib/config/const";
+import { getConfig } from "@app/lib/config/env";
+import { NotFoundError } from "@app/lib/errors";
+import { groupBy } from "@app/lib/fn";
+import { ActorType } from "@app/services/auth/auth-type";
+import { TFolderCommitServiceFactory } from "@app/services/folder-commit/folder-commit-service";
+import { TKmsServiceFactory } from "@app/services/kms/kms-service";
+import { TNotificationServiceFactory } from "@app/services/notification/notification-service";
+import { NotificationType } from "@app/services/notification/notification-types";
+import { TResourceMetadataDALFactory } from "@app/services/resource-metadata/resource-metadata-dal";
+import { TSecretQueueFactory } from "@app/services/secret/secret-queue";
+import { SecretOperations } from "@app/services/secret/secret-types";
+import { TSecretFolderDALFactory } from "@app/services/secret-folder/secret-folder-dal";
+import { TSecretTagDALFactory } from "@app/services/secret-tag/secret-tag-dal";
+import { getAllSecretReferences } from "@app/services/secret-v2-bridge/secret-reference-fns";
+import { TSecretV2BridgeDALFactory } from "@app/services/secret-v2-bridge/secret-v2-bridge-dal";
+import {
+ fnSecretBulkDelete,
+ fnSecretBulkInsert,
+ fnSecretBulkUpdate,
+ fnUpdateMovedSecretReferences,
+ fnUpdateSecretLinkedReferences
+} from "@app/services/secret-v2-bridge/secret-v2-bridge-fns";
+import { TSecretVersionV2DALFactory } from "@app/services/secret-v2-bridge/secret-version-dal";
+import { TSecretVersionV2TagDALFactory } from "@app/services/secret-v2-bridge/secret-version-tag-dal";
+import { SmtpTemplates, TSmtpService } from "@app/services/smtp/smtp-service";
+import { TUserDALFactory } from "@app/services/user/user-dal";
+
+import { ProjectPermissionSet } from "../permission/project-permission";
+import { ProjectEvents, TProjectEventPayload } from "../project-events/project-events-types";
+import { TSecretApprovalRequestCommitFnsFactory } from "./secret-approval-request-commit-fns";
+import { hasSecretUpdateCommitConflict } from "./secret-approval-request-fns";
+import { TSecretApprovalRequestSecretDALFactory } from "./secret-approval-request-secret-dal";
+import { InternalMetadataType, TInternalMetadata } from "./secret-approval-request-types";
+
+type TSecretApprovalRequestMergeFnsFactoryDep = {
+ folderDAL: Pick<TSecretFolderDALFactory, "findBySecretPath" | "findSecretPathByFolderIds">;
+ secretV2BridgeDAL: Pick<
+ TSecretV2BridgeDALFactory,
+ | "insertMany"
+ | "upsertSecretReferences"
+ | "findBySecretKeys"
+ | "bulkUpdate"
+ | "deleteMany"
+ | "find"
+ | "updateById"
+ | "findReferencedSecretReferencesBySecretKey"
+ | "updateSecretReferenceSecretKey"
+ | "updateSecretReferenceEnvAndPath"
+ | "findOne"
+ >;
+ secretVersionV2BridgeDAL: Pick<TSecretVersionV2DALFactory, "insertMany" | "findLatestVersionMany">;
+ secretVersionTagV2BridgeDAL: Pick<TSecretVersionV2TagDALFactory, "insertMany">;
+ secretTagDAL: Pick<TSecretTagDALFactory, "saveTagsToSecretV2" | "deleteTagsToSecretV2" | "find">;
+ resourceMetadataDAL: Pick<TResourceMetadataDALFactory, "insertMany" | "delete">;
+ folderCommitService: Pick<TFolderCommitServiceFactory, "createCommit">;
+ secretQueueService: Pick<TSecretQueueFactory, "syncSecrets" | "removeSecretReminder">;
+ secretApprovalRequestSecretDAL: Pick<TSecretApprovalRequestSecretDALFactory, "updateV2ById">;
+ validateSecrets: TSecretApprovalRequestCommitFnsFactory["validateSecrets"];
+ userDAL: Pick<TUserDALFactory, "find" | "findOne">;
+ notificationService: Pick<TNotificationServiceFactory, "createUserNotifications">;
+ smtpService: Pick<TSmtpService, "sendMail">;
+};
+
+export type TSecretApprovalRequestMergeFnsFactory = ReturnType<typeof secretApprovalRequestMergeFnsFactory>;
+
+export type TSecretApprovalBridgeCommit = Awaited<
+ ReturnType<TSecretApprovalRequestSecretDALFactory["findByRequestIdBridgeSecretV2"]>
+>[number];
+
+export type TSecretApprovalCommitConflict = { secretId: string; op: SecretOperations };
+
+export type TSecretManagerCipher = Awaited<ReturnType<TKmsServiceFactory["createCipherPairWithDataKey"]>>;
+
+type TMergedFolder = { path: string; environmentSlug: string; environmentName: string };
+
+export type TMergedSecretsV2Bridge = {
+ created: Awaited<ReturnType<typeof fnSecretBulkInsert>>;
+ updated: Awaited<ReturnType<typeof fnSecretBulkUpdate>>;
+ deleted: Awaited<ReturnType<typeof fnSecretBulkDelete>>;
+};
+
+type TAuditSecretMetadata = { key: string; encryptedValue: string; value: string }[];
+
+const toAuditSecretMetadata = (secretMetadata: unknown) =>
+ (secretMetadata as TAuditSecretMetadata | undefined)?.map((meta) => ({
+ key: meta.key,
+ isEncrypted: Boolean(meta.encryptedValue),
+ value: meta.encryptedValue ? AUDIT_LOG_SENSITIVE_VALUE : meta.value || ""
+ }));
+
+const toAuditSecretTags = (tags: unknown) => (tags as { name: string }[] | undefined)?.map((tag) => tag.name);
+
+export const buildSecretMutationEvents = ({
+ environment,
+ secretPath,
+ secrets: { created, updated, deleted }
+}: {
+ environment: string;
+ secretPath: string;
+ secrets: TMergedSecretsV2Bridge;
+}): Event[] => {
+ const secretMutationEvents: Event[] = [];
+
+ if (created.length) {
+ if (created.length > 1) {
+ secretMutationEvents.push({
+ type: EventType.CREATE_SECRETS,
+ metadata: {
+ environment,
+ secretPath,
+ secrets: created.map((secret) => ({
+ secretId: secret.id,
+ secretVersion: 1,
+ secretKey: secret.key,
+ secretMetadata: toAuditSecretMetadata(secret.secretMetadata),
+ secretTags: toAuditSecretTags(secret.tags)
+ }))
+ }
+ });
+ } else {
+ const [secret] = created;
+ secretMutationEvents.push({
+ type: EventType.CREATE_SECRET,
+ metadata: {
+ environment,
+ secretPath,
+ secretId: secret.id,
+ secretVersion: 1,
+ secretKey: secret.key,
+ secretMetadata: toAuditSecretMetadata(secret.secretMetadata),
+ secretTags: toAuditSecretTags(secret.tags)
+ }
+ });
+ }
+ }
+
+ if (updated.length) {
+ if (updated.length > 1) {
+ secretMutationEvents.push({
+ type: EventType.UPDATE_SECRETS,
+ metadata: {
+ environment,
+ secretPath,
+ secrets: updated.map((secret) => ({
+ secretId: secret.id,
+ secretVersion: secret.version,
+ secretKey: secret.key,
+ secretMetadata: toAuditSecretMetadata(secret.secretMetadata),
+ secretTags: toAuditSecretTags(secret.tags)
+ }))
+ }
+ });
+ } else {
+ const [secret] = updated;
+ secretMutationEvents.push({
+ type: EventType.UPDATE_SECRET,
+ metadata: {
+ environment,
+ secretPath,
+ secretId: secret.id,
+ secretVersion: secret.version,
+ secretKey: secret.key,
+ secretMetadata: toAuditSecretMetadata(secret.secretMetadata),
+ secretTags: toAuditSecretTags(secret.tags)
+ }
+ });
+ }
+ }
+
+ if (deleted.length) {
+ if (deleted.length > 1) {
+ secretMutationEvents.push({
+ type: EventType.DELETE_SECRETS,
+ metadata: {
+ environment,
+ secretPath,
+ secrets: deleted.map((secret) => ({
+ secretId: secret.id,
+ secretVersion: secret.version,
+ secretKey: secret.key
+ }))
+ }
+ });
+ } else {
+ const [secret] = deleted;
+ secretMutationEvents.push({
+ type: EventType.DELETE_SECRET,
+ metadata: {
+ environment,
+ secretPath,
+ secretId: secret.id,
+ secretVersion: secret.version,
+ secretKey: secret.key
+ }
+ });
+ }
+ }
+
+ return secretMutationEvents;
+};
+
+export const buildRequestedByActor = ({
+ committerUserId,
+ committerUser,
+ committerIdentity
+}: {
+ committerUserId?: string | null;
+ committerUser?: { email?: string | null; username?: string | null } | null;
+ committerIdentity?: { identityId: string; name: string } | null;
+}): Actor | undefined => {
+ if (committerUserId) {
+ return {
+ type: ActorType.USER,
+ metadata: {
+ userId: committerUserId,
+ email: committerUser?.email ?? undefined,
+ username: committerUser?.username ?? ""
+ }
+ };
+ }
+ if (committerIdentity) {
+ return {
+ type: ActorType.IDENTITY,
+ metadata: { identityId: committerIdentity.identityId, name: committerIdentity.name }
+ };
+ }
+ return undefined;
+};
+
+const toSecretMetadataInput = (secretMetadata: unknown) =>
+ (Array.isArray(secretMetadata)
+ ? (secretMetadata as { key: string; value?: string | null; encryptedValue?: string | null }[])
+ : []
+ ).map((meta) => ({
+ key: meta.key,
+ [meta.encryptedValue ? "encryptedValue" : "value"]: meta.encryptedValue
+ ? Buffer.from(meta.encryptedValue, "base64")
+ : meta.value || ""
+ }));
+
+export const secretApprovalRequestMergeFnsFactory = ({
+ folderDAL,
+ secretV2BridgeDAL,
+ secretVersionV2BridgeDAL,
+ secretVersionTagV2BridgeDAL,
+ secretTagDAL,
+ resourceMetadataDAL,
+ folderCommitService,
+ secretQueueService,
+ secretApprovalRequestSecretDAL,
+ validateSecrets,
+ userDAL,
+ notificationService,
+ smtpService
+}: TSecretApprovalRequestMergeFnsFactoryDep) => {
+ const detectSecretApprovalCommitConflicts = async ({
+ folderId,
+ commits
+ }: {
+ folderId: string;
+ commits: TSecretApprovalBridgeCommit[];
+ }) => {
+ const conflicts: TSecretApprovalCommitConflict[] = [];
+
+ let creates = commits.filter(({ op }) => op === SecretOperations.Create);
+ if (creates.length) {
+ const secrets = await secretV2BridgeDAL.findBySecretKeys(
+ folderId,
+ creates.map((el) => ({ key: el.key, type: SecretType.Shared }))
+ );
+ const creationConflictSecretsGroupByKey = groupBy(secrets, (i) => i.key);
+ creates
+ .filter(({ key }) => creationConflictSecretsGroupByKey[key])
+ .forEach((el) => {
+ conflicts.push({ op: SecretOperations.Create, secretId: el.id });
+ });
+ creates = creates.filter(({ key }) => !creationConflictSecretsGroupByKey[key]);
+ }
+
+ let updates = commits.filter(({ op }) => op === SecretOperations.Update);
+ if (updates.length) {
+ const secrets = await secretV2BridgeDAL.findBySecretKeys(
+ folderId,
+ updates.map((el) => ({ key: el.key, type: SecretType.Shared }))
+ );
+ const updationSecretsGroupByKey = groupBy(secrets, (i) => i.key);
+ const hasUpdateConflict = (el: TSecretApprovalBridgeCommit) =>
+ hasSecretUpdateCommitConflict(el, updationSecretsGroupByKey[el.key]?.[0]);
+
+ updates.filter(hasUpdateConflict).forEach((el) => {
+ conflicts.push({ op: SecretOperations.Update, secretId: el.id });
+ });
+ updates = updates.filter((el) => !hasUpdateConflict(el));
+ }
+
+ const deletes = commits.filter(({ op }) => op === SecretOperations.Delete);
+
+ return { conflicts, creates, updates, deletes };
+ };
+
+ const applySecretApprovalCommitsV2Bridge = async ({
+ projectId,
+ folderId,
+ environment,
+ envId,
+ secretPath,
+ actor,
+ actorId,
+ actorOrgId,
+ permission,
+ cipher,
+ creates,
+ updates,
+ deletes,
+ tx
+ }: {
+ projectId: string;
+ folderId: string;
+ environment: string;
+ envId: string;
+ secretPath: string;
+ actor: ActorType;
+ actorId: string;
+ actorOrgId: string;
+ permission: MongoAbility<ProjectPermissionSet>;
+ cipher: TSecretManagerCipher;
+ creates: TSecretApprovalBridgeCommit[];
+ updates: TSecretApprovalBridgeCommit[];
+ deletes: TSecretApprovalBridgeCommit[];
+ tx: Knex;
+ }): Promise<TMergedSecretsV2Bridge> => {
+ const { decryptor: secretManagerDecryptor, generateSecretBlindIndex, encryptor: secretManagerEncryptor } = cipher;
+
+ // The request-time check ran before the approvals did. Another write, or another pending
+ // request, may have claimed a proposed value since, so the rules are enforced again here,
+ // under the same transaction that applies the writes.
+ const secretsToValidate = [
+ ...creates.map((el) => ({
+ key: el.key,
+ value: el.encryptedValue ? secretManagerDecryptor({ cipherTextBlob: el.encryptedValue }).toString() : undefined
+ })),
+ ...updates
+ .filter((el) => !el.secret?.isRotatedSecret && (Boolean(el.encryptedValue) || el.key !== el.secret?.key))
+ .map((el) => ({
+ key: el.key,
+ value: el.encryptedValue
+ ? secretManagerDecryptor({ cipherTextBlob: el.encryptedValue }).toString()
+ : undefined,
+ secretId: el.secretId ?? undefined
+ }))
+ ];
+
+ if (secretsToValidate.length) {
+ await validateSecrets({ projectId, environment, envId, secretPath, secrets: secretsToValidate }, permission, tx);
+ }
+
+ const creationBlindIndexes = await Promise.all(
+ creates.map((el) =>
+ el.encryptedValue
+ ? generateSecretBlindIndex(secretManagerDecryptor({ cipherTextBlob: el.encryptedValue }))
+ : Promise.resolve(undefined)
+ )
+ );
+
+ const created = creates.length
+ ? await fnSecretBulkInsert({
+ tx,
+ folderId,
+ actor: { actorId, type: actor },
+ orgId: actorOrgId,
+ inputSecrets: creates.map((el, idx) => ({
+ tagIds: el?.tags.map(({ id }) => id),
+ version: 1,
+ encryptedComment: el.encryptedComment,
+ encryptedValue: el.encryptedValue,
+ secretValueBlindIndex: creationBlindIndexes[idx],
+ skipMultilineEncoding: el.skipMultilineEncoding,
+ key: el.key,
+ secretMetadata: toSecretMetadataInput(el.secretMetadata),
+ references: el.encryptedValue
+ ? getAllSecretReferences(secretManagerDecryptor({ cipherTextBlob: el.encryptedValue }).toString())
+ .nestedReferences
+ : [],
+ type: SecretType.Shared
+ })),
+ resourceMetadataDAL,
+ secretDAL: secretV2BridgeDAL,
+ secretVersionDAL: secretVersionV2BridgeDAL,
+ secretTagDAL,
+ secretVersionTagDAL: secretVersionTagV2BridgeDAL,
+ folderCommitService
+ })
+ : [];
+
+ // case: move secrets. update references to point to the new location based on metadata source environment and path
+ const moveSecretCommits = creates.filter(
+ (el) => (el.internalMetadata as TInternalMetadata)?.type === InternalMetadataType.MoveSecret
+ );
+
+ if (moveSecretCommits.length > 0 && created.length > 0) {
+ const createdSecretsByKey = new Map(created.map((s) => [s.key, s]));
+
+ for await (const moveCommit of moveSecretCommits) {
+ const internalMeta = moveCommit.internalMetadata as TInternalMetadata;
+ const createdSecret = createdSecretsByKey.get(moveCommit.key);
+
+ // eslint-disable-next-line no-continue
+ if (!createdSecret || internalMeta.type !== InternalMetadataType.MoveSecret) continue;
+
+ const { source } = internalMeta.payload;
+
+ const sourceFolder = await folderDAL.findBySecretPath(projectId, source.environment, source.secretPath, tx);
+ // eslint-disable-next-line no-continue
+ if (!sourceFolder) continue;
+
+ await fnUpdateMovedSecretReferences({
+ orgId: actorOrgId,
+ projectId,
+ sourceEnvironment: source.environment,
+ sourceSecretPath: source.secretPath,
+ sourceFolderId: sourceFolder.id,
+ destinationEnvironment: environment,
+ destinationSecretPath: secretPath,
+ destinationFolderId: folderId,
+ secretKey: moveCommit.key,
+ secretId: createdSecret.id,
+ secretDAL: secretV2BridgeDAL,
+ secretVersionDAL: secretVersionV2BridgeDAL,
+ folderCommitService,
+ secretQueueService,
+ folderDAL,
+ encryptor: ({ plainText }) => secretManagerEncryptor({ plainText }),
+ decryptor: ({ cipherTextBlob }) => secretManagerDecryptor({ cipherTextBlob }),
+ generateSecretBlindIndex,
+ tx
+ });
+ }
+ }
+
+ // Back-fill secretId on approval commit rows so created secrets are traceable
+ // This is useful for clients that require polling when a approval request is created
+ // for example our terraform provider.
+ if (created.length) {
+ const newSecretsByKey = new Map(created.map((s) => [s.key, s.id]));
+ await Promise.all(
+ creates
+ .filter((commit) => newSecretsByKey.has(commit.key))
+ .map((commit) =>
+ secretApprovalRequestSecretDAL.updateV2ById(commit.id, { secretId: newSecretsByKey.get(commit.key)! }, tx)
+ )
+ );
+ }
+
+ const updationBlindIndexes = await Promise.all(
+ updates.map((el) => {
+ const shouldComputeBlindIndex =
+ !el.secret?.isRotatedSecret && el.encryptedValue !== null && el.encryptedValue !== undefined;
+ return shouldComputeBlindIndex
+ ? generateSecretBlindIndex(secretManagerDecryptor({ cipherTextBlob: el.encryptedValue as Buffer }))
+ : Promise.resolve(undefined);
+ })
+ );
+
+ const updated = updates.length
+ ? await fnSecretBulkUpdate({
+ folderId,
+ orgId: actorOrgId,
+ actor: { actorId, type: actor },
+ tx,
+ inputSecrets: updates.map((el, idx) => {
+ const encryptedValue =
+ !el.secret?.isRotatedSecret && el.encryptedValue !== null && el.encryptedValue !== undefined
+ ? {
+ encryptedValue: el.encryptedValue,
+ secretValueBlindIndex: updationBlindIndexes[idx],
+ references: el.encryptedValue
+ ? getAllSecretReferences(secretManagerDecryptor({ cipherTextBlob: el.encryptedValue }).toString())
+ .nestedReferences
+ : []
+ }
+ : {};
+ return {
+ filter: { id: el.secretId as string, type: SecretType.Shared },
+ data: {
+ reminderRepeatDays: el.reminderRepeatDays,
+ encryptedComment: el.encryptedComment !== null ? el.encryptedComment : undefined,
+ reminderNote: el.reminderNote,
+ skipMultilineEncoding: el.skipMultilineEncoding !== null ? el.skipMultilineEncoding : undefined,
+ key: el.key,
+ tags: el?.tags.map(({ id }) => id),
+ secretMetadata: toSecretMetadataInput(el.secretMetadata),
+ ...encryptedValue
+ }
+ };
+ }),
+ secretDAL: secretV2BridgeDAL,
+ secretVersionDAL: secretVersionV2BridgeDAL,
+ secretTagDAL,
+ secretVersionTagDAL: secretVersionTagV2BridgeDAL,
+ resourceMetadataDAL,
+ folderCommitService
+ })
+ : [];
+
+ // update the ref's for any secret key renames
+ const secretKeyRenames = updates.filter((el) => el.secret && el.key !== el.secret.key);
+
+ for await (const rename of secretKeyRenames) {
+ // eslint-disable-next-line no-continue
+ if (!rename.secret || !rename.secretId) continue;
+
+ await fnUpdateSecretLinkedReferences({
+ orgId: actorOrgId,
+ projectId,
+ environment,
+ secretPath,
+ folderId,
+ oldSecretKey: rename.secret.key,
+ newSecretKey: rename.key,
+ secretId: rename.secretId,
+ secretDAL: secretV2BridgeDAL,
+ secretVersionDAL: secretVersionV2BridgeDAL,
+ folderCommitService,
+ secretQueueService,
+ folderDAL,
+ encryptor: ({ plainText }) => secretManagerEncryptor({ plainText }),
+ decryptor: ({ cipherTextBlob }) => secretManagerDecryptor({ cipherTextBlob }),
+ generateSecretBlindIndex,
+ tx
+ });
+ }
+
+ const deleted = deletes.length
+ ? await fnSecretBulkDelete({
+ projectId,
+ folderId,
+ tx,
+ actorId,
+ actorType: actor,
+ secretDAL: secretV2BridgeDAL,
+ secretQueueService,
+ inputSecrets: deletes.map(({ key }) => ({ secretKey: key, type: SecretType.Shared })),
+ folderCommitService,
+ secretVersionDAL: secretVersionV2BridgeDAL
+ })
+ : [];
+
+ return { created, updated, deleted };
+ };
+
+ const findMergedFolder = async (projectId: string, folderId: string) => {
+ const [folder] = await folderDAL.findSecretPathByFolderIds(projectId, [folderId]);
+ if (!folder) {
+ throw new NotFoundError({ message: `Folder with ID '${folderId}' not found in project with ID '${projectId}'` });
+ }
+ return folder;
+ };
+
+ const syncMergedSecrets = async ({
+ projectId,
+ actorOrgId,
+ actor,
+ actorId,
+ folder,
+ secrets
+ }: {
+ projectId: string;
+ actorOrgId: string;
+ actor: ActorType;
+ actorId: string;
+ folder: TMergedFolder;
+ secrets: TMergedSecretsV2Bridge;
+ }) => {
+ const events: TProjectEventPayload[] = [];
+ if (secrets.created.length > 0) {
+ events.push({
+ type: ProjectEvents.SecretCreate,
+ projectId,
+ environment: folder.environmentSlug,
+ secretPath: folder.path,
+ secretKeys: secrets.created.map((el) => el.key)
+ });
+ }
+
+ if (secrets.updated.length > 0) {
+ events.push({
+ type: ProjectEvents.SecretUpdate,
+ projectId,
+ environment: folder.environmentSlug,
+ secretPath: folder.path,
+ secretKeys: secrets.updated.map((el) => el.key)
+ });
+ }
+
+ if (secrets.deleted.length > 0) {
+ events.push({
+ type: ProjectEvents.SecretDelete,
+ projectId,
+ environment: folder.environmentSlug,
+ secretPath: folder.path,
+ secretKeys: secrets.deleted.map((el) => el.key)
+ });
+ }
+
+ await secretQueueService.syncSecrets({
+ projectId,
+ orgId: actorOrgId,
+ secretPath: folder.path,
+ environmentSlug: folder.environmentSlug,
+ environmentName: folder.environmentName,
+ actorId,
+ actor,
+ events
+ });
+ };
+
+ const notifySecretApprovalBypass = async ({
+ project,
+ environmentName,
+ secretPath,
+ actorId,
+ approverUserIds,
+ bypassReason
+ }: {
+ project: { id: string; name: string; orgId: string };
+ environmentName: string;
+ secretPath: string;
+ actorId: string;
+ approverUserIds: string[];
+ bypassReason?: string;
+ }) => {
+ const cfg = getConfig();
+ const requestedByUser = await userDAL.findOne({ id: actorId });
+ const approverUsers = await userDAL.find({ $in: { id: approverUserIds } });
+
+ await notificationService.createUserNotifications(
+ approverUsers.map((approver) => ({
+ userId: approver.id,
+ orgId: project.orgId,
+ type: NotificationType.SECRET_CHANGE_POLICY_BYPASSED,
+ title: "Secret Change Policy Bypassed",
+ body: `**${requestedByUser.firstName} ${requestedByUser.lastName}** (${requestedByUser.email}) has merged a secret to **${secretPath}** in the **${environmentName}** environment for project **${project.name}** without obtaining the required approval.`,
+ link: `/projects/secret-management/${project.id}/approval`
+ }))
+ );
+
+ const recipients = approverUsers.filter((approver) => approver.email).map((approver) => approver.email!);
+
+ if (recipients?.length) {
+ await smtpService.sendMail({
+ recipients,
+ subjectLine: "Infisical Secret Change Policy Bypassed",
+ substitutions: {
+ projectName: project.name,
+ requesterFullName: `${requestedByUser.firstName} ${requestedByUser.lastName}`,
+ requesterEmail: requestedByUser.email,
+ bypassReason,
+ secretPath,
+ environment: environmentName,
+ approvalUrl: `${cfg.SITE_URL}/organizations/${project.orgId}/projects/secret-management/${project.id}/approval`
+ },
+ template: SmtpTemplates.AccessSecretRequestBypassed
+ });
+ }
+ };
+
+ return {
+ detectSecretApprovalCommitConflicts,
+ applySecretApprovalCommitsV2Bridge,
+ findMergedFolder,
+ syncMergedSecrets,
+ notifySecretApprovalBypass
+ };
+};
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-secret-dal.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-secret-dal.ts
index 1a6b4c366e..7d74c5f181 100644
--- a/backend/src/ee/services/secret-approval-request/secret-approval-request-secret-dal.ts
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-secret-dal.ts
@@ -223,13 +223,23 @@ export const secretApprovalRequestSecretDALFactory = (db: TDbClient) => {
}
};
- const findByRequestIdBridgeSecretV2 = async (requestId: string, tx?: Knex) => {
+ const $findBridgeSecretV2 = async (
+ where: { requestId: string } | { secretChangeId: string },
+ errorName: string,
+ tx?: Knex
+ ) => {
try {
const doc = await (tx || db.replicaNode())({
secVerTag: TableName.SecretTag
})
.from(TableName.SecretApprovalRequestSecretV2)
- .where({ requestId })
+ .where((qb) => {
+ if ("requestId" in where) {
+ void qb.where(`${TableName.SecretApprovalRequestSecretV2}.requestId`, where.requestId);
+ } else {
+ void qb.where(`${TableName.SecretApprovalRequestSecretV2}.secretChangeId`, where.secretChangeId);
+ }
+ })
.leftJoin(
TableName.SecretApprovalRequestSecretTagV2,
`${TableName.SecretApprovalRequestSecretV2}.id`,
@@ -382,9 +392,16 @@ export const secretApprovalRequestSecretDALFactory = (db: TDbClient) => {
secretVersion: secretVersion?.[0]
}));
} catch (error) {
- throw new DatabaseError({ error, name: "FindByRequestId" });
+ throw new DatabaseError({ error, name: errorName });
}
};
+
+ const findByRequestIdBridgeSecretV2 = (requestId: string, tx?: Knex) =>
+ $findBridgeSecretV2({ requestId }, "FindByRequestIdBridgeSecretV2", tx);
+
+ const findBySecretChangeIdBridgeSecretV2 = (secretChangeId: string, tx?: Knex) =>
+ $findBridgeSecretV2({ secretChangeId }, "FindBySecretChangeIdBridgeSecretV2", tx);
+
// special query for migration to v2 secret
const findByProjectId = async (projectId: string, tx?: Knex) => {
try {
@@ -445,6 +462,7 @@ export const secretApprovalRequestSecretDALFactory = (db: TDbClient) => {
updateV2ById: secretApprovalRequestSecretV2Orm.updateById,
findByRequestId,
findByRequestIdBridgeSecretV2,
+ findBySecretChangeIdBridgeSecretV2,
bulkUpdateNoVersionIncrement,
findByProjectId,
insertApprovalSecretTags: secretApprovalRequestSecretTagOrm.insertMany,
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-service.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-service.ts
index 1a0320b3d9..35666bc35f 100644
--- a/backend/src/ee/services/secret-approval-request/secret-approval-request-service.ts
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-service.ts
@@ -9,7 +9,7 @@ import {
SecretType,
TSecretApprovalRequestsSecretsInsert
} from "@app/db/schemas";
-import { Actor, Event, EventType } from "@app/ee/services/audit-log/audit-log-types";
+import { Event, EventType } from "@app/ee/services/audit-log/audit-log-types";
import { AUDIT_LOG_SENSITIVE_VALUE } from "@app/lib/config/const";
import { getConfig } from "@app/lib/config/env";
import { crypto, SymmetricKeySize } from "@app/lib/crypto/cryptography";
@@ -30,7 +30,6 @@ import { KmsDataKey } from "@app/services/kms/kms-types";
import { TMicrosoftTeamsServiceFactory } from "@app/services/microsoft-teams/microsoft-teams-service";
import { TProjectMicrosoftTeamsConfigDALFactory } from "@app/services/microsoft-teams/project-microsoft-teams-config-dal";
import { TNotificationServiceFactory } from "@app/services/notification/notification-service";
-import { NotificationType } from "@app/services/notification/notification-types";
import { TProjectDALFactory } from "@app/services/project/project-dal";
import { TProjectBotServiceFactory } from "@app/services/project-bot/project-bot-service";
import { TProjectEnvDALFactory } from "@app/services/project-env/project-env-dal";
@@ -53,20 +52,12 @@ import { TSecretVersionTagDALFactory } from "@app/services/secret/secret-version
import { TSecretBlindIndexDALFactory } from "@app/services/secret-blind-index/secret-blind-index-dal";
import { TSecretFolderDALFactory } from "@app/services/secret-folder/secret-folder-dal";
import { TSecretTagDALFactory } from "@app/services/secret-tag/secret-tag-dal";
-import { getAllSecretReferences as getAllSecretReferencesV2Bridge } from "@app/services/secret-v2-bridge/secret-reference-fns";
import { TSecretV2BridgeDALFactory } from "@app/services/secret-v2-bridge/secret-v2-bridge-dal";
-import {
- fnSecretBulkDelete as fnSecretV2BridgeBulkDelete,
- fnSecretBulkInsert as fnSecretV2BridgeBulkInsert,
- fnSecretBulkUpdate as fnSecretV2BridgeBulkUpdate,
- fnUpdateMovedSecretReferences,
- fnUpdateSecretLinkedReferences
-} from "@app/services/secret-v2-bridge/secret-v2-bridge-fns";
import { TSecretVersionV2DALFactory } from "@app/services/secret-v2-bridge/secret-version-dal";
import { TSecretVersionV2TagDALFactory } from "@app/services/secret-v2-bridge/secret-version-tag-dal";
import { TSecretValidationRuleServiceFactory } from "@app/services/secret-validation-rule/secret-validation-rule-service";
import { TProjectSlackConfigDALFactory } from "@app/services/slack/project-slack-config-dal";
-import { SmtpTemplates, TSmtpService } from "@app/services/smtp/smtp-service";
+import { TSmtpService } from "@app/services/smtp/smtp-service";
import { TTelemetryServiceFactory } from "@app/services/telemetry/telemetry-service";
import { PostHogEventTypes } from "@app/services/telemetry/telemetry-types";
import { TUserDALFactory } from "@app/services/user/user-dal";
@@ -90,18 +81,17 @@ import { TSecretChangePolicyBridgeServiceFactory } from "../secret-change-policy
import { TSecretChangeRequestBridgeServiceFactory } from "../secret-change-request-bridge/secret-change-request-bridge-service";
import { pickApprovalCommitColumns, secretApprovalRequestCommitFnsFactory } from "./secret-approval-request-commit-fns";
import { TSecretApprovalRequestDALFactory } from "./secret-approval-request-dal";
-import { hasSecretUpdateCommitConflict, sendApprovalEmailsFn } from "./secret-approval-request-fns";
+import { sendApprovalEmailsFn } from "./secret-approval-request-fns";
+import { buildRequestedByActor, secretApprovalRequestMergeFnsFactory } from "./secret-approval-request-merge-fns";
import { TSecretApprovalRequestReviewerDALFactory } from "./secret-approval-request-reviewer-dal";
import { TSecretApprovalRequestSecretDALFactory } from "./secret-approval-request-secret-dal";
import {
ApprovalStatus,
- InternalMetadataType,
RequestState,
TApprovalRequestCountDTO,
TCreateSecretApprovalSideEffectsDTO,
TGenerateSecretApprovalRequestDTO,
TGenerateSecretApprovalRequestV2BridgeDTO,
- TInternalMetadata,
TListApprovalsDTO,
TMergeSecretApprovalRequestDTO,
TReviewRequestDTO,
@@ -226,6 +216,23 @@ export const secretApprovalRequestServiceFactory = ({
secretValidationRuleService
});
+ const { detectSecretApprovalCommitConflicts, applySecretApprovalCommitsV2Bridge, notifySecretApprovalBypass } =
+ secretApprovalRequestMergeFnsFactory({
+ folderDAL,
+ secretV2BridgeDAL,
+ secretVersionV2BridgeDAL,
+ secretVersionTagV2BridgeDAL,
+ secretTagDAL,
+ resourceMetadataDAL,
+ folderCommitService,
+ secretQueueService,
+ secretApprovalRequestSecretDAL,
+ validateSecrets,
+ userDAL,
+ notificationService,
+ smtpService
+ });
+
const $useSecretChangeRequestBridge = async (requestId: string) =>
Boolean(await secretChangeRequestBridgeService.findSecretChangeRequest(requestId));
@@ -859,335 +866,42 @@ export const secretApprovalRequestServiceFactory = ({
const isMergedViaBypass = isSoftEnforcement && !hasMinApproval;
const { botKey, shouldUseSecretV2Bridge, project } = await projectBotService.getBotKey(projectId);
+ const [folder] = await folderDAL.findSecretPathByFolderIds(projectId, [folderId]);
+ if (!folder) {
+ throw new NotFoundError({ message: `Folder with ID '${folderId}' not found in project with ID '${projectId}'` });
+ }
+
let mergeStatus;
if (shouldUseSecretV2Bridge) {
- // this cycle if for bridged secrets
const secretApprovalSecrets = await secretApprovalRequestSecretDAL.findByRequestIdBridgeSecretV2(
secretApprovalRequest.id
);
-
- if (!secretApprovalSecrets) {
- throw new NotFoundError({ message: `No secrets found in secret change request with ID '${approvalId}'` });
- }
-
- const {
- decryptor: secretManagerDecryptor,
- generateSecretBlindIndex,
- encryptor: secretManagerEncryptor
- } = await kmsService.createCipherPairWithDataKey({
+ const { conflicts, creates, updates, deletes } = await detectSecretApprovalCommitConflicts({
+ folderId,
+ commits: secretApprovalSecrets
+ });
+ const cipher = await kmsService.createCipherPairWithDataKey({
type: KmsDataKey.SecretManager,
projectId
});
- const conflicts: Array<{ secretId: string; op: SecretOperations }> = [];
- let secretCreationCommits = secretApprovalSecrets.filter(({ op }) => op === SecretOperations.Create);
- if (secretCreationCommits.length) {
- const secrets = await secretV2BridgeDAL.findBySecretKeys(
- folderId,
- secretCreationCommits.map((el) => ({
- key: el.key,
- type: SecretType.Shared
- }))
- );
- const creationConflictSecretsGroupByKey = groupBy(secrets, (i) => i.key);
- secretCreationCommits
- .filter(({ key }) => creationConflictSecretsGroupByKey[key])
- .forEach((el) => {
- conflicts.push({ op: SecretOperations.Create, secretId: el.id });
- });
- secretCreationCommits = secretCreationCommits.filter(({ key }) => !creationConflictSecretsGroupByKey[key]);
- }
-
- let secretUpdationCommits = secretApprovalSecrets.filter(({ op }) => op === SecretOperations.Update);
- if (secretUpdationCommits.length) {
- const secrets = await secretV2BridgeDAL.findBySecretKeys(
+ mergeStatus = await secretApprovalRequestDAL.transaction(async (tx) => {
+ const secrets = await applySecretApprovalCommitsV2Bridge({
+ projectId,
folderId,
- secretUpdationCommits.map((el) => ({
- key: el.key,
- type: SecretType.Shared
- }))
- );
- const updationSecretsGroupByKey = groupBy(secrets, (i) => i.key);
- const hasUpdateConflict = (el: (typeof secretUpdationCommits)[number]) =>
- hasSecretUpdateCommitConflict(el, updationSecretsGroupByKey[el.key]?.[0]);
-
- secretUpdationCommits.filter(hasUpdateConflict).forEach((el) => {
- conflicts.push({ op: SecretOperations.Update, secretId: el.id });
+ environment,
+ envId: policyEnvId,
+ secretPath: folder.path,
+ actor,
+ actorId,
+ actorOrgId,
+ permission,
+ cipher,
+ creates,
+ updates,
+ deletes,
+ tx
});
- secretUpdationCommits = secretUpdationCommits.filter((el) => !hasUpdateConflict(el));
- }
-
- const secretDeletionCommits = secretApprovalSecrets.filter(({ op }) => op === SecretOperations.Delete);
- mergeStatus = await secretApprovalRequestDAL.transaction(async (tx) => {
- // The request-time check ran before the approvals did. Another write, or another pending
- // request, may have claimed a proposed value since, so the rules are enforced again here,
- // under the same transaction that applies the writes.
- const secretsToValidate = [
- ...secretCreationCommits.map((el) => ({
- key: el.key,
- value: el.encryptedValue
- ? secretManagerDecryptor({ cipherTextBlob: el.encryptedValue }).toString()
- : undefined
- })),
- ...secretUpdationCommits
- .filter((el) => !el.secret?.isRotatedSecret && (Boolean(el.encryptedValue) || el.key !== el.secret?.key))
- .map((el) => ({
- key: el.key,
- value: el.encryptedValue
- ? secretManagerDecryptor({ cipherTextBlob: el.encryptedValue }).toString()
- : undefined,
- secretId: el.secretId ?? undefined
- }))
- ];
-
- if (secretsToValidate.length) {
- const folderPaths = await folderDAL.findSecretPathByFolderIds(projectId, [folderId], tx);
- await validateSecrets(
- {
- projectId,
- environment,
- envId: policyEnvId,
- secretPath: folderPaths?.[0]?.path || "/",
- secrets: secretsToValidate
- },
- permission,
- tx
- );
- }
-
- const creationBlindIndexes = await Promise.all(
- secretCreationCommits.map((el) =>
- el.encryptedValue
- ? generateSecretBlindIndex(secretManagerDecryptor({ cipherTextBlob: el.encryptedValue }))
- : Promise.resolve(undefined)
- )
- );
-
- const newSecrets = secretCreationCommits.length
- ? await fnSecretV2BridgeBulkInsert({
- tx,
- folderId,
- actor: {
- actorId,
- type: actor
- },
- orgId: actorOrgId,
- inputSecrets: secretCreationCommits.map((el, idx) => {
- return {
- tagIds: el?.tags.map(({ id }) => id),
- version: 1,
- encryptedComment: el.encryptedComment,
- encryptedValue: el.encryptedValue,
- secretValueBlindIndex: creationBlindIndexes[idx],
- skipMultilineEncoding: el.skipMultilineEncoding,
- key: el.key,
- secretMetadata: (Array.isArray(el.secretMetadata)
- ? (el.secretMetadata as { key: string; value?: string | null; encryptedValue?: string | null }[])
- : []
- ).map((meta) => ({
- key: meta.key,
- [meta.encryptedValue ? "encryptedValue" : "value"]: meta.encryptedValue
- ? Buffer.from(meta.encryptedValue, "base64")
- : meta.value || ""
- })),
- references: el.encryptedValue
- ? getAllSecretReferencesV2Bridge(
- secretManagerDecryptor({
- cipherTextBlob: el.encryptedValue
- }).toString()
- ).nestedReferences
- : [],
- type: SecretType.Shared
- };
- }),
- resourceMetadataDAL,
- secretDAL: secretV2BridgeDAL,
- secretVersionDAL: secretVersionV2BridgeDAL,
- secretTagDAL,
- secretVersionTagDAL: secretVersionTagV2BridgeDAL,
- folderCommitService
- })
- : [];
-
- // case: move secrets. update references to point to the new location based on metadata source environment and path
- const moveSecretCommits = secretCreationCommits.filter(
- (el) => (el.internalMetadata as TInternalMetadata)?.type === InternalMetadataType.MoveSecret
- );
-
- if (moveSecretCommits.length > 0 && newSecrets.length > 0) {
- const folderPaths = await folderDAL.findSecretPathByFolderIds(projectId, [folderId], tx);
- const destinationSecretPath = folderPaths?.[0]?.path || "/";
-
- const createdSecretsByKey = new Map(newSecrets.map((s) => [s.key, s]));
-
- for await (const moveCommit of moveSecretCommits) {
- const internalMeta = moveCommit.internalMetadata as TInternalMetadata;
- const createdSecret = createdSecretsByKey.get(moveCommit.key);
-
- // eslint-disable-next-line no-continue
- if (!createdSecret || internalMeta.type !== InternalMetadataType.MoveSecret) continue;
-
- const { source } = internalMeta.payload;
-
- const sourceFolder = await folderDAL.findBySecretPath(projectId, source.environment, source.secretPath, tx);
- // eslint-disable-next-line no-continue
- if (!sourceFolder) continue;
-
- await fnUpdateMovedSecretReferences({
- orgId: actorOrgId,
- projectId,
- sourceEnvironment: source.environment,
- sourceSecretPath: source.secretPath,
- sourceFolderId: sourceFolder.id,
- destinationEnvironment: environment,
- destinationSecretPath,
- destinationFolderId: folderId,
- secretKey: moveCommit.key,
- secretId: createdSecret.id,
- secretDAL: secretV2BridgeDAL,
- secretVersionDAL: secretVersionV2BridgeDAL,
- folderCommitService,
- secretQueueService,
- folderDAL,
- encryptor: ({ plainText }) => secretManagerEncryptor({ plainText }),
- decryptor: ({ cipherTextBlob }) => secretManagerDecryptor({ cipherTextBlob }),
- generateSecretBlindIndex,
- tx
- });
- }
- }
-
- // Back-fill secretId on approval commit rows so created secrets are traceable
- // This is useful for clients that require polling when a approval request is created
- // for example our terraform provider.
- if (newSecrets.length) {
- const newSecretsByKey = new Map(newSecrets.map((s) => [s.key, s.id]));
- await Promise.all(
- secretCreationCommits
- .filter((commit) => newSecretsByKey.has(commit.key))
- .map((commit) =>
- secretApprovalRequestSecretDAL.updateV2ById(
- commit.id,
- { secretId: newSecretsByKey.get(commit.key)! },
- tx
- )
- )
- );
- }
-
- const updationBlindIndexes = await Promise.all(
- secretUpdationCommits.map((el) => {
- const shouldComputeBlindIndex =
- !el.secret?.isRotatedSecret && el.encryptedValue !== null && el.encryptedValue !== undefined;
- return shouldComputeBlindIndex
- ? generateSecretBlindIndex(secretManagerDecryptor({ cipherTextBlob: el.encryptedValue as Buffer }))
- : Promise.resolve(undefined);
- })
- );
-
- const updatedSecrets = secretUpdationCommits.length
- ? await fnSecretV2BridgeBulkUpdate({
- folderId,
- orgId: actorOrgId,
- actor: {
- actorId,
- type: actor
- },
- tx,
- inputSecrets: secretUpdationCommits.map((el, idx) => {
- const encryptedValue =
- !el.secret?.isRotatedSecret && el.encryptedValue !== null && el.encryptedValue !== undefined
- ? {
- encryptedValue: el.encryptedValue,
- secretValueBlindIndex: updationBlindIndexes[idx],
- references: el.encryptedValue
- ? getAllSecretReferencesV2Bridge(
- secretManagerDecryptor({
- cipherTextBlob: el.encryptedValue
- }).toString()
- ).nestedReferences
- : []
- }
- : {};
- return {
- filter: { id: el.secretId as string, type: SecretType.Shared },
- data: {
- reminderRepeatDays: el.reminderRepeatDays,
- encryptedComment: el.encryptedComment !== null ? el.encryptedComment : undefined,
- reminderNote: el.reminderNote,
- skipMultilineEncoding: el.skipMultilineEncoding !== null ? el.skipMultilineEncoding : undefined,
- key: el.key,
- tags: el?.tags.map(({ id }) => id),
- secretMetadata: (Array.isArray(el.secretMetadata)
- ? (el.secretMetadata as { key: string; value?: string | null; encryptedValue?: string | null }[])
- : []
- ).map((meta) => ({
- key: meta.key,
- [meta.encryptedValue ? "encryptedValue" : "value"]: meta.encryptedValue
- ? Buffer.from(meta.encryptedValue, "base64")
- : meta.value || ""
- })),
- ...encryptedValue
- }
- };
- }),
- secretDAL: secretV2BridgeDAL,
- secretVersionDAL: secretVersionV2BridgeDAL,
- secretTagDAL,
- secretVersionTagDAL: secretVersionTagV2BridgeDAL,
- resourceMetadataDAL,
- folderCommitService
- })
- : [];
-
- // update the ref's for any secret key renames
- const secretKeyRenames = secretUpdationCommits.filter((el) => el.secret && el.key !== el.secret.key);
-
- if (secretKeyRenames.length > 0) {
- // get folder path for reference updates
- const folderPaths = await folderDAL.findSecretPathByFolderIds(projectId, [folderId], tx);
- const secretPath = folderPaths?.[0]?.path || "/";
-
- for await (const rename of secretKeyRenames) {
- // eslint-disable-next-line no-continue
- if (!rename.secret || !rename.secretId) continue;
-
- await fnUpdateSecretLinkedReferences({
- orgId: actorOrgId,
- projectId,
- environment,
- secretPath,
- folderId,
- oldSecretKey: rename.secret.key,
- newSecretKey: rename.key,
- secretId: rename.secretId,
- secretDAL: secretV2BridgeDAL,
- secretVersionDAL: secretVersionV2BridgeDAL,
- folderCommitService,
- secretQueueService,
- folderDAL,
- encryptor: ({ plainText }) => secretManagerEncryptor({ plainText }),
- decryptor: ({ cipherTextBlob }) => secretManagerDecryptor({ cipherTextBlob }),
- generateSecretBlindIndex,
- tx
- });
- }
- }
-
- const deletedSecret = secretDeletionCommits.length
- ? await fnSecretV2BridgeBulkDelete({
- projectId,
- folderId,
- tx,
- actorId,
- actorType: actor,
- secretDAL: secretV2BridgeDAL,
- secretQueueService,
- inputSecrets: secretDeletionCommits.map(({ key }) => ({ secretKey: key, type: SecretType.Shared })),
- folderCommitService,
- secretVersionDAL: secretVersionV2BridgeDAL
- })
- : [];
const updatedSecretApproval = await secretApprovalRequestDAL.updateById(
secretApprovalRequest.id,
@@ -1201,10 +915,7 @@ export const secretApprovalRequestServiceFactory = ({
tx
);
await secretV2BridgeDAL.invalidateSecretCacheByProjectId(projectId, tx);
- return {
- secrets: { created: newSecrets, updated: updatedSecrets, deleted: deletedSecret },
- approval: updatedSecretApproval
- };
+ return { secrets, approval: updatedSecretApproval };
});
} else {
const secretApprovalSecrets = await secretApprovalRequestSecretDAL.findByRequestId(secretApprovalRequest.id);
@@ -1399,11 +1110,6 @@ export const secretApprovalRequestServiceFactory = ({
});
}
- const [folder] = await folderDAL.findSecretPathByFolderIds(projectId, [folderId]);
- if (!folder) {
- throw new NotFoundError({ message: `Folder with ID '${folderId}' not found in project with ID '${projectId}'` });
- }
-
const { secrets } = mergeStatus;
const events: TProjectEventPayload[] = [];
if (secrets.created.length > 0) {
@@ -1477,67 +1183,20 @@ export const secretApprovalRequestServiceFactory = ({
}
if (isSoftEnforcement && !hasMinApproval) {
- const cfg = getConfig();
const env = await projectEnvDAL.findOne({ slug: environment, projectId });
- const requestedByUser = await userDAL.findOne({ id: actorId });
- const approverUsers = await userDAL.find({
- $in: {
- id: policy.approvers.map((approver: { userId: string | null | undefined }) => approver.userId!)
- }
+ await notifySecretApprovalBypass({
+ project,
+ environmentName: env.name,
+ secretPath: policy.secretPath,
+ actorId,
+ approverUserIds: policy.approvers.map((approver: { userId: string | null | undefined }) => approver.userId!),
+ bypassReason
});
-
- await notificationService.createUserNotifications(
- approverUsers.map((approver) => ({
- userId: approver.id,
- orgId: project.orgId,
- type: NotificationType.SECRET_CHANGE_POLICY_BYPASSED,
- title: "Secret Change Policy Bypassed",
- body: `**${requestedByUser.firstName} ${requestedByUser.lastName}** (${requestedByUser.email}) has merged a secret to **${policy.secretPath}** in the **${env.name}** environment for project **${project.name}** without obtaining the required approval.`,
- link: `/projects/secret-management/${project.id}/approval`
- }))
- );
-
- const recipients = approverUsers.filter((approver) => approver.email).map((approver) => approver.email!);
-
- if (recipients?.length) {
- await smtpService.sendMail({
- recipients,
- subjectLine: "Infisical Secret Change Policy Bypassed",
-
- substitutions: {
- projectName: project.name,
- requesterFullName: `${requestedByUser.firstName} ${requestedByUser.lastName}`,
- requesterEmail: requestedByUser.email,
- bypassReason,
- secretPath: policy.secretPath,
- environment: env.name,
- approvalUrl: `${cfg.SITE_URL}/organizations/${project.orgId}/projects/secret-management/${project.id}/approval`
- },
- template: SmtpTemplates.AccessSecretRequestBypassed
- });
- }
}
const { created, updated, deleted } = mergeStatus.secrets;
- const requestedByActor: Actor | undefined = secretApprovalRequest.committerUserId
- ? {
- type: ActorType.USER,
- metadata: {
- userId: secretApprovalRequest.committerUserId,
- email: secretApprovalRequest.committerUser?.email,
- username: secretApprovalRequest.committerUser?.username ?? ""
- }
- }
- : secretApprovalRequest.committerIdentity
- ? {
- type: ActorType.IDENTITY,
- metadata: {
- identityId: secretApprovalRequest.committerIdentity.identityId,
- name: secretApprovalRequest.committerIdentity.name
- }
- }
- : undefined;
+ const requestedByActor = buildRequestedByActor(secretApprovalRequest);
const secretMutationEvents: Event[] = [];
diff --git a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-fns.ts b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-fns.ts
index 9fcba55b16..52eb5ddb02 100644
--- a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-fns.ts
+++ b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-fns.ts
@@ -33,6 +33,7 @@ import { PostHogEventTypes } from "@app/services/telemetry/telemetry-types";
import { TUserDALFactory } from "@app/services/user/user-dal";
import { ChangeRequestWebhookAction, TWebhookActor, WebhookEvents } from "@app/services/webhook/webhook-types";
+import { TSecretApprovalBridgeCommit } from "../secret-approval-request/secret-approval-request-merge-fns";
import { TSecretChangePolicy } from "../secret-change-policy-bridge/secret-change-policy-bridge-types";
import { TSecretChangeRequest } from "./secret-change-request-bridge-types";
@@ -102,6 +103,17 @@ export const toSecretChangeRequest = ({
commits
});
+export const toSecretChangeRequestCommit = ({
+ secret,
+ secretVersion,
+ tags,
+ oldSecretMetadata,
+ ...commit
+}: TSecretApprovalBridgeCommit): TSecretApprovalRequestsSecretsV2 => ({
+ ...commit,
+ secretVersion: secretVersion?.id ?? null
+});
+
export const toSecretChangeRequestReview = (
approval: TApprovalRequestApprovals,
requestId: string
@@ -212,11 +224,12 @@ export const secretChangeRequestFnsFactory = ({
project,
environment,
environmentName,
- secretPath
+ secretPath,
+ isBypassed
}: Pick<
TSecretChangeRequestSideEffectsDTO,
"approvalRequest" | "secretChangeRequest" | "policy" | "project" | "environment" | "secretPath"
- > & { action: ChangeRequestWebhookAction; environmentName: string }) => {
+ > & { action: ChangeRequestWebhookAction; environmentName: string; isBypassed?: boolean }) => {
const requestedBy: TWebhookActor | null = approvalRequest.requesterId
? {
type: ActorType.USER,
@@ -244,7 +257,7 @@ export const secretChangeRequestFnsFactory = ({
url: buildApprovalUrl(project.orgId, project.id, approvalRequest.id),
status: approvalRequest.status,
hasMerged: secretChangeRequest.hasMerged,
- isBypassed: Boolean(secretChangeRequest.bypassReason),
+ isBypassed: isBypassed ?? Boolean(secretChangeRequest.bypassReason),
policy: { id: policy.id, name: policy.name, enforcementLevel: policy.enforcementLevel },
requestedBy,
createdAt: approvalRequest.createdAt.toISOString(),
diff --git a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.test.ts b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.test.ts
index 86392b3883..29cbe5dfc9 100644
--- a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.test.ts
+++ b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.test.ts
@@ -2,6 +2,7 @@ import { Knex } from "knex";
import { beforeEach, describe, expect, test, vi } from "vitest";
import { ProjectMembershipRole } from "@app/db/schemas";
+import { EventType } from "@app/ee/services/audit-log/audit-log-types";
import { BadRequestError, ForbiddenRequestError, NotFoundError } from "@app/lib/errors";
import {
ApprovalPolicyType,
@@ -20,12 +21,27 @@ const buildSecretApprovalCommits = vi.fn();
const resolveRequester = vi.fn();
const runSecretChangeRequestSideEffects = vi.fn().mockResolvedValue(undefined);
const queueChangeRequestWebhook = vi.fn().mockResolvedValue(undefined);
+const detectSecretApprovalCommitConflicts = vi.fn();
+const applySecretApprovalCommitsV2Bridge = vi.fn();
+const findMergedFolder = vi.fn();
+const syncMergedSecrets = vi.fn().mockResolvedValue(undefined);
+const notifySecretApprovalBypass = vi.fn().mockResolvedValue(undefined);
vi.mock("@app/lib/logger", () => ({ logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn(), debug: vi.fn() } }));
vi.mock("../secret-approval-request/secret-approval-request-commit-fns", async (importOriginal) => ({
...(await importOriginal<typeof import("../secret-approval-request/secret-approval-request-commit-fns")>()),
secretApprovalRequestCommitFnsFactory: () => ({ buildSecretApprovalCommits, validateSecrets: vi.fn() })
}));
+vi.mock("../secret-approval-request/secret-approval-request-merge-fns", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("../secret-approval-request/secret-approval-request-merge-fns")>()),
+ secretApprovalRequestMergeFnsFactory: () => ({
+ detectSecretApprovalCommitConflicts,
+ applySecretApprovalCommitsV2Bridge,
+ findMergedFolder,
+ syncMergedSecrets,
+ notifySecretApprovalBypass
+ })
+}));
vi.mock("./secret-change-request-bridge-fns", async (importOriginal) => ({
...(await importOriginal<typeof import("./secret-change-request-bridge-fns")>()),
secretChangeRequestFnsFactory: () => ({
@@ -42,6 +58,7 @@ const POLICY = {
name: "dev-policy",
enforcementLevel: "hard",
allowedSelfApprovals: true,
+ bypassers: [] as { type: string; id: string }[],
userApprovers: [{ userId: "approver-1" }]
};
const REVIEW_CREATED_AT = new Date("2026-02-01");
@@ -74,7 +91,7 @@ const REQUEST_STEP = {
{ type: ApproverType.User, id: "approver-1" },
{ type: ApproverType.Group, id: "group-1" }
],
- approvals: []
+ approvals: [] as { id: string; stepId: string; approverUserId: string; decision: ApprovalRequestApprovalDecision }[]
};
const PROJECT = { id: "project-1", name: "Project", orgId: "org-1" };
const REQUESTER = {
@@ -97,9 +114,37 @@ const BUNDLE = {
secretKeys: ["NEW_KEY", "OLD_KEY"]
};
+const MERGED_FOLDER = {
+ id: "folder-1",
+ envId: "env-1",
+ path: "/app",
+ environmentSlug: "dev",
+ environmentName: "Development"
+};
+const CIPHER = { cipher: "secret-manager" };
+const COMMIT_ROWS = [
+ {
+ id: "commit-1",
+ op: SecretOperations.Create,
+ key: "NEW_KEY",
+ version: 1,
+ secretId: null,
+ secret: undefined,
+ secretVersion: undefined,
+ tags: [],
+ oldSecretMetadata: []
+ }
+];
+const APPLIED_SECRETS = {
+ created: [{ id: "secret-1", key: "NEW_KEY", version: 1, tags: [], secretMetadata: [] }],
+ updated: [],
+ deleted: []
+};
+
const buildService = ({
policy = POLICY as typeof POLICY | null,
- steps = [{ requiredApprovals: 1, approvers: [{ type: ApproverType.User, id: "approver-1" }] }]
+ steps = [{ requiredApprovals: 1, approvers: [{ type: ApproverType.User, id: "approver-1" }] }],
+ requestSteps = [REQUEST_STEP] as (typeof REQUEST_STEP)[]
} = {}) => {
let requestCounter = 0;
const hasRole = vi.fn().mockReturnValue(false);
@@ -107,7 +152,10 @@ const buildService = ({
approvalRequestDAL: {
findById: vi.fn().mockResolvedValue(APPROVAL_REQUEST),
findByIdForUpdate: vi.fn().mockResolvedValue(APPROVAL_REQUEST),
- findStepsByRequestId: vi.fn().mockResolvedValue([REQUEST_STEP]),
+ findStepsByRequestId: vi.fn().mockResolvedValue(requestSteps),
+ updateById: vi.fn((id: string, row: Record<string, unknown>) =>
+ Promise.resolve({ ...APPROVAL_REQUEST, id, ...row, updatedAt: new Date("2026-03-01") })
+ ),
create: vi.fn((row: Record<string, unknown>) => {
requestCounter += 1;
return Promise.resolve({
@@ -139,11 +187,24 @@ const buildService = ({
create: vi.fn((row: Record<string, unknown>) =>
Promise.resolve({ id: "change-1", conflicts: null, bypassReason: null, statusChangedByUserId: null, ...row })
),
- findOne: vi.fn().mockResolvedValue(SECRET_CHANGE_REQUEST)
+ findOne: vi.fn().mockResolvedValue(SECRET_CHANGE_REQUEST),
+ updateById: vi.fn((id: string, row: Record<string, unknown>) =>
+ Promise.resolve({
+ ...SECRET_CHANGE_REQUEST,
+ id,
+ ...row,
+ conflicts: typeof row.conflicts === "string" ? (JSON.parse(row.conflicts) as unknown) : row.conflicts
+ })
+ )
},
- permissionService: { getProjectPermission: vi.fn().mockResolvedValue({ hasRole }) },
+ permissionService: { getProjectPermission: vi.fn().mockResolvedValue({ hasRole, permission: { can: vi.fn() } }) },
licenseService: { getPlan: vi.fn().mockResolvedValue({ secretApproval: true }) },
- userGroupMembershipDAL: { findGroupMembershipsByUserIdInOrg: vi.fn().mockResolvedValue([]) },
+ userGroupMembershipDAL: {
+ findGroupMembershipsByUserIdInOrg: vi.fn().mockResolvedValue([]),
+ find: vi.fn().mockResolvedValue([])
+ },
+ kmsService: { createCipherPairWithDataKey: vi.fn().mockResolvedValue(CIPHER) },
+ secretV2BridgeDAL: { invalidateSecretCacheByProjectId: vi.fn().mockResolvedValue(undefined) },
projectDAL: { findById: vi.fn().mockResolvedValue(PROJECT) },
folderDAL: {
findSecretPathByFolderIds: vi
@@ -154,7 +215,8 @@ const buildService = ({
insertV2Bridge: vi.fn<(rows: Record<string, unknown>[], tx?: Knex) => Promise<Record<string, unknown>[]>>(
(rows) => Promise.resolve(rows.map((row, index) => ({ id: `commit-${index}`, ...row })))
),
- insertApprovalSecretV2Tags: vi.fn().mockResolvedValue([])
+ insertApprovalSecretV2Tags: vi.fn().mockResolvedValue([]),
+ findBySecretChangeIdBridgeSecretV2: vi.fn().mockResolvedValue(COMMIT_ROWS)
},
secretChangePolicyBridgeService: { findSecretChangePolicyById: vi.fn().mockResolvedValue(policy) }
};
@@ -533,3 +595,285 @@ describe("secretChangeRequestBridge reviewSecretChangeRequest", () => {
expect(queueChangeRequestWebhook).toHaveBeenCalledTimes(1);
});
});
+
+describe("secretChangeRequestBridge mergeSecretChangeRequest", () => {
+ const approvedBy = (...userIds: string[]) =>
+ userIds.map((approverUserId, index) => ({
+ id: `approval-${index}`,
+ stepId: "step-1",
+ approverUserId,
+ decision: ApprovalRequestApprovalDecision.Approved
+ }));
+ const stepWith = (overrides: Partial<typeof REQUEST_STEP>) => ({ ...REQUEST_STEP, ...overrides });
+
+ beforeEach(() => {
+ queueChangeRequestWebhook.mockClear();
+ syncMergedSecrets.mockClear();
+ notifySecretApprovalBypass.mockClear();
+ detectSecretApprovalCommitConflicts
+ .mockReset()
+ .mockResolvedValue({ conflicts: [], creates: COMMIT_ROWS, updates: [], deletes: [] });
+ applySecretApprovalCommitsV2Bridge.mockReset().mockResolvedValue(APPLIED_SECRETS);
+ findMergedFolder.mockReset().mockResolvedValue(MERGED_FOLDER);
+ });
+
+ const merge = (service: ReturnType<typeof buildService>["service"], overrides: Record<string, unknown> = {}) =>
+ service.mergeSecretChangeRequest({
+ approvalId: "request-1",
+ actor: ActorType.USER,
+ actorId: "approver-1",
+ actorOrgId: "org-1",
+ actorAuthMethod: null,
+ ...overrides
+ } as Parameters<ReturnType<typeof buildService>["service"]["mergeSecretChangeRequest"]>[0]);
+
+ test("applies the commits under the request lock, closes the request and reports the merge", async () => {
+ const { service, deps } = buildService({ requestSteps: [stepWith({ approvals: approvedBy("approver-1") })] });
+
+ const result = await merge(service);
+
+ expect(deps.approvalRequestDAL.findByIdForUpdate).toHaveBeenCalledWith("request-1", OWN_TX);
+ expect(detectSecretApprovalCommitConflicts).toHaveBeenCalledWith({ folderId: "folder-1", commits: COMMIT_ROWS });
+ expect(deps.kmsService.createCipherPairWithDataKey).toHaveBeenCalledTimes(1);
+ expect(applySecretApprovalCommitsV2Bridge).toHaveBeenCalledWith(
+ expect.objectContaining({
+ projectId: "project-1",
+ folderId: "folder-1",
+ environment: "dev",
+ envId: "env-1",
+ secretPath: "/app",
+ actor: ActorType.USER,
+ actorId: "approver-1",
+ actorOrgId: "org-1",
+ cipher: CIPHER,
+ creates: COMMIT_ROWS,
+ updates: [],
+ deletes: [],
+ tx: OWN_TX
+ })
+ );
+ expect(deps.secretChangeRequestDAL.updateById).toHaveBeenCalledWith(
+ "change-1",
+ { conflicts: "[]", hasMerged: true, statusChangedByUserId: "approver-1", bypassReason: null },
+ OWN_TX
+ );
+ expect(deps.approvalRequestDAL.updateById).toHaveBeenCalledWith(
+ "request-1",
+ { status: ApprovalRequestStatus.Closed },
+ OWN_TX
+ );
+ expect(deps.secretV2BridgeDAL.invalidateSecretCacheByProjectId).toHaveBeenCalledWith("project-1", OWN_TX);
+
+ expect(syncMergedSecrets).toHaveBeenCalledWith({
+ projectId: "project-1",
+ actorOrgId: "org-1",
+ actor: ActorType.USER,
+ actorId: "approver-1",
+ folder: MERGED_FOLDER,
+ secrets: APPLIED_SECRETS
+ });
+ expect(queueChangeRequestWebhook).toHaveBeenCalledWith(
+ expect.objectContaining({
+ action: ChangeRequestWebhookAction.Merged,
+ approvalRequest: expect.objectContaining({ status: ApprovalRequestStatus.Closed }) as unknown,
+ secretChangeRequest: expect.objectContaining({ hasMerged: true }) as unknown,
+ environment: "dev",
+ secretPath: "/app",
+ isBypassed: false
+ })
+ );
+ expect(notifySecretApprovalBypass).not.toHaveBeenCalled();
+
+ expect(result).toMatchObject({
+ projectId: "project-1",
+ isMergedViaBypass: false,
+ secrets: APPLIED_SECRETS,
+ approval: {
+ id: "request-1",
+ slug: "slug-1",
+ status: ApprovalRequestStatus.Closed,
+ hasMerged: true,
+ conflicts: [],
+ statusChangedByUserId: "approver-1",
+ committerUserId: "user-1",
+ commits: [{ id: "commit-1", key: "NEW_KEY", secretVersion: null }]
+ },
+ secretMutationEvents: [
+ {
+ type: EventType.CREATE_SECRET,
+ metadata: { environment: "dev", secretPath: "/app", secretId: "secret-1", secretKey: "NEW_KEY" }
+ }
+ ],
+ requestedByActor: { type: ActorType.USER, metadata: { userId: "user-1" } }
+ });
+ });
+
+ test("counts an approval from a member of an approver group", async () => {
+ const { service, deps } = buildService({
+ requestSteps: [
+ stepWith({ approvers: [{ type: ApproverType.Group, id: "group-1" }], approvals: approvedBy("member-1") })
+ ]
+ });
+ deps.userGroupMembershipDAL.find.mockResolvedValue([{ userId: "member-1" }]);
+ deps.userGroupMembershipDAL.findGroupMembershipsByUserIdInOrg.mockResolvedValue([{ groupId: "group-1" }]);
+
+ await expect(merge(service, { actorId: "member-1" })).resolves.toMatchObject({ isMergedViaBypass: false });
+ expect(deps.userGroupMembershipDAL.find).toHaveBeenCalledWith({ groupId: "group-1" });
+ });
+
+ test("ignores an approval from someone who is not an approver on the step", async () => {
+ const { service, hasRole } = buildService({ requestSteps: [stepWith({ approvals: approvedBy("admin-1") })] });
+ hasRole.mockReturnValue(true);
+
+ await expect(merge(service, { actorId: "admin-1" })).rejects.toThrow(
+ new BadRequestError({ message: "Secret approval request 'slug-1' needs 1 approval(s) on step 1 and has 0." })
+ );
+ expect(applySecretApprovalCommitsV2Bridge).not.toHaveBeenCalled();
+ });
+
+ test("requires every step to be approved, not only the current one", async () => {
+ const { service } = buildService({
+ requestSteps: [
+ stepWith({ approvals: approvedBy("approver-1") }),
+ stepWith({
+ id: "step-2",
+ stepNumber: 2,
+ requiredApprovals: 2,
+ approvers: [{ type: ApproverType.User, id: "approver-2" }],
+ approvals: []
+ })
+ ]
+ });
+
+ await expect(merge(service)).rejects.toThrow(
+ new BadRequestError({ message: "Secret approval request 'slug-1' needs 2 approval(s) on step 2 and has 0." })
+ );
+ });
+
+ test("lets a soft policy without bypassers merge unapproved and records the bypass", async () => {
+ const { service, deps } = buildService({ policy: { ...POLICY, enforcementLevel: "soft" } });
+
+ const result = await merge(service, { actorId: "user-1", bypassReason: "incident" });
+
+ expect(deps.secretChangeRequestDAL.updateById).toHaveBeenCalledWith(
+ "change-1",
+ expect.objectContaining({ hasMerged: true, bypassReason: "incident" }),
+ OWN_TX
+ );
+ expect(queueChangeRequestWebhook).toHaveBeenCalledWith(expect.objectContaining({ isBypassed: true }));
+ expect(notifySecretApprovalBypass).toHaveBeenCalledWith({
+ project: PROJECT,
+ environmentName: "Development",
+ secretPath: "/app",
+ actorId: "user-1",
+ approverUserIds: ["approver-1"],
+ bypassReason: "incident"
+ });
+ expect(result).toMatchObject({ isMergedViaBypass: true, approval: { bypassReason: "incident" } });
+ });
+
+ test("only a listed bypasser, directly or through a group, can bypass a soft policy", async () => {
+ const policy = { ...POLICY, enforcementLevel: "soft", bypassers: [{ type: "group", id: "group-9" }] };
+ const refused = buildService({ policy });
+ await expect(merge(refused.service, { actorId: "user-1" })).rejects.toBeInstanceOf(BadRequestError);
+
+ const allowed = buildService({ policy });
+ allowed.deps.userGroupMembershipDAL.findGroupMembershipsByUserIdInOrg.mockResolvedValue([{ groupId: "group-9" }]);
+ await expect(merge(allowed.service, { actorId: "user-1" })).resolves.toMatchObject({ isMergedViaBypass: true });
+
+ const direct = buildService({ policy: { ...policy, bypassers: [{ type: "user", id: "user-1" }] } });
+ await expect(merge(direct.service, { actorId: "user-1" })).resolves.toMatchObject({ isMergedViaBypass: true });
+ });
+
+ test("does not persist a bypass reason on a fully approved merge", async () => {
+ const { service, deps } = buildService({
+ policy: { ...POLICY, enforcementLevel: "soft" },
+ requestSteps: [stepWith({ approvals: approvedBy("approver-1") })]
+ });
+
+ await merge(service, { bypassReason: "not needed" });
+
+ expect(deps.secretChangeRequestDAL.updateById).toHaveBeenCalledWith(
+ "change-1",
+ expect.objectContaining({ bypassReason: null }),
+ OWN_TX
+ );
+ expect(notifySecretApprovalBypass).not.toHaveBeenCalled();
+ });
+
+ test("refuses when the plan lacks secret approvals", async () => {
+ const { service, deps } = buildService();
+ deps.licenseService.getPlan.mockResolvedValue({ secretApproval: false });
+
+ await expect(merge(service)).rejects.toBeInstanceOf(BadRequestError);
+ expect(deps.approvalRequestDAL.findById).not.toHaveBeenCalled();
+ });
+
+ test("refuses a non-user actor, a merged request and a request that is not open", async () => {
+ const { service, deps } = buildService({ requestSteps: [stepWith({ approvals: approvedBy("approver-1") })] });
+
+ await expect(merge(service, { actor: ActorType.IDENTITY })).rejects.toThrow(
+ new BadRequestError({ message: "Must be a user" })
+ );
+
+ deps.secretChangeRequestDAL.findOne.mockResolvedValueOnce({ ...SECRET_CHANGE_REQUEST, hasMerged: true });
+ await expect(merge(service)).rejects.toThrow(
+ new BadRequestError({ message: "This secret approval request has already been merged." })
+ );
+
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce({
+ ...APPROVAL_REQUEST,
+ status: ApprovalRequestStatus.Closed
+ });
+ await expect(merge(service)).rejects.toThrow(
+ new BadRequestError({ message: "You can only merge open approval requests" })
+ );
+ expect(applySecretApprovalCommitsV2Bridge).not.toHaveBeenCalled();
+ });
+
+ test("refuses when the request was closed between the checks and the lock", async () => {
+ const { service, deps } = buildService({ requestSteps: [stepWith({ approvals: approvedBy("approver-1") })] });
+ deps.approvalRequestDAL.findByIdForUpdate.mockResolvedValueOnce({
+ ...APPROVAL_REQUEST,
+ status: ApprovalRequestStatus.Closed
+ });
+
+ await expect(merge(service)).rejects.toBeInstanceOf(BadRequestError);
+ expect(applySecretApprovalCommitsV2Bridge).not.toHaveBeenCalled();
+ expect(deps.secretChangeRequestDAL.updateById).not.toHaveBeenCalled();
+ });
+
+ test("reads an unknown id or a request of another type as not found", async () => {
+ const { service, deps } = buildService();
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce(null);
+ await expect(merge(service)).rejects.toBeInstanceOf(NotFoundError);
+
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce({ ...APPROVAL_REQUEST, type: ApprovalPolicyType.PamAccess });
+ await expect(merge(service)).rejects.toBeInstanceOf(NotFoundError);
+ });
+
+ test("refuses a request whose policy is gone", async () => {
+ const { service } = buildService({ policy: null });
+ await expect(merge(service)).rejects.toThrow(
+ new BadRequestError({ message: "The policy associated with this secret approval request has been deleted." })
+ );
+ });
+
+ test("forbids a user who is neither admin, requester nor an eligible approver", async () => {
+ const { service } = buildService({ requestSteps: [stepWith({ approvals: approvedBy("approver-1") })] });
+ await expect(merge(service, { actorId: "stranger-1" })).rejects.toBeInstanceOf(ForbiddenRequestError);
+ });
+
+ test("lets the requester merge once the approvers have approved", async () => {
+ const { service } = buildService({ requestSteps: [stepWith({ approvals: approvedBy("approver-1") })] });
+ await expect(merge(service, { actorId: "user-1" })).resolves.toMatchObject({ isMergedViaBypass: false });
+ });
+
+ test("keeps the merge when the webhook cannot be queued", async () => {
+ const { service } = buildService({ requestSteps: [stepWith({ approvals: approvedBy("approver-1") })] });
+ queueChangeRequestWebhook.mockRejectedValueOnce(new Error("redis down"));
+
+ await expect(merge(service)).resolves.toMatchObject({ approval: { hasMerged: true } });
+ expect(syncMergedSecrets).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.ts b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.ts
index 980ac3bf05..5073ee99eb 100644
--- a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.ts
+++ b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.ts
@@ -2,9 +2,10 @@ import { Knex } from "knex";
import { ActionProjectType, ProjectMembershipRole } from "@app/db/schemas";
import { BadRequestError, ForbiddenRequestError, NotFoundError } from "@app/lib/errors";
-import { groupBy } from "@app/lib/fn";
+import { groupBy, unique } from "@app/lib/fn";
import { logger } from "@app/lib/logger";
import { alphaNumericNanoId } from "@app/lib/nanoid";
+import { EnforcementLevel } from "@app/lib/types";
import { TQueueServiceFactory } from "@app/queue";
import { TApprovalPolicyDALFactory } from "@app/services/approval-policy/approval-policy-dal";
import {
@@ -21,20 +22,26 @@ import {
import {
createApprovalRequestWithSteps,
isEligibleStepApprover,
+ resolveStepApproverUserIds,
upsertApprovalRequestStepDecision
} from "@app/services/approval-policy/approval-request-fns";
import { ActorType } from "@app/services/auth/auth-type";
+import { TFolderCommitServiceFactory } from "@app/services/folder-commit/folder-commit-service";
import { TIdentityDALFactory } from "@app/services/identity/identity-dal";
import { TKmsServiceFactory } from "@app/services/kms/kms-service";
+import { KmsDataKey } from "@app/services/kms/kms-types";
import { TMicrosoftTeamsServiceFactory } from "@app/services/microsoft-teams/microsoft-teams-service";
import { TProjectMicrosoftTeamsConfigDALFactory } from "@app/services/microsoft-teams/project-microsoft-teams-config-dal";
import { TNotificationServiceFactory } from "@app/services/notification/notification-service";
import { TProjectDALFactory } from "@app/services/project/project-dal";
import { TProjectEnvDALFactory } from "@app/services/project-env/project-env-dal";
+import { TResourceMetadataDALFactory } from "@app/services/resource-metadata/resource-metadata-dal";
+import { TSecretQueueFactory } from "@app/services/secret/secret-queue";
import { TSecretFolderDALFactory } from "@app/services/secret-folder/secret-folder-dal";
import { TSecretTagDALFactory } from "@app/services/secret-tag/secret-tag-dal";
import { TSecretV2BridgeDALFactory } from "@app/services/secret-v2-bridge/secret-v2-bridge-dal";
import { TSecretVersionV2DALFactory } from "@app/services/secret-v2-bridge/secret-version-dal";
+import { TSecretVersionV2TagDALFactory } from "@app/services/secret-v2-bridge/secret-version-tag-dal";
import { TSecretValidationRuleServiceFactory } from "@app/services/secret-validation-rule/secret-validation-rule-service";
import { TProjectSlackConfigDALFactory } from "@app/services/slack/project-slack-config-dal";
import { TSmtpService } from "@app/services/smtp/smtp-service";
@@ -42,6 +49,7 @@ import { TTelemetryServiceFactory } from "@app/services/telemetry/telemetry-serv
import { TUserDALFactory } from "@app/services/user/user-dal";
import { ChangeRequestWebhookAction } from "@app/services/webhook/webhook-types";
+import { BypasserType } from "../access-approval-policy/access-approval-policy-types";
import { TUserGroupMembershipDALFactory } from "../group/user-group-membership-dal";
import { TLicenseServiceFactory } from "../license/license-service";
import { TPermissionServiceFactory } from "../permission/permission-service-types";
@@ -49,12 +57,18 @@ import {
pickApprovalCommitColumns,
secretApprovalRequestCommitFnsFactory
} from "../secret-approval-request/secret-approval-request-commit-fns";
+import {
+ buildRequestedByActor,
+ buildSecretMutationEvents,
+ secretApprovalRequestMergeFnsFactory
+} from "../secret-approval-request/secret-approval-request-merge-fns";
import { TSecretApprovalRequestSecretDALFactory } from "../secret-approval-request/secret-approval-request-secret-dal";
import { ApprovalStatus } from "../secret-approval-request/secret-approval-request-types";
import { TSecretChangePolicyBridgeServiceFactory } from "../secret-change-policy-bridge/secret-change-policy-bridge-service";
import {
secretChangeRequestFnsFactory,
toSecretChangeRequest,
+ toSecretChangeRequestCommit,
toSecretChangeRequestReview
} from "./secret-change-request-bridge-fns";
import { TSecretChangeRequestBridgeMethods } from "./secret-change-request-bridge-types";
@@ -63,30 +77,48 @@ import { TSecretChangeRequestDALFactory } from "./secret-change-request-dal";
type TSecretChangeRequestBridgeServiceFactoryDep = {
approvalRequestDAL: Pick<
TApprovalRequestDALFactory,
- "findById" | "findByIdForUpdate" | "findStepsByRequestId" | "create" | "transaction"
+ "findById" | "findByIdForUpdate" | "findStepsByRequestId" | "create" | "updateById" | "transaction"
>;
approvalRequestStepsDAL: Pick<TApprovalRequestStepsDALFactory, "create">;
approvalRequestStepEligibleApproversDAL: Pick<TApprovalRequestStepEligibleApproversDALFactory, "create">;
approvalRequestApprovalsDAL: Pick<TApprovalRequestApprovalsDALFactory, "findOne" | "create" | "updateById">;
approvalPolicyDAL: Pick<TApprovalPolicyDALFactory, "findStepsByPolicyId">;
- secretChangeRequestDAL: Pick<TSecretChangeRequestDALFactory, "create" | "findOne">;
+ secretChangeRequestDAL: Pick<TSecretChangeRequestDALFactory, "create" | "findOne" | "updateById">;
secretApprovalRequestSecretDAL: Pick<
TSecretApprovalRequestSecretDALFactory,
- "insertV2Bridge" | "insertApprovalSecretV2Tags"
+ "insertV2Bridge" | "insertApprovalSecretV2Tags" | "updateV2ById" | "findBySecretChangeIdBridgeSecretV2"
>;
secretChangePolicyBridgeService: Pick<TSecretChangePolicyBridgeServiceFactory, "findSecretChangePolicyById">;
permissionService: Pick<TPermissionServiceFactory, "getProjectPermission">;
licenseService: Pick<TLicenseServiceFactory, "getPlan">;
- userGroupMembershipDAL: Pick<TUserGroupMembershipDALFactory, "findGroupMembershipsByUserIdInOrg">;
+ userGroupMembershipDAL: Pick<TUserGroupMembershipDALFactory, "findGroupMembershipsByUserIdInOrg" | "find">;
folderDAL: Pick<TSecretFolderDALFactory, "findBySecretPath" | "findSecretPathByFolderIds">;
projectDAL: Pick<TProjectDALFactory, "findById" | "findProjectWithOrg">;
projectEnvDAL: Pick<TProjectEnvDALFactory, "findOne">;
kmsService: Pick<TKmsServiceFactory, "createCipherPairWithDataKey">;
- secretV2BridgeDAL: Pick<TSecretV2BridgeDALFactory, "findBySecretKeys" | "find">;
- secretVersionV2BridgeDAL: Pick<TSecretVersionV2DALFactory, "findLatestVersionMany">;
- secretTagDAL: Pick<TSecretTagDALFactory, "findManyTagsById">;
+ secretV2BridgeDAL: Pick<
+ TSecretV2BridgeDALFactory,
+ | "insertMany"
+ | "upsertSecretReferences"
+ | "findBySecretKeys"
+ | "bulkUpdate"
+ | "deleteMany"
+ | "find"
+ | "invalidateSecretCacheByProjectId"
+ | "updateById"
+ | "findReferencedSecretReferencesBySecretKey"
+ | "updateSecretReferenceSecretKey"
+ | "updateSecretReferenceEnvAndPath"
+ | "findOne"
+ >;
+ secretVersionV2BridgeDAL: Pick<TSecretVersionV2DALFactory, "findLatestVersionMany" | "insertMany">;
+ secretVersionTagV2BridgeDAL: Pick<TSecretVersionV2TagDALFactory, "insertMany">;
+ secretTagDAL: Pick<TSecretTagDALFactory, "findManyTagsById" | "saveTagsToSecretV2" | "deleteTagsToSecretV2" | "find">;
+ resourceMetadataDAL: Pick<TResourceMetadataDALFactory, "insertMany" | "delete">;
+ folderCommitService: Pick<TFolderCommitServiceFactory, "createCommit">;
+ secretQueueService: Pick<TSecretQueueFactory, "syncSecrets" | "removeSecretReminder">;
secretValidationRuleService: Pick<TSecretValidationRuleServiceFactory, "validateSecrets">;
- userDAL: Pick<TUserDALFactory, "findById" | "find">;
+ userDAL: Pick<TUserDALFactory, "findById" | "find" | "findOne">;
identityDAL: Pick<TIdentityDALFactory, "findById">;
projectSlackConfigDAL: Pick<TProjectSlackConfigDALFactory, "getIntegrationDetailsByProject">;
projectMicrosoftTeamsConfigDAL: Pick<TProjectMicrosoftTeamsConfigDALFactory, "getIntegrationDetailsByProject">;
@@ -120,7 +152,11 @@ export const secretChangeRequestBridgeServiceFactory = ({
kmsService,
secretV2BridgeDAL,
secretVersionV2BridgeDAL,
+ secretVersionTagV2BridgeDAL,
secretTagDAL,
+ resourceMetadataDAL,
+ folderCommitService,
+ secretQueueService,
secretValidationRuleService,
userDAL,
identityDAL,
@@ -132,7 +168,7 @@ export const secretChangeRequestBridgeServiceFactory = ({
queueService,
telemetryService
}: TSecretChangeRequestBridgeServiceFactoryDep) => {
- const { buildSecretApprovalCommits } = secretApprovalRequestCommitFnsFactory({
+ const { buildSecretApprovalCommits, validateSecrets } = secretApprovalRequestCommitFnsFactory({
permissionService,
folderDAL,
projectDAL,
@@ -143,6 +179,28 @@ export const secretChangeRequestBridgeServiceFactory = ({
secretValidationRuleService
});
+ const {
+ detectSecretApprovalCommitConflicts,
+ applySecretApprovalCommitsV2Bridge,
+ findMergedFolder,
+ syncMergedSecrets,
+ notifySecretApprovalBypass
+ } = secretApprovalRequestMergeFnsFactory({
+ folderDAL,
+ secretV2BridgeDAL,
+ secretVersionV2BridgeDAL,
+ secretVersionTagV2BridgeDAL,
+ secretTagDAL,
+ resourceMetadataDAL,
+ folderCommitService,
+ secretQueueService,
+ secretApprovalRequestSecretDAL,
+ validateSecrets,
+ userDAL,
+ notificationService,
+ smtpService
+ });
+
const { resolveRequester, queueChangeRequestWebhook, runSecretChangeRequestSideEffects } =
secretChangeRequestFnsFactory({
userDAL,
@@ -269,10 +327,207 @@ export const secretChangeRequestBridgeServiceFactory = ({
return result;
};
- const mergeSecretChangeRequest: TSecretChangeRequestBridgeMethods["mergeSecretChangeRequest"] = async () => {
+ const createSecretChangeRequest: TSecretChangeRequestBridgeMethods["createSecretChangeRequest"] = async () => {
throw notAvailable();
};
+ const mergeSecretChangeRequest: TSecretChangeRequestBridgeMethods["mergeSecretChangeRequest"] = async ({
+ approvalId,
+ actor,
+ actorId,
+ actorAuthMethod,
+ actorOrgId,
+ bypassReason
+ }) => {
+ const plan = await licenseService.getPlan(actorOrgId);
+ if (!plan.secretApproval) {
+ throw new BadRequestError({
+ message:
+ "Failed to merge secret approval request due to plan restriction. Upgrade plan to merge secret approval request."
+ });
+ }
+
+ const { approvalRequest, secretChangeRequest } = await $findSecretChangeRequestOrThrow(approvalId);
+ if (actor !== ActorType.USER) throw new BadRequestError({ message: "Must be a user" });
+
+ if (secretChangeRequest.hasMerged) {
+ throw new BadRequestError({ message: "This secret approval request has already been merged." });
+ }
+ if (approvalRequest.status !== ApprovalRequestStatus.Open) {
+ throw new BadRequestError({ message: "You can only merge open approval requests" });
+ }
+
+ const policy = await $findSecretChangePolicyOrThrow(approvalRequest.policyId);
+ const { projectId } = approvalRequest;
+
+ const { hasRole, permission } = await permissionService.getProjectPermission({
+ actor: ActorType.USER,
+ actorId,
+ projectId,
+ actorAuthMethod,
+ actorOrgId,
+ actionProjectType: ActionProjectType.SecretManager
+ });
+
+ const steps = await approvalRequestDAL.findStepsByRequestId(approvalRequest.id);
+ const currentStep = steps.find((step) => step.stepNumber === approvalRequest.currentStep);
+ if (!currentStep) {
+ throw new BadRequestError({
+ message: `Secret approval request with ID '${approvalId}' has no approval step to merge.`
+ });
+ }
+
+ const userGroups = await userGroupMembershipDAL.findGroupMembershipsByUserIdInOrg(actorId, actorOrgId);
+ const userGroupIds = new Set(userGroups.map((group) => group.groupId));
+ if (
+ !hasRole(ProjectMembershipRole.Admin) &&
+ approvalRequest.requesterId !== actorId &&
+ !isEligibleStepApprover(currentStep, actorId, userGroupIds)
+ ) {
+ throw new ForbiddenRequestError({ message: "User has insufficient privileges" });
+ }
+
+ const stepApprovals = await Promise.all(
+ steps.map(async (step) => {
+ const eligibleUserIds = await resolveStepApproverUserIds(step, userGroupMembershipDAL);
+ const approvedCount = new Set(
+ step.approvals
+ .filter(
+ (approval) =>
+ approval.decision === ApprovalRequestApprovalDecision.Approved &&
+ eligibleUserIds.has(approval.approverUserId)
+ )
+ .map((approval) => approval.approverUserId)
+ ).size;
+ return { step, approvedCount };
+ })
+ );
+ const unmetStep = stepApprovals.find(({ step, approvedCount }) => approvedCount < step.requiredApprovals);
+ const isSoftEnforcement = policy.enforcementLevel === EnforcementLevel.Soft;
+ const canBypass =
+ !policy.bypassers.length ||
+ policy.bypassers.some(
+ (bypasser) =>
+ (bypasser.type === BypasserType.User && bypasser.id === actorId) ||
+ (bypasser.type === BypasserType.Group && userGroupIds.has(bypasser.id))
+ );
+
+ if (unmetStep && !(isSoftEnforcement && canBypass)) {
+ throw new BadRequestError({
+ message: `Secret approval request '${secretChangeRequest.slug}' needs ${unmetStep.step.requiredApprovals} approval(s) on step ${unmetStep.step.stepNumber} and has ${unmetStep.approvedCount}.`
+ });
+ }
+ const isMergedViaBypass = isSoftEnforcement && Boolean(unmetStep);
+
+ const project = await projectDAL.findById(projectId);
+ if (!project) throw new NotFoundError({ message: `Project with ID '${projectId}' not found` });
+ const folder = await findMergedFolder(projectId, secretChangeRequest.folderId);
+ const commits = await secretApprovalRequestSecretDAL.findBySecretChangeIdBridgeSecretV2(secretChangeRequest.id);
+ const { conflicts, creates, updates, deletes } = await detectSecretApprovalCommitConflicts({
+ folderId: folder.id,
+ commits
+ });
+ const cipher = await kmsService.createCipherPairWithDataKey({ type: KmsDataKey.SecretManager, projectId });
+
+ const merged = await approvalRequestDAL.transaction(async (tx) => {
+ const locked = await approvalRequestDAL.findByIdForUpdate(approvalRequest.id, tx);
+ if (!locked || locked.status !== ApprovalRequestStatus.Open) {
+ throw new BadRequestError({ message: "You can only merge open approval requests" });
+ }
+
+ const secrets = await applySecretApprovalCommitsV2Bridge({
+ projectId,
+ folderId: folder.id,
+ environment: folder.environmentSlug,
+ envId: folder.envId,
+ secretPath: folder.path,
+ actor,
+ actorId,
+ actorOrgId,
+ permission,
+ cipher,
+ creates,
+ updates,
+ deletes,
+ tx
+ });
+
+ const mergedChangeRequest = await secretChangeRequestDAL.updateById(
+ secretChangeRequest.id,
+ {
+ conflicts: JSON.stringify(conflicts),
+ hasMerged: true,
+ statusChangedByUserId: actorId,
+ bypassReason: isMergedViaBypass ? (bypassReason ?? null) : null
+ },
+ tx
+ );
+ const mergedApprovalRequest = await approvalRequestDAL.updateById(
+ approvalRequest.id,
+ { status: ApprovalRequestStatus.Closed },
+ tx
+ );
+ await secretV2BridgeDAL.invalidateSecretCacheByProjectId(projectId, tx);
+
+ return { secrets, approvalRequest: mergedApprovalRequest, secretChangeRequest: mergedChangeRequest };
+ });
+
+ await syncMergedSecrets({ projectId, actorOrgId, actor, actorId, folder, secrets: merged.secrets });
+
+ try {
+ await queueChangeRequestWebhook({
+ action: ChangeRequestWebhookAction.Merged,
+ approvalRequest: merged.approvalRequest,
+ secretChangeRequest: merged.secretChangeRequest,
+ policy,
+ project,
+ environment: folder.environmentSlug,
+ environmentName: folder.environmentName,
+ secretPath: folder.path,
+ isBypassed: isMergedViaBypass
+ });
+ } catch (error) {
+ logger.error(
+ error,
+ `Failed to queue change request webhook [requestId=${approvalRequest.id}] [action=${ChangeRequestWebhookAction.Merged}]`
+ );
+ }
+
+ if (isMergedViaBypass) {
+ await notifySecretApprovalBypass({
+ project,
+ environmentName: folder.environmentName,
+ secretPath: folder.path,
+ actorId,
+ approverUserIds: unique(policy.userApprovers.map((approver) => approver.userId)),
+ bypassReason
+ });
+ }
+
+ return {
+ secrets: merged.secrets,
+ approval: toSecretChangeRequest({
+ approvalRequest: merged.approvalRequest,
+ secretChangeRequest: merged.secretChangeRequest,
+ commits: commits.map(toSecretChangeRequestCommit)
+ }),
+ projectId,
+ secretMutationEvents: buildSecretMutationEvents({
+ environment: folder.environmentSlug,
+ secretPath: folder.path,
+ secrets: merged.secrets
+ }),
+ isMergedViaBypass,
+ requestedByActor: buildRequestedByActor({
+ committerUserId: approvalRequest.requesterId,
+ committerUser: { email: approvalRequest.requesterEmail, username: approvalRequest.requesterEmail },
+ committerIdentity: approvalRequest.machineIdentityId
+ ? { identityId: approvalRequest.machineIdentityId, name: approvalRequest.requesterName }
+ : null
+ })
+ };
+ };
+
const reviewSecretChangeRequest: TSecretChangeRequestBridgeMethods["reviewSecretChangeRequest"] = async ({
approvalId,
actor,
@@ -391,6 +646,7 @@ export const secretChangeRequestBridgeServiceFactory = ({
return {
findSecretChangeRequest,
generateSecretChangeRequest,
+ createSecretChangeRequest,
mergeSecretChangeRequest,
reviewSecretChangeRequest,
updateSecretChangeRequestStatus,
diff --git a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-types.ts b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-types.ts
index 7bdd51711c..ed5db3be23 100644
--- a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-types.ts
+++ b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-types.ts
@@ -5,7 +5,9 @@ import {
TSecretApprovalRequestsReviewers,
TSecretApprovalRequestsSecretsV2
} from "@app/db/schemas";
+import { Actor, Event } from "@app/ee/services/audit-log/audit-log-types";
+import { TMergedSecretsV2Bridge } from "../secret-approval-request/secret-approval-request-merge-fns";
import {
TCreateSecretApprovalRequestV2BridgeDTO,
TGenerateSecretApprovalRequestV2BridgeDTO,
@@ -23,12 +25,21 @@ export type TSecretChangeRequest = TSecretApprovalRequests & { commits: TSecretA
export type TSecretChangeRequestReview = TSecretApprovalRequestsReviewers & { projectId: string };
+export type TSecretChangeRequestMergeResult = {
+ secrets: TMergedSecretsV2Bridge;
+ approval: TSecretChangeRequest;
+ projectId: string;
+ secretMutationEvents: Event[];
+ isMergedViaBypass: boolean;
+ requestedByActor?: Actor;
+};
+
export type TSecretChangeRequestBridgeMethods = {
generateSecretChangeRequest: (
dto: TGenerateSecretApprovalRequestV2BridgeDTO & { trx?: Knex; skipPostProcessing?: boolean }
) => Promise<TSecretChangeRequest>;
createSecretChangeRequest: (dto: TCreateSecretApprovalRequestV2BridgeDTO, tx?: Knex) => Promise<never>;
- mergeSecretChangeRequest: (dto: TMergeSecretApprovalRequestDTO) => Promise<never>;
+ mergeSecretChangeRequest: (dto: TMergeSecretApprovalRequestDTO) => Promise<TSecretChangeRequestMergeResult>;
reviewSecretChangeRequest: (dto: TReviewRequestDTO) => Promise<TSecretChangeRequestReview>;
updateSecretChangeRequestStatus: (dto: TStatusChangeDTO) => Promise<never>;
getSecretChangeRequestById: (dto: TSecretApprovalDetailsDTO) => Promise<never>;
diff --git a/backend/src/server/routes/index.ts b/backend/src/server/routes/index.ts
index cb4f937ce6..2882127371 100644
--- a/backend/src/server/routes/index.ts
+++ b/backend/src/server/routes/index.ts
@@ -2391,7 +2391,11 @@ export const registerRoutes = async (
kmsService,
secretV2BridgeDAL,
secretVersionV2BridgeDAL,
+ secretVersionTagV2BridgeDAL,
secretTagDAL,
+ resourceMetadataDAL,
+ folderCommitService,
+ secretQueueService,
secretValidationRuleService,
userDAL,
identityDAL,
diff --git a/backend/src/services/approval-policy/approval-request-fns.test.ts b/backend/src/services/approval-policy/approval-request-fns.test.ts
index e8cac087c0..1b6c276d33 100644
--- a/backend/src/services/approval-policy/approval-request-fns.test.ts
+++ b/backend/src/services/approval-policy/approval-request-fns.test.ts
@@ -42,7 +42,7 @@ describe("upsertApprovalRequestStepDecision", () => {
const result = await upsertApprovalRequestStepDecision(
{ stepId: "step-1", approverUserId: "user-1", decision: ApprovalRequestApprovalDecision.Approved, comment: "ok" },
- deps,
+ deps as unknown as Parameters<typeof upsertApprovalRequestStepDecision>[1],
TX
);
@@ -63,7 +63,7 @@ describe("upsertApprovalRequestStepDecision", () => {
const result = await upsertApprovalRequestStepDecision(
{ stepId: "step-1", approverUserId: "user-1", decision: ApprovalRequestApprovalDecision.Rejected },
- deps,
+ deps as unknown as Parameters<typeof upsertApprovalRequestStepDecision>[1],
TX
);