Skip to content

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

Merge branch 'main' into feat/adilsitos/secrets-723

adilsonf5451fc11516
diff --cc backend/src/ee/services/secret-approval-request/secret-approval-request-merge-fns.ts
index 2dfabbebbe,0000000000..663bd71301
mode 100644,000000..100644
--- 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
@@@ -1,680 -1,0 +1,683 @@@
+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 { TSecretBlindIndexer } from "@app/services/secret-v2-bridge/secret-blind-index-fns";
+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,
++ blindIndexer,
+ 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;
++ blindIndexer: TSecretBlindIndexer;
+ creates: TSecretApprovalBridgeCommit[];
+ updates: TSecretApprovalBridgeCommit[];
+ deletes: TSecretApprovalBridgeCommit[];
+ tx: Knex;
+ }): Promise<TMergedSecretsV2Bridge> => {
- const { decryptor: secretManagerDecryptor, generateSecretBlindIndex, encryptor: secretManagerEncryptor } = cipher;
++ const { decryptor: secretManagerDecryptor, 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)
++ ? blindIndexer.generateBlindIndexes(secretManagerDecryptor({ cipherTextBlob: el.encryptedValue }))
++ : Promise.resolve(null)
+ )
+ );
+
+ 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],
++ blindIndexes: 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,
++ blindIndexer,
+ 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);
++ ? blindIndexer.generateBlindIndexes(secretManagerDecryptor({ cipherTextBlob: el.encryptedValue as Buffer }))
++ : Promise.resolve(null);
+ })
+ );
+
+ 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],
++ blindIndexes: 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,
++ blindIndexer,
+ 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 --cc backend/src/ee/services/secret-approval-request/secret-approval-request-service.ts
index 645c92fa66,e2cecef2f0..1aba0aba7a
--- 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
@@@ -51,12 -57,27 +51,13 @@@ import { TSecretVersionTagDALFactory }
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 { createSecretBlindIndexer } from "@app/services/secret-v2-bridge/secret-blind-index-fns";
-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 { SecretUpdateMode } from "@app/services/secret-v2-bridge/secret-v2-bridge-types";
import { TSecretVersionV2DALFactory } from "@app/services/secret-v2-bridge/secret-version-dal";
import { TSecretVersionV2TagDALFactory } from "@app/services/secret-v2-bridge/secret-version-tag-dal";
-import {
- describeSecretValidationFailures,
- SecretValidationError
-} from "@app/services/secret-validation-rule/secret-validation-rule-errors";
import { TSecretValidationRuleServiceFactory } from "@app/services/secret-validation-rule/secret-validation-rule-service";
-import { TValidateSecretsDTO } from "@app/services/secret-validation-rule/secret-validation-rule-types";
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";
@@@ -810,32 -879,330 +811,34 @@@ export const secretApprovalRequestServi
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, encryptor: secretManagerEncryptor } =
- await kmsService.createCipherPairWithDataKey({
- type: KmsDataKey.SecretManager,
- projectId
- });
+ const { conflicts, creates, updates, deletes } = await detectSecretApprovalCommitConflicts({
+ folderId,
+ commits: secretApprovalSecrets
+ });
+ const cipher = await kmsService.createCipherPairWithDataKey({
+ type: KmsDataKey.SecretManager,
+ projectId
+ });
+ const blindIndexer = await createSecretBlindIndexer({ projectId, orgId: actorOrgId, kmsService });
- 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,
++ blindIndexer,
+ 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
- ? blindIndexer.generateBlindIndexes(secretManagerDecryptor({ cipherTextBlob: el.encryptedValue }))
- : Promise.resolve(null)
- )
- );
-
- 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,
- blindIndexes: 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 }),
- blindIndexer,
- 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
- ? blindIndexer.generateBlindIndexes(
- secretManagerDecryptor({ cipherTextBlob: el.encryptedValue as Buffer })
- )
- : Promise.resolve(null);
- })
- );
-
- 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,
- blindIndexes: 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 }),
- blindIndexer,
- 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,
diff --cc backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.test.ts
index 33022f4446,0000000000..781b0c6575
mode 100644,000000..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
@@@ -1,1582 -1,0 +1,1587 @@@
+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,
+ ApprovalRequestApprovalDecision,
+ ApprovalRequestStatus,
+ ApproverType
+} from "@app/services/approval-policy/approval-policy-enums";
+import { ActorType } from "@app/services/auth/auth-type";
+import { INFISICAL_SECRET_VALUE_HIDDEN_MASK } from "@app/services/secret/secret-fns";
+import { SecretOperations } from "@app/services/secret/secret-types";
+import { ChangeRequestWebhookAction } from "@app/services/webhook/webhook-types";
+
+import { ApprovalStatus, RequestState } from "../secret-approval-request/secret-approval-request-types";
+import { secretChangeRequestBridgeServiceFactory } from "./secret-change-request-bridge-service";
+
+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);
++const BLIND_INDEXER = { generateBlindIndexes: vi.fn() };
+
+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("@app/services/secret-v2-bridge/secret-blind-index-fns", () => ({
++ createSecretBlindIndexer: async () => BLIND_INDEXER
++}));
+vi.mock("./secret-change-request-bridge-fns", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("./secret-change-request-bridge-fns")>()),
+ secretChangeRequestFnsFactory: () => ({
+ resolveRequester,
+ queueChangeRequestWebhook,
+ runSecretChangeRequestSideEffects
+ })
+}));
+
+const CALLER_TX = { isTx: "caller" } as unknown as Knex;
+const OWN_TX = { isTx: "own" } as unknown as Knex;
+const POLICY = {
+ id: "policy-1",
+ 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");
+const APPROVAL_REQUEST = {
+ id: "request-1",
+ projectId: "project-1",
+ organizationId: "org-1",
+ policyId: "policy-1",
+ requesterId: "user-1",
+ type: ApprovalPolicyType.SecretChange,
+ status: ApprovalRequestStatus.Open,
+ currentStep: 1,
+ createdAt: new Date("2026-01-01"),
+ updatedAt: new Date("2026-01-01")
+};
+const SECRET_CHANGE_REQUEST = {
+ id: "change-1",
+ approvalRequestId: "request-1",
+ folderId: "folder-1",
+ slug: "slug-1",
+ hasMerged: false,
+ bypassReason: null
+};
+const REQUEST_STEP = {
+ id: "step-1",
+ requestId: "request-1",
+ stepNumber: 1,
+ requiredApprovals: 1,
+ approvers: [
+ { type: ApproverType.User, id: "approver-1" },
+ { type: ApproverType.Group, id: "group-1" }
+ ],
+ approvals: [] as { id: string; stepId: string; approverUserId: string; decision: ApprovalRequestApprovalDecision }[]
+};
+const PROJECT = { id: "project-1", name: "Project", orgId: "org-1" };
+const REQUESTER = {
+ requesterUserId: "user-1",
+ machineIdentityId: null,
+ requesterName: "Alice Smith",
+ requesterEmail: "[email protected]"
+};
+const BUNDLE = {
+ folder: { id: "folder-1", envId: "env-1" },
+ folderId: "folder-1",
+ project: PROJECT,
+ permission: {},
+ commits: [
+ { op: SecretOperations.Create, version: 1, key: "NEW_KEY", encryptedValue: Buffer.from("v"), type: "shared" },
+ { op: SecretOperations.Delete, version: 3, key: "OLD_KEY", secretId: "secret-2", secretVersion: "version-2" }
+ ],
+ commitTagIds: { NEW_KEY: ["tag-1", "tag-2"] },
+ tagIds: ["tag-1", "tag-2"],
+ 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",
+ decryptor: ({ cipherTextBlob }: { cipherTextBlob: Buffer }) => Buffer.from(`plain:${cipherTextBlob.toString()}`)
+};
+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" }] }],
+ requestSteps = [REQUEST_STEP] as (typeof REQUEST_STEP)[]
+} = {}) => {
+ let requestCounter = 0;
+ const hasRole = vi.fn().mockReturnValue(false);
+ const deps = {
+ approvalRequestDAL: {
+ findById: vi.fn().mockResolvedValue(APPROVAL_REQUEST),
+ findByIdForUpdate: vi.fn().mockResolvedValue(APPROVAL_REQUEST),
+ findStepsByRequestId: vi.fn().mockResolvedValue(requestSteps),
+ findStepsByRequestIds: vi.fn().mockResolvedValue({ "request-1": 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({
+ id: `request-${requestCounter}`,
+ createdAt: new Date("2026-01-01"),
+ updatedAt: new Date("2026-01-01"),
+ ...row
+ });
+ }),
+ transaction: vi.fn((cb: (tx: Knex) => Promise<unknown>) => cb(OWN_TX))
+ },
+ approvalRequestStepsDAL: {
+ create: vi.fn((row: Record<string, unknown>) => Promise.resolve({ id: "step-1", ...row }))
+ },
+ approvalRequestStepEligibleApproversDAL: {
+ create: vi.fn((row: Record<string, unknown>) => Promise.resolve({ id: "eligible-1", ...row }))
+ },
+ approvalRequestApprovalsDAL: {
+ findOne: vi.fn().mockResolvedValue(null),
+ create: vi.fn((row: Record<string, unknown>) =>
+ Promise.resolve({ id: "approval-1", createdAt: REVIEW_CREATED_AT, ...row })
+ ),
+ updateById: vi.fn((id: string, row: Record<string, unknown>) =>
+ Promise.resolve({ id, stepId: "step-1", approverUserId: "approver-1", createdAt: REVIEW_CREATED_AT, ...row })
+ )
+ },
+ approvalPolicyDAL: {
+ findStepsByPolicyId: vi.fn().mockResolvedValue(steps),
+ findBypassersByPolicyIds: vi.fn().mockResolvedValue({})
+ },
+ secretChangeRequestDAL: {
+ 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),
+ findByProjectId: vi.fn().mockResolvedValue({ rows: [], totalCount: 0 }),
+ countByProjectId: vi.fn().mockResolvedValue({ open: 2, closed: 1 }),
+ 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, permission: { can: vi.fn().mockReturnValue(false) } })
+ },
+ membershipUserDAL: {
+ find: vi.fn().mockResolvedValue([{ actorUserId: "approver-1", isActive: true }])
+ },
+ userDAL: {
+ find: vi.fn().mockResolvedValue([
+ { id: "approver-1", email: "[email protected]", username: "approver", firstName: "App", lastName: "Rover" },
+ { id: "user-1", email: "[email protected]", username: "alice", firstName: "Alice", lastName: "Smith" }
+ ])
+ },
+ licenseService: { getPlan: vi.fn().mockResolvedValue({ secretApproval: true }) },
+ 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
+ .fn()
+ .mockResolvedValue([{ environmentSlug: "dev", environmentName: "Development", path: "/app" }])
+ },
+ secretApprovalRequestSecretDAL: {
+ 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([]),
+ findBySecretChangeIdBridgeSecretV2: vi.fn().mockResolvedValue(COMMIT_ROWS),
+ findCommitsBySecretChangeIds: vi.fn().mockResolvedValue([])
+ },
+ secretChangePolicyBridgeService: { findSecretChangePolicyById: vi.fn().mockResolvedValue(policy) }
+ };
+ const service = secretChangeRequestBridgeServiceFactory(
+ deps as unknown as Parameters<typeof secretChangeRequestBridgeServiceFactory>[0]
+ );
+ return { service, deps, hasRole };
+};
+
+const dto = (overrides: Record<string, unknown> = {}) => ({
+ actor: ActorType.USER,
+ actorId: "user-1",
+ actorOrgId: "org-1",
+ actorAuthMethod: null,
+ projectId: "project-1",
+ environment: "dev",
+ secretPath: "/",
+ commitMessage: "msg",
+ policy: { id: "policy-1" },
+ data: { [SecretOperations.Create]: [{ secretKey: "NEW_KEY", secretValue: "v" }] },
+ ...overrides
+});
+
+type TGenerateInput = Parameters<ReturnType<typeof buildService>["service"]["generateSecretChangeRequest"]>[0];
+const generate = (service: ReturnType<typeof buildService>["service"], overrides: Record<string, unknown> = {}) =>
+ service.generateSecretChangeRequest(dto(overrides) as unknown as TGenerateInput);
+
+describe("secretChangeRequestBridge generateSecretChangeRequest", () => {
+ beforeEach(() => {
+ buildSecretApprovalCommits.mockReset().mockResolvedValue(BUNDLE);
+ resolveRequester.mockReset().mockResolvedValue(REQUESTER);
+ runSecretChangeRequestSideEffects.mockClear();
+ });
+
+ test("writes the request envelope, steps, change row and commits in its own transaction", async () => {
+ const { service, deps } = buildService();
+
+ const result = await generate(service);
+
+ expect(buildSecretApprovalCommits).toHaveBeenCalledWith(expect.objectContaining({ policy: { id: "policy-1" } }));
+ expect(deps.approvalRequestDAL.transaction).toHaveBeenCalledTimes(1);
+ expect(deps.secretChangePolicyBridgeService.findSecretChangePolicyById).toHaveBeenCalledWith("policy-1", OWN_TX);
+ expect(deps.approvalPolicyDAL.findStepsByPolicyId).toHaveBeenCalledWith("policy-1", OWN_TX);
+ expect(resolveRequester).toHaveBeenCalledWith(ActorType.USER, "user-1", OWN_TX);
+
+ expect(deps.approvalRequestDAL.create).toHaveBeenCalledWith(
+ {
+ projectId: "project-1",
+ organizationId: "org-1",
+ policyId: "policy-1",
+ requesterId: "user-1",
+ machineIdentityId: null,
+ requesterName: "Alice Smith",
+ requesterEmail: "[email protected]",
+ type: ApprovalPolicyType.SecretChange,
+ status: ApprovalRequestStatus.Open,
+ justification: undefined,
+ currentStep: 1,
+ requestData: { version: 1, requestData: {} },
+ expiresAt: undefined,
+ scopeType: null,
+ scopeId: null
+ },
+ OWN_TX
+ );
+ expect(deps.approvalRequestStepsDAL.create).toHaveBeenCalledWith(
+ expect.objectContaining({ requestId: "request-1", stepNumber: 1, requiredApprovals: 1 }),
+ OWN_TX
+ );
+ expect(deps.approvalRequestStepEligibleApproversDAL.create).toHaveBeenCalledWith(
+ { stepId: "step-1", userId: "approver-1", groupId: null },
+ OWN_TX
+ );
+
+ expect(deps.secretChangeRequestDAL.create).toHaveBeenCalledWith(
+ {
+ approvalRequestId: "request-1",
+ folderId: "folder-1",
+ slug: expect.any(String) as string,
+ hasMerged: false,
+ commitMessage: "msg"
+ },
+ OWN_TX
+ );
+
+ const [commitRows, commitTx] = deps.secretApprovalRequestSecretDAL.insertV2Bridge.mock.calls[0];
+ expect(commitTx).toBe(OWN_TX);
+ expect(commitRows).toEqual([
+ expect.objectContaining({ op: SecretOperations.Create, key: "NEW_KEY", secretChangeId: "change-1" }),
+ expect.objectContaining({
+ op: SecretOperations.Delete,
+ key: "OLD_KEY",
+ secretId: "secret-2",
+ secretChangeId: "change-1"
+ })
+ ]);
+ commitRows.forEach((row: Record<string, unknown>) => {
+ expect(row).not.toHaveProperty("requestId");
+ expect(row).not.toHaveProperty("type");
+ });
+
+ expect(deps.secretApprovalRequestSecretDAL.insertApprovalSecretV2Tags).toHaveBeenCalledWith(
+ [
+ { secretId: "commit-0", tagId: "tag-1" },
+ { secretId: "commit-0", tagId: "tag-2" }
+ ],
+ OWN_TX
+ );
+
+ expect(result).toMatchObject({
+ id: "request-1",
+ policyId: "policy-1",
+ status: RequestState.Open,
+ slug: expect.any(String) as string,
+ folderId: "folder-1",
+ hasMerged: false,
+ committerUserId: "user-1",
+ committerIdentityId: null,
+ commitMessage: "msg",
+ commits: [expect.objectContaining({ id: "commit-0" }), expect.objectContaining({ id: "commit-1" })]
+ });
+
+ expect(runSecretChangeRequestSideEffects).toHaveBeenCalledWith(
+ expect.objectContaining({
+ approvalRequest: expect.objectContaining({ id: "request-1" }) as object,
+ secretChangeRequest: expect.objectContaining({ id: "change-1" }) as object,
+ policy: POLICY,
+ project: PROJECT,
+ environment: "dev",
+ secretPath: "/",
+ secretKeys: ["NEW_KEY", "OLD_KEY"],
+ tx: undefined
+ })
+ );
+ });
+
+ test("joins the caller's transaction and passes it to post-processing", async () => {
+ const { service, deps } = buildService();
+
+ await generate(service, { trx: CALLER_TX });
+
+ expect(deps.approvalRequestDAL.transaction).not.toHaveBeenCalled();
+ expect(deps.approvalRequestDAL.create).toHaveBeenCalledWith(expect.anything(), CALLER_TX);
+ expect(deps.secretChangeRequestDAL.create).toHaveBeenCalledWith(expect.anything(), CALLER_TX);
+ expect(deps.secretApprovalRequestSecretDAL.insertV2Bridge).toHaveBeenCalledWith(expect.anything(), CALLER_TX);
+ expect(deps.secretApprovalRequestSecretDAL.insertApprovalSecretV2Tags).toHaveBeenCalledWith(
+ expect.anything(),
+ CALLER_TX
+ );
+ expect(runSecretChangeRequestSideEffects).toHaveBeenCalledWith(expect.objectContaining({ tx: CALLER_TX }));
+ });
+
+ test("skips post-processing when asked and skips the tag insert when there are no tags", async () => {
+ buildSecretApprovalCommits.mockResolvedValue({ ...BUNDLE, commitTagIds: {}, tagIds: [] });
+ const { service, deps } = buildService();
+
+ await generate(service, { skipPostProcessing: true });
+
+ expect(deps.secretApprovalRequestSecretDAL.insertApprovalSecretV2Tags).not.toHaveBeenCalled();
+ expect(runSecretChangeRequestSideEffects).not.toHaveBeenCalled();
+ });
+
+ test("writes nothing when the policy no longer exists on the global approval system", async () => {
+ const { service, deps } = buildService({ policy: null });
+
+ await expect(generate(service)).rejects.toBeInstanceOf(NotFoundError);
+ expect(deps.approvalRequestDAL.create).not.toHaveBeenCalled();
+ expect(deps.secretChangeRequestDAL.create).not.toHaveBeenCalled();
+ expect(runSecretChangeRequestSideEffects).not.toHaveBeenCalled();
+ });
+
+ test("refuses a policy without an approval step", async () => {
+ const { service, deps } = buildService({ steps: [] });
+
+ const result = generate(service);
+ await expect(result).rejects.toBeInstanceOf(BadRequestError);
+ await expect(result).rejects.toThrow("has no approval step configured");
+ expect(deps.approvalRequestDAL.create).not.toHaveBeenCalled();
+ });
+
+ test("stores a machine identity requester on machineIdentityId", async () => {
+ resolveRequester.mockResolvedValue({
+ requesterUserId: null,
+ machineIdentityId: "identity-1",
+ requesterName: "ci-bot",
+ requesterEmail: ""
+ });
+ const { service, deps } = buildService();
+
+ const result = await generate(service, { actor: ActorType.IDENTITY, actorId: "identity-1" });
+
+ expect(deps.approvalRequestDAL.create).toHaveBeenCalledWith(
+ expect.objectContaining({ requesterId: null, machineIdentityId: "identity-1", requesterName: "ci-bot" }),
+ OWN_TX
+ );
+ expect(result).toMatchObject({ committerUserId: null, committerIdentityId: "identity-1" });
+ });
+});
+
+describe("secretChangeRequestBridge reviewSecretChangeRequest", () => {
+ beforeEach(() => {
+ queueChangeRequestWebhook.mockClear();
+ });
+
+ const review = (service: ReturnType<typeof buildService>["service"], overrides: Record<string, unknown> = {}) =>
+ service.reviewSecretChangeRequest({
+ approvalId: "request-1",
+ actor: ActorType.USER,
+ actorId: "approver-1",
+ actorOrgId: "org-1",
+ actorAuthMethod: null,
+ status: ApprovalStatus.APPROVED,
+ comment: "ship it",
+ ...overrides
+ } as Parameters<ReturnType<typeof buildService>["service"]["reviewSecretChangeRequest"]>[0]);
+
+ test("records an approver's decision on the current step under the request lock and queues the webhook", async () => {
+ const { service, deps } = buildService();
+
+ const result = await review(service);
+
+ expect(deps.licenseService.getPlan).toHaveBeenCalledWith("org-1");
+ expect(deps.permissionService.getProjectPermission).toHaveBeenCalledWith(
+ expect.objectContaining({ actor: ActorType.USER, actorId: "approver-1", projectId: "project-1" })
+ );
+ expect(deps.approvalRequestDAL.transaction).toHaveBeenCalledTimes(1);
+ expect(deps.approvalRequestDAL.findByIdForUpdate).toHaveBeenCalledWith("request-1", OWN_TX);
+ expect(deps.approvalRequestApprovalsDAL.findOne).toHaveBeenCalledWith(
+ { stepId: "step-1", approverUserId: "approver-1" },
+ OWN_TX
+ );
+ expect(deps.approvalRequestApprovalsDAL.create).toHaveBeenCalledWith(
+ {
+ stepId: "step-1",
+ approverUserId: "approver-1",
+ decision: ApprovalRequestApprovalDecision.Approved,
+ comment: "ship it"
+ },
+ OWN_TX
+ );
+
+ expect(queueChangeRequestWebhook).toHaveBeenCalledWith({
+ action: ChangeRequestWebhookAction.Reviewed,
+ approvalRequest: APPROVAL_REQUEST,
+ secretChangeRequest: SECRET_CHANGE_REQUEST,
+ policy: POLICY,
+ project: PROJECT,
+ environment: "dev",
+ environmentName: "Development",
+ secretPath: "/app"
+ });
+
+ expect(result).toEqual({
+ id: "approval-1",
+ status: ApprovalStatus.APPROVED,
+ requestId: "request-1",
+ reviewerUserId: "approver-1",
+ comment: "ship it",
+ createdAt: REVIEW_CREATED_AT,
+ updatedAt: REVIEW_CREATED_AT,
+ projectId: "project-1"
+ });
+ });
+
+ test("updates the reviewer's existing decision instead of adding a second row", async () => {
+ const { service, deps } = buildService();
+ deps.approvalRequestApprovalsDAL.findOne.mockResolvedValue({ id: "approval-9" });
+
+ const result = await review(service, { status: ApprovalStatus.REJECTED, comment: undefined });
+
+ expect(deps.approvalRequestApprovalsDAL.create).not.toHaveBeenCalled();
+ expect(deps.approvalRequestApprovalsDAL.updateById).toHaveBeenCalledWith(
+ "approval-9",
+ { decision: ApprovalRequestApprovalDecision.Rejected, comment: null },
+ OWN_TX
+ );
+ expect(result).toMatchObject({ id: "approval-9", status: ApprovalStatus.REJECTED, comment: null });
+ });
+
+ test("lets a project admin, the committer and a group member review", async () => {
+ const { service, deps, hasRole } = buildService();
+
+ hasRole.mockReturnValueOnce(true);
+ await expect(review(service, { actorId: "outsider" })).resolves.toMatchObject({ reviewerUserId: "outsider" });
+ expect(hasRole).toHaveBeenCalledWith(ProjectMembershipRole.Admin);
+
+ await expect(review(service, { actorId: "user-1" })).resolves.toMatchObject({ reviewerUserId: "user-1" });
+
+ deps.userGroupMembershipDAL.findGroupMembershipsByUserIdInOrg.mockResolvedValueOnce([{ groupId: "group-1" }]);
+ await expect(review(service, { actorId: "member-1" })).resolves.toMatchObject({ reviewerUserId: "member-1" });
+ expect(deps.userGroupMembershipDAL.findGroupMembershipsByUserIdInOrg).toHaveBeenCalledWith("member-1", "org-1");
+ });
+
+ test("forbids a user who is neither admin, committer nor an eligible approver", async () => {
+ const { service, deps } = buildService();
+
+ await expect(review(service, { actorId: "outsider" })).rejects.toBeInstanceOf(ForbiddenRequestError);
+ expect(deps.approvalRequestDAL.transaction).not.toHaveBeenCalled();
+ expect(queueChangeRequestWebhook).not.toHaveBeenCalled();
+ });
+
+ test("refuses when the plan lacks secret approvals", async () => {
+ const { service, deps } = buildService();
+ deps.licenseService.getPlan.mockResolvedValue({ secretApproval: false });
+
+ const result = review(service);
+ await expect(result).rejects.toBeInstanceOf(BadRequestError);
+ await expect(result).rejects.toThrow("plan restriction");
+ expect(deps.approvalRequestDAL.findById).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(review(service)).rejects.toBeInstanceOf(NotFoundError);
+
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce({ ...APPROVAL_REQUEST, type: ApprovalPolicyType.PamAccess });
+ await expect(review(service)).rejects.toBeInstanceOf(NotFoundError);
+
+ deps.secretChangeRequestDAL.findOne.mockResolvedValueOnce(null);
+ await expect(review(service)).rejects.toBeInstanceOf(NotFoundError);
+ });
+
+ test("refuses a non-user actor and a request that is not open", async () => {
+ const { service, deps } = buildService();
+
+ await expect(review(service, { actor: ActorType.IDENTITY })).rejects.toThrow("Must be a user");
+
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce({
+ ...APPROVAL_REQUEST,
+ status: ApprovalRequestStatus.Closed
+ });
+ await expect(review(service)).rejects.toThrow("You can only review open approval requests");
+
+ deps.approvalRequestDAL.findByIdForUpdate.mockResolvedValueOnce({
+ ...APPROVAL_REQUEST,
+ status: ApprovalRequestStatus.Closed
+ });
+ await expect(review(service)).rejects.toThrow("You can only review open approval requests");
+ expect(deps.approvalRequestApprovalsDAL.create).not.toHaveBeenCalled();
+ });
+
+ test("refuses a request whose policy is gone", async () => {
+ const { service, deps } = buildService();
+
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce({ ...APPROVAL_REQUEST, policyId: null });
+ await expect(review(service)).rejects.toThrow("has been deleted");
+ expect(deps.secretChangePolicyBridgeService.findSecretChangePolicyById).not.toHaveBeenCalled();
+
+ deps.secretChangePolicyBridgeService.findSecretChangePolicyById.mockResolvedValueOnce(undefined);
+ await expect(review(service)).rejects.toThrow("has been deleted");
+ });
+
+ test("refuses a self review when the policy disallows it", async () => {
+ const { service } = buildService({ policy: { ...POLICY, allowedSelfApprovals: false } });
+
+ await expect(review(service, { actorId: "user-1" })).rejects.toThrow("review their own request");
+ });
+
+ test("refuses a request without a current step", async () => {
+ const { service, deps } = buildService();
+ deps.approvalRequestDAL.findStepsByRequestId.mockResolvedValueOnce([]);
+
+ await expect(review(service)).rejects.toThrow("has no approval step to review");
+ });
+
+ test("keeps the review when the webhook cannot be queued or the folder is gone", async () => {
+ const { service, deps } = buildService();
+
+ queueChangeRequestWebhook.mockRejectedValueOnce(new Error("redis down"));
+ await expect(review(service)).resolves.toMatchObject({ reviewerUserId: "approver-1" });
+
+ deps.folderDAL.findSecretPathByFolderIds.mockResolvedValueOnce([]);
+ await expect(review(service)).resolves.toMatchObject({ reviewerUserId: "approver-1" });
+ 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,
++ blindIndexer: BLIND_INDEXER,
+ 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);
+ });
+});
+
+describe("secretChangeRequestBridge updateSecretChangeRequestStatus", () => {
+ beforeEach(() => {
+ queueChangeRequestWebhook.mockClear();
+ });
+
+ const setStatus = (service: ReturnType<typeof buildService>["service"], overrides: Record<string, unknown> = {}) =>
+ service.updateSecretChangeRequestStatus({
+ approvalId: "request-1",
+ actor: ActorType.USER,
+ actorId: "approver-1",
+ actorOrgId: "org-1",
+ actorAuthMethod: null,
+ status: RequestState.Closed,
+ ...overrides
+ } as Parameters<ReturnType<typeof buildService>["service"]["updateSecretChangeRequestStatus"]>[0]);
+
+ test("closes an open request on both tables under the request lock and queues the webhook", async () => {
+ const { service, deps } = buildService();
+
+ const result = await setStatus(service);
+
+ expect(deps.licenseService.getPlan).toHaveBeenCalledWith("org-1");
+ expect(deps.approvalRequestDAL.findByIdForUpdate).toHaveBeenCalledWith("request-1", OWN_TX);
+ expect(deps.secretChangeRequestDAL.findOne).toHaveBeenCalledWith({ approvalRequestId: "request-1" }, OWN_TX);
+ expect(deps.approvalRequestDAL.updateById).toHaveBeenCalledWith(
+ "request-1",
+ { status: ApprovalRequestStatus.Closed },
+ OWN_TX
+ );
+ expect(deps.secretChangeRequestDAL.updateById).toHaveBeenCalledWith(
+ "change-1",
+ { statusChangedByUserId: "approver-1" },
+ OWN_TX
+ );
+ expect(queueChangeRequestWebhook).toHaveBeenCalledWith(
+ expect.objectContaining({
+ action: ChangeRequestWebhookAction.Closed,
+ approvalRequest: expect.objectContaining({ status: ApprovalRequestStatus.Closed }) as unknown,
+ secretChangeRequest: expect.objectContaining({ statusChangedByUserId: "approver-1" }) as unknown,
+ environment: "dev",
+ environmentName: "Development",
+ secretPath: "/app"
+ })
+ );
+ expect(result).toMatchObject({
+ id: "request-1",
+ status: ApprovalRequestStatus.Closed,
+ statusChangedByUserId: "approver-1",
+ slug: "slug-1",
+ hasMerged: false,
+ projectId: "project-1"
+ });
+ expect(result).not.toHaveProperty("commits");
+ });
+
+ test("reopens a closed request", async () => {
+ const { service, deps } = buildService();
+ const closed = { ...APPROVAL_REQUEST, status: ApprovalRequestStatus.Closed };
+ deps.approvalRequestDAL.findById.mockResolvedValue(closed);
+ deps.approvalRequestDAL.findByIdForUpdate.mockResolvedValue(closed);
+
+ await expect(setStatus(service, { status: RequestState.Open })).resolves.toMatchObject({
+ status: ApprovalRequestStatus.Open
+ });
+ expect(queueChangeRequestWebhook).toHaveBeenCalledWith(
+ expect.objectContaining({ action: ChangeRequestWebhookAction.Reopened })
+ );
+ });
+
+ test("refuses when the plan lacks secret approvals", async () => {
+ const { service, deps } = buildService();
+ deps.licenseService.getPlan.mockResolvedValue({ secretApproval: false });
+
+ await expect(setStatus(service)).rejects.toThrow("plan restriction");
+ expect(deps.approvalRequestDAL.findById).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(setStatus(service)).rejects.toBeInstanceOf(NotFoundError);
+
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce({ ...APPROVAL_REQUEST, type: ApprovalPolicyType.PamAccess });
+ await expect(setStatus(service)).rejects.toBeInstanceOf(NotFoundError);
+ });
+
+ test("refuses a non-user actor and a request whose policy is gone", async () => {
+ const { service, deps } = buildService();
+
+ await expect(setStatus(service, { actor: ActorType.IDENTITY })).rejects.toThrow("Must be a user");
+
+ deps.secretChangePolicyBridgeService.findSecretChangePolicyById.mockResolvedValueOnce(null);
+ await expect(setStatus(service)).rejects.toThrow("has been deleted");
+ expect(deps.approvalRequestDAL.transaction).not.toHaveBeenCalled();
+ });
+
+ test("lets a project admin, the requester and a group member change the status but not a stranger", async () => {
+ const { service, deps, hasRole } = buildService();
+
+ hasRole.mockReturnValueOnce(true);
+ await expect(setStatus(service, { actorId: "outsider" })).resolves.toMatchObject({
+ statusChangedByUserId: "outsider"
+ });
+
+ await expect(setStatus(service, { actorId: "user-1" })).resolves.toMatchObject({ statusChangedByUserId: "user-1" });
+
+ deps.userGroupMembershipDAL.findGroupMembershipsByUserIdInOrg.mockResolvedValueOnce([{ groupId: "group-1" }]);
+ await expect(setStatus(service, { actorId: "member-1" })).resolves.toMatchObject({
+ statusChangedByUserId: "member-1"
+ });
+
+ await expect(setStatus(service, { actorId: "stranger" })).rejects.toBeInstanceOf(ForbiddenRequestError);
+ });
+
+ test("refuses a merged request and a request already in the requested status", async () => {
+ const { service, deps } = buildService();
+
+ deps.secretChangeRequestDAL.findOne.mockResolvedValueOnce({ ...SECRET_CHANGE_REQUEST, hasMerged: true });
+ await expect(setStatus(service)).rejects.toThrow("Approval request has been merged");
+
+ await expect(setStatus(service, { status: RequestState.Open })).rejects.toThrow("Approval request is already open");
+
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce({
+ ...APPROVAL_REQUEST,
+ status: ApprovalRequestStatus.Closed
+ });
+ await expect(setStatus(service)).rejects.toThrow("Approval request is already closed");
+ expect(deps.approvalRequestDAL.updateById).not.toHaveBeenCalled();
+ });
+
+ test("gives up when the request changed between the checks and the lock", async () => {
+ const { service, deps } = buildService();
+
+ deps.approvalRequestDAL.findByIdForUpdate.mockResolvedValueOnce({
+ ...APPROVAL_REQUEST,
+ status: ApprovalRequestStatus.Closed
+ });
+ await expect(setStatus(service)).rejects.toThrow("Approval request is already closed");
+
+ deps.secretChangeRequestDAL.findOne
+ .mockResolvedValueOnce(SECRET_CHANGE_REQUEST)
+ .mockResolvedValueOnce({ ...SECRET_CHANGE_REQUEST, hasMerged: true });
+ await expect(setStatus(service)).rejects.toThrow("Approval request has been merged");
+ expect(deps.approvalRequestDAL.updateById).not.toHaveBeenCalled();
+ expect(queueChangeRequestWebhook).not.toHaveBeenCalled();
+ });
+
+ test("keeps the status change when the webhook cannot be queued or the folder is gone", async () => {
+ const { service, deps } = buildService();
+
+ queueChangeRequestWebhook.mockRejectedValueOnce(new Error("redis down"));
+ await expect(setStatus(service)).resolves.toMatchObject({ status: ApprovalRequestStatus.Closed });
+
+ deps.folderDAL.findSecretPathByFolderIds.mockResolvedValueOnce([]);
+ await expect(setStatus(service)).resolves.toMatchObject({ status: ApprovalRequestStatus.Closed });
+ expect(queueChangeRequestWebhook).toHaveBeenCalledTimes(1);
+ });
+});
+
+describe("secretChangeRequestBridge getSecretChangeRequestById", () => {
+ const DETAIL_COMMIT = {
+ id: "commit-1",
+ op: SecretOperations.Update,
+ key: "NEW_KEY",
+ version: 2,
+ secretId: "secret-1",
+ encryptedValue: Buffer.from("new"),
+ encryptedComment: null,
+ skipMultilineEncoding: null,
+ secretMetadata: null,
+ tags: [{ id: "tag-1", name: "t", slug: "t", color: "red" }],
+ secret: {
+ id: "secret-1",
+ version: 1,
+ key: "NEW_KEY",
+ encryptedValue: Buffer.from("live"),
+ encryptedComment: null,
+ isRotatedSecret: false,
+ rotationId: null
+ },
+ secretVersion: undefined,
+ oldSecretMetadata: []
+ };
+ const reviewedStep = {
+ ...REQUEST_STEP,
+ approvals: [
+ {
+ id: "approval-1",
+ stepId: "step-1",
+ approverUserId: "approver-1",
+ decision: ApprovalRequestApprovalDecision.Approved,
+ comment: null,
+ createdAt: REVIEW_CREATED_AT
+ }
+ ]
+ };
+
+ const details = (service: ReturnType<typeof buildService>["service"], overrides: Record<string, unknown> = {}) =>
+ service.getSecretChangeRequestById({
+ id: "request-1",
+ actor: ActorType.USER,
+ actorId: "approver-1",
+ actorOrgId: "org-1",
+ actorAuthMethod: null,
+ ...overrides
+ } as Parameters<ReturnType<typeof buildService>["service"]["getSecretChangeRequestById"]>[0]);
+
+ const buildDetailsService = (overrides: Parameters<typeof buildService>[0] = {}) => {
+ const built = buildService({ requestSteps: [reviewedStep], ...overrides });
+ built.deps.secretApprovalRequestSecretDAL.findBySecretChangeIdBridgeSecretV2.mockResolvedValue([DETAIL_COMMIT]);
+ built.deps.secretChangeRequestDAL.findOne.mockResolvedValue({
+ ...SECRET_CHANGE_REQUEST,
+ statusChangedByUserId: "user-1"
+ });
+ return built;
+ };
+
+ test("returns the request with its policy, people and decrypted commits for an eligible approver", async () => {
+ const { service, deps } = buildDetailsService();
+
+ const result = await details(service);
+
+ expect(deps.licenseService.getPlan).not.toHaveBeenCalled();
+ expect(deps.userGroupMembershipDAL.find).toHaveBeenCalledWith({ $in: { groupId: ["group-1"] } });
+ expect(deps.membershipUserDAL.find).toHaveBeenCalledWith(
+ expect.objectContaining({
+ scopeOrgId: "org-1",
+ $in: { actorUserId: expect.arrayContaining(["approver-1", "user-1"]) as string[] }
+ })
+ );
+ expect(result).toMatchObject({
+ id: "request-1",
+ projectId: "project-1",
+ environment: "dev",
+ secretPath: "/app",
+ slug: "slug-1",
+ policy: {
+ id: "policy-1",
+ name: "dev-policy",
+ enforcementLevel: "hard",
+ allowedSelfApprovals: true,
+ deletedAt: null,
+ approvers: [{ userId: "approver-1", email: "[email protected]", isOrgMembershipActive: true }],
+ bypassers: []
+ },
+ statusChangedByUser: { userId: "user-1", username: "alice" },
+ committerUser: { userId: "user-1", email: "[email protected]", firstName: "Alice" },
+ committerIdentity: null,
+ reviewers: [
+ {
+ userId: "approver-1",
+ status: ApprovalRequestApprovalDecision.Approved,
+ comment: "",
+ createdAt: REVIEW_CREATED_AT,
+ isOrgMembershipActive: true
+ }
+ ],
+ commits: [
+ {
+ id: "commit-1",
+ secretKey: "NEW_KEY",
+ op: SecretOperations.Update,
+ secretValueHidden: false,
+ secretValue: "plain:new",
+ secret: { id: "secret-1", secretValue: "plain:live", secretValueHidden: false }
+ }
+ ]
+ });
+ expect(result.policy.approvers[0]).not.toHaveProperty("isOrgMembershipActive", null);
+ });
+
+ test("refuses a service token and reads an unknown id or a missing folder as not found", async () => {
+ const { service, deps } = buildDetailsService();
+
+ await expect(details(service, { actor: ActorType.SERVICE })).rejects.toThrow("Cannot use service token");
+
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce(null);
+ await expect(details(service)).rejects.toBeInstanceOf(NotFoundError);
+
+ deps.folderDAL.findSecretPathByFolderIds.mockResolvedValueOnce([]);
+ await expect(details(service)).rejects.toBeInstanceOf(NotFoundError);
+ });
+
+ test("lets the read permission, an admin, the requester, the requesting identity or a group member in", async () => {
+ const { service, deps, hasRole } = buildDetailsService();
+
+ await expect(details(service, { actorId: "stranger" })).rejects.toBeInstanceOf(ForbiddenRequestError);
+
+ deps.permissionService.getProjectPermission.mockResolvedValueOnce({
+ hasRole,
+ permission: { can: vi.fn().mockReturnValue(true) }
+ });
+ await expect(details(service, { actorId: "stranger" })).resolves.toMatchObject({ id: "request-1" });
+
+ hasRole.mockReturnValueOnce(true);
+ await expect(details(service, { actorId: "stranger" })).resolves.toMatchObject({ id: "request-1" });
+
+ await expect(details(service, { actorId: "user-1" })).resolves.toMatchObject({ id: "request-1" });
+
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce({
+ ...APPROVAL_REQUEST,
+ requesterId: null,
+ machineIdentityId: "identity-1",
+ requesterName: "Deploy bot"
+ });
+ await expect(details(service, { actor: ActorType.IDENTITY, actorId: "identity-1" })).resolves.toMatchObject({
+ committerUser: null,
+ committerIdentity: { identityId: "identity-1", name: "Deploy bot" }
+ });
+
+ deps.userGroupMembershipDAL.find.mockResolvedValueOnce([{ groupId: "group-1", userId: "member-1" }]);
+ await expect(details(service, { actorId: "member-1" })).resolves.toMatchObject({ id: "request-1" });
+ });
+
+ test("masks the values once the request is closed for an approver without read access", async () => {
+ const { service, deps } = buildDetailsService();
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce({
+ ...APPROVAL_REQUEST,
+ status: ApprovalRequestStatus.Closed
+ });
+
+ const result = await details(service);
+
+ expect(result.commits[0]).toMatchObject({
+ secretValueHidden: true,
+ secretValue: INFISICAL_SECRET_VALUE_HIDDEN_MASK
+ });
+ });
+
+ test("still answers when the policy was deleted and when the requesting user is gone", async () => {
+ const { service, deps } = buildDetailsService();
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce({
+ ...APPROVAL_REQUEST,
+ policyId: null,
+ requesterId: "ghost-1",
+ requesterEmail: "[email protected]",
+ requesterName: "Ghost"
+ });
+
+ const result = await details(service);
+
+ expect(deps.secretChangePolicyBridgeService.findSecretChangePolicyById).not.toHaveBeenCalled();
+ expect(result.policyId).toBe("");
+ expect(result.policy).toMatchObject({
+ id: "",
+ approvals: 1,
+ deletedAt: expect.any(Date) as Date,
+ approvers: [{ userId: "approver-1" }]
+ });
+ expect(result.committerUser).toEqual({
+ userId: "ghost-1",
+ email: "[email protected]",
+ username: "[email protected]",
+ firstName: "Ghost",
+ lastName: null
+ });
+ });
+});
+
+describe("secretChangeRequestBridge listSecretChangeRequests and countSecretChangeRequests", () => {
+ const LIST_ROW = {
+ ...APPROVAL_REQUEST,
+ requesterName: "Alice Smith",
+ requesterEmail: "[email protected]",
+ machineIdentityId: null,
+ secretChangeId: "change-1",
+ folderId: "folder-1",
+ slug: "slug-1",
+ hasMerged: false,
+ conflicts: null,
+ commitMessage: "msg",
+ bypassReason: null,
+ statusChangedByUserId: null,
+ environment: "dev",
+ environmentName: "Development",
+ requestFolderPath: "app",
+ policyName: "dev-policy",
+ policyEnforcementLevel: "soft",
+ policyConstraints: { constraints: { allowedSelfApprovals: false } },
+ policySecretPath: "/app",
+ policyApprovals: 2,
+ committerUserEmail: "[email protected]",
+ committerUserUsername: "alice",
+ committerUserFirstName: "Alice",
+ committerUserLastName: "Smith",
+ committerIdentityName: null
+ };
+ const filter = { projectId: "project-1", userId: "approver-1", limit: 20, offset: 0 };
+
+ test("hydrates the page in batches and maps it onto the list shape", async () => {
+ const { service, deps } = buildService({
+ requestSteps: [
+ {
+ ...REQUEST_STEP,
+ approvals: [
+ {
+ id: "approval-1",
+ stepId: "step-1",
+ approverUserId: "approver-1",
+ decision: ApprovalRequestApprovalDecision.Approved
+ }
+ ]
+ }
+ ]
+ });
+ deps.secretChangeRequestDAL.findByProjectId.mockResolvedValue({ rows: [LIST_ROW], totalCount: 5 });
+ deps.secretApprovalRequestSecretDAL.findCommitsBySecretChangeIds.mockResolvedValue([
+ { id: "commit-1", op: "create", secretId: null, secretChangeId: "change-1" }
+ ]);
+ deps.approvalPolicyDAL.findBypassersByPolicyIds.mockResolvedValue({
+ "policy-1": [{ type: ApproverType.Group, id: "group-2" }]
+ });
+ deps.userGroupMembershipDAL.find.mockResolvedValue([
+ { groupId: "group-1", userId: "member-1" },
+ { groupId: "group-1", userId: "approver-1" },
+ { groupId: "group-2", userId: "bypasser-1" }
+ ]);
+
+ const result = await service.listSecretChangeRequests(filter);
+
+ expect(deps.secretChangeRequestDAL.findByProjectId).toHaveBeenCalledWith(filter);
+ expect(deps.approvalRequestDAL.findStepsByRequestIds).toHaveBeenCalledWith(["request-1"]);
+ expect(deps.secretApprovalRequestSecretDAL.findCommitsBySecretChangeIds).toHaveBeenCalledWith(["change-1"]);
+ expect(deps.approvalPolicyDAL.findBypassersByPolicyIds).toHaveBeenCalledWith(["policy-1"]);
+ expect(deps.userGroupMembershipDAL.find).toHaveBeenCalledWith({
+ $in: { groupId: expect.arrayContaining(["group-1", "group-2"]) as string[] }
+ });
+ expect(result.totalCount).toBe(5);
+ expect(result.approvals).toHaveLength(1);
+ expect(result.approvals[0]).toMatchObject({
+ id: "request-1",
+ projectId: "project-1",
+ environment: "dev",
+ environmentName: "Development",
+ status: ApprovalRequestStatus.Open,
+ slug: "slug-1",
+ commitMessage: "msg",
+ committerUserId: "user-1",
+ policy: {
+ id: "policy-1",
+ name: "dev-policy",
+ approvals: 2,
+ secretPath: "/app",
+ enforcementLevel: "soft",
+ allowedSelfApprovals: false,
+ deletedAt: null,
+ approvers: [{ userId: "approver-1" }, { userId: "member-1" }],
+ bypassers: [{ userId: "bypasser-1" }]
+ },
+ committerUser: { userId: "user-1", email: "[email protected]", username: "alice", firstName: "Alice" },
+ committerIdentity: null,
+ reviewers: [{ userId: "approver-1", status: ApprovalRequestApprovalDecision.Approved }],
+ commits: [{ op: "create", secretId: null }],
+ approvers: [{ userId: "approver-1" }, { userId: "member-1" }],
+ bypassers: [{ userId: "bypasser-1" }]
+ });
+ });
+
+ test("marks a request whose policy is gone and skips the follow-up reads on an empty page", async () => {
+ const { service, deps } = buildService();
+ deps.secretChangeRequestDAL.findByProjectId.mockResolvedValueOnce({
+ rows: [{ ...LIST_ROW, policyId: null, policyName: null, policySecretPath: null, policyApprovals: null }],
+ totalCount: 1
+ });
+
+ const result = await service.listSecretChangeRequests(filter);
+ expect(deps.approvalPolicyDAL.findBypassersByPolicyIds).toHaveBeenCalledWith([]);
+ expect(result.approvals[0].policyId).toBe("");
+ expect(result.approvals[0].policy).toMatchObject({ id: "", approvals: 1, deletedAt: expect.any(Date) as Date });
+
+ deps.approvalRequestDAL.findStepsByRequestIds.mockClear();
+ await expect(service.listSecretChangeRequests(filter)).resolves.toEqual({ approvals: [], totalCount: 0 });
+ expect(deps.approvalRequestDAL.findStepsByRequestIds).not.toHaveBeenCalled();
+ });
+
+ test("counts through the DAL", async () => {
+ const { service, deps } = buildService();
+
+ await expect(
+ service.countSecretChangeRequests({ projectId: "project-1", userId: "approver-1", policyId: "policy-1" })
+ ).resolves.toEqual({ open: 2, closed: 1 });
+ expect(deps.secretChangeRequestDAL.countByProjectId).toHaveBeenCalledWith("project-1", "approver-1", "policy-1");
+ });
+});
+
+describe("secretChangeRequestBridge createSecretChangeRequest", () => {
+ const CREATE_DTO = {
+ policy: { id: "policy-1" },
+ folderId: "folder-1",
+ actor: ActorType.USER,
+ actorId: "user-1",
+ isReplicated: true,
+ commitMessage: "moved",
+ commits: [
+ { op: SecretOperations.Create, key: "NEW_KEY", encryptedValue: Buffer.from("v"), tagIds: ["tag-1"] },
+ { op: SecretOperations.Delete, key: "OLD_KEY", secretId: "secret-2", secretVersion: "version-2" }
+ ]
+ };
+
+ beforeEach(() => {
+ resolveRequester.mockReset().mockResolvedValue(REQUESTER);
+ runSecretChangeRequestSideEffects.mockClear();
+ });
+
+ const create = (service: ReturnType<typeof buildService>["service"], tx?: Knex) =>
+ service.createSecretChangeRequest(
+ CREATE_DTO as unknown as Parameters<ReturnType<typeof buildService>["service"]["createSecretChangeRequest"]>[0],
+ tx
+ );
+
+ test("writes the request envelope, change row, commits and tags in the caller's transaction", async () => {
+ const { service, deps } = buildService();
+ deps.secretChangePolicyBridgeService.findSecretChangePolicyById.mockResolvedValue({
+ ...POLICY,
+ projectId: "project-1"
+ });
+
+ const result = await create(service, CALLER_TX);
+
+ expect(deps.approvalRequestDAL.transaction).not.toHaveBeenCalled();
+ expect(deps.secretChangePolicyBridgeService.findSecretChangePolicyById).toHaveBeenCalledWith("policy-1", CALLER_TX);
+ expect(deps.projectDAL.findById).toHaveBeenCalledWith("project-1", CALLER_TX);
+ expect(resolveRequester).toHaveBeenCalledWith(ActorType.USER, "user-1", CALLER_TX);
+ expect(deps.approvalRequestDAL.create).toHaveBeenCalledWith(
+ expect.objectContaining({
+ projectId: "project-1",
+ organizationId: "org-1",
+ policyId: "policy-1",
+ type: ApprovalPolicyType.SecretChange,
+ status: ApprovalRequestStatus.Open,
+ requesterId: "user-1"
+ }),
+ CALLER_TX
+ );
+ expect(deps.secretChangeRequestDAL.create).toHaveBeenCalledWith(
+ expect.objectContaining({
+ approvalRequestId: "request-1",
+ folderId: "folder-1",
+ hasMerged: false,
+ commitMessage: "moved",
+ isReplicated: true
+ }),
+ CALLER_TX
+ );
+ expect(deps.secretApprovalRequestSecretDAL.insertV2Bridge).toHaveBeenCalledWith(
+ [
+ expect.objectContaining({ key: "NEW_KEY", op: SecretOperations.Create, secretChangeId: "change-1" }),
+ expect.objectContaining({ key: "OLD_KEY", op: SecretOperations.Delete, secretChangeId: "change-1" })
+ ],
+ CALLER_TX
+ );
+ const [insertedCommits] = deps.secretApprovalRequestSecretDAL.insertV2Bridge.mock.calls[0];
+ expect(insertedCommits[0]).not.toHaveProperty("tagIds");
+ expect(deps.secretApprovalRequestSecretDAL.insertApprovalSecretV2Tags).toHaveBeenCalledWith(
+ [{ secretId: "commit-0", tagId: "tag-1" }],
+ CALLER_TX
+ );
+ expect(runSecretChangeRequestSideEffects).not.toHaveBeenCalled();
+ expect(result).toMatchObject({
+ id: "request-1",
+ policyId: "policy-1",
+ status: ApprovalRequestStatus.Open,
+ folderId: "folder-1",
+ isReplicated: true,
+ committerUserId: "user-1",
+ commits: [expect.objectContaining({ key: "NEW_KEY" }), expect.objectContaining({ key: "OLD_KEY" })]
+ });
+ });
+
+ test("opens its own transaction when the caller has none and skips the tag insert without tags", async () => {
+ const { service, deps } = buildService();
+ deps.secretChangePolicyBridgeService.findSecretChangePolicyById.mockResolvedValue({
+ ...POLICY,
+ projectId: "project-1"
+ });
+
+ await service.createSecretChangeRequest({
+ ...CREATE_DTO,
+ commits: [{ op: SecretOperations.Delete, key: "OLD_KEY", secretId: "secret-2" }]
+ } as unknown as Parameters<ReturnType<typeof buildService>["service"]["createSecretChangeRequest"]>[0]);
+
+ expect(deps.approvalRequestDAL.transaction).toHaveBeenCalledTimes(1);
+ expect(deps.secretChangeRequestDAL.create).toHaveBeenCalledWith(expect.anything(), OWN_TX);
+ expect(deps.secretApprovalRequestSecretDAL.insertApprovalSecretV2Tags).not.toHaveBeenCalled();
+ });
+
+ test("keeps the tags of every commit that shares a key, as the legacy system does", async () => {
+ const { service, deps } = buildService();
+ deps.secretChangePolicyBridgeService.findSecretChangePolicyById.mockResolvedValue({
+ ...POLICY,
+ projectId: "project-1"
+ });
+
+ await service.createSecretChangeRequest(
+ {
+ ...CREATE_DTO,
+ commits: [
+ { op: SecretOperations.Delete, key: "KEY", secretId: "secret-1", tagIds: ["tag-1"] },
+ { op: SecretOperations.Create, key: "KEY", encryptedValue: Buffer.from("v"), tagIds: ["tag-2"] }
+ ]
+ } as unknown as Parameters<ReturnType<typeof buildService>["service"]["createSecretChangeRequest"]>[0],
+ CALLER_TX
+ );
+
+ expect(deps.secretApprovalRequestSecretDAL.insertApprovalSecretV2Tags).toHaveBeenCalledWith(
+ [
+ { secretId: "commit-0", tagId: "tag-1" },
+ { secretId: "commit-0", tagId: "tag-2" }
+ ],
+ CALLER_TX
+ );
+ });
+
+ test("writes nothing when the policy is gone or has no approval step", async () => {
+ const { service, deps } = buildService({ steps: [] });
+ deps.secretChangePolicyBridgeService.findSecretChangePolicyById.mockResolvedValueOnce(null);
+ await expect(create(service, CALLER_TX)).rejects.toBeInstanceOf(NotFoundError);
+
+ deps.secretChangePolicyBridgeService.findSecretChangePolicyById.mockResolvedValueOnce({
+ ...POLICY,
+ projectId: "project-1"
+ });
+ await expect(create(service, CALLER_TX)).rejects.toThrow("has no approval step configured");
+ expect(deps.approvalRequestDAL.create).not.toHaveBeenCalled();
+ });
+});
+
+describe("secretChangeRequestBridge createSecretChangeRequestSideEffects", () => {
+ const SIDE_EFFECTS_DTO = {
+ secretApprovalRequest: { id: "request-1", policyId: "policy-1", commits: [{ id: "commit-1" }] },
+ projectId: "project-1",
+ environment: "dev",
+ secretPath: "/app",
+ secretKeys: ["NEW_KEY"],
+ actor: ActorType.USER,
+ actorId: "user-1",
+ actorOrgId: "org-1"
+ };
+
+ beforeEach(() => {
+ runSecretChangeRequestSideEffects.mockClear();
+ });
+
+ test("runs the bridge side effects for the stored request through the caller's transaction", async () => {
+ const { service, deps } = buildService();
+
+ await service.createSecretChangeRequestSideEffects({ ...SIDE_EFFECTS_DTO, tx: CALLER_TX });
+
+ expect(deps.approvalRequestDAL.findById).toHaveBeenCalledWith("request-1", CALLER_TX);
+ expect(deps.secretChangeRequestDAL.findOne).toHaveBeenCalledWith({ approvalRequestId: "request-1" }, CALLER_TX);
+ expect(deps.secretChangePolicyBridgeService.findSecretChangePolicyById).toHaveBeenCalledWith("policy-1", CALLER_TX);
+ expect(deps.projectDAL.findById).toHaveBeenCalledWith("project-1", CALLER_TX);
+ expect(runSecretChangeRequestSideEffects).toHaveBeenCalledWith({
+ approvalRequest: APPROVAL_REQUEST,
+ secretChangeRequest: SECRET_CHANGE_REQUEST,
+ policy: POLICY,
+ project: PROJECT,
+ commits: [{ id: "commit-1" }],
+ environment: "dev",
+ secretPath: "/app",
+ secretKeys: ["NEW_KEY"],
+ actor: ActorType.USER,
+ actorId: "user-1",
+ actorOrgId: "org-1",
+ tx: CALLER_TX
+ });
+ });
+
+ test("reads an unknown request as not found and refuses one whose policy is gone", async () => {
+ const { service, deps } = buildService();
+
+ deps.approvalRequestDAL.findById.mockResolvedValueOnce(null);
+ await expect(service.createSecretChangeRequestSideEffects(SIDE_EFFECTS_DTO)).rejects.toBeInstanceOf(NotFoundError);
+
+ deps.secretChangePolicyBridgeService.findSecretChangePolicyById.mockResolvedValueOnce(null);
+ await expect(service.createSecretChangeRequestSideEffects(SIDE_EFFECTS_DTO)).rejects.toThrow("has been deleted");
+ expect(runSecretChangeRequestSideEffects).not.toHaveBeenCalled();
+ });
+});
diff --cc backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.ts
index 00b6a36e9d,0000000000..cd764d701f
mode 100644,000000..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
@@@ -1,1104 -1,0 +1,1107 @@@
+import { Knex } from "knex";
+
+import { AccessScope, ActionProjectType, ProjectMembershipRole, TApprovalRequests } from "@app/db/schemas";
+import { BadRequestError, ForbiddenRequestError, NotFoundError } from "@app/lib/errors";
+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 {
+ ApprovalPolicyType,
+ ApprovalRequestApprovalDecision,
+ ApprovalRequestStatus
+} from "@app/services/approval-policy/approval-policy-enums";
+import {
+ TApprovalRequestApprovalsDALFactory,
+ TApprovalRequestDALFactory,
+ TApprovalRequestStepEligibleApproversDALFactory,
+ TApprovalRequestStepsDALFactory
+} from "@app/services/approval-policy/approval-request-dal";
+import {
+ createApprovalRequestWithSteps,
+ isEligibleStepApprover,
+ resolveStepApproverUserIds,
+ upsertApprovalRequestStepDecision
+} from "@app/services/approval-policy/approval-request-fns";
+import { ActorAuthMethod, 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 { TMembershipUserDALFactory } from "@app/services/membership-user/membership-user-dal";
+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 { createSecretBlindIndexer } from "@app/services/secret-v2-bridge/secret-blind-index-fns";
+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";
+import { TTelemetryServiceFactory } from "@app/services/telemetry/telemetry-service";
+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";
+import { ProjectPermissionSecretApprovalRequestActions, ProjectPermissionSub } from "../permission/project-permission";
+import {
+ pickApprovalCommitColumns,
+ secretApprovalRequestCommitFnsFactory
+} from "../secret-approval-request/secret-approval-request-commit-fns";
+import {
+ buildSecretApprovalCommitValueAccess,
+ formatSecretApprovalCommitsV2Bridge
+} from "../secret-approval-request/secret-approval-request-details-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, RequestState } from "../secret-approval-request/secret-approval-request-types";
+import { TSecretChangePolicyBridgeServiceFactory } from "../secret-change-policy-bridge/secret-change-policy-bridge-service";
+import {
+ groupUserIdsByGroupId,
+ isGroupActor,
+ resolveActorUserIds,
+ secretChangeRequestFnsFactory,
+ toApprovalRequestUser,
+ toDeletedSecretChangePolicyStub,
+ toSecretChangeRequest,
+ toSecretChangeRequestBase,
+ toSecretChangeRequestCommit,
+ toSecretChangeRequestListItem,
+ toSecretChangeRequestReview
+} from "./secret-change-request-bridge-fns";
+import {
+ TApprovalRequestUser,
+ TSecretChangeRequestBridgeMethods,
+ TSecretChangeRequestCommitInsert,
+ TSecretChangeRequestPolicySummary
+} from "./secret-change-request-bridge-types";
+import { TSecretChangeRequestDALFactory } from "./secret-change-request-dal";
+
+type TSecretChangeRequestBridgeServiceFactoryDep = {
+ approvalRequestDAL: Pick<
+ TApprovalRequestDALFactory,
+ | "find"
+ | "findById"
+ | "findByIdForUpdate"
+ | "findStepsByRequestId"
+ | "findStepsByRequestIds"
+ | "create"
+ | "updateById"
+ | "transaction"
+ >;
+ approvalRequestStepsDAL: Pick<TApprovalRequestStepsDALFactory, "create">;
+ approvalRequestStepEligibleApproversDAL: Pick<TApprovalRequestStepEligibleApproversDALFactory, "create">;
+ approvalRequestApprovalsDAL: Pick<TApprovalRequestApprovalsDALFactory, "findOne" | "create" | "updateById">;
+ approvalPolicyDAL: Pick<TApprovalPolicyDALFactory, "findStepsByPolicyId" | "findBypassersByPolicyIds">;
+ secretChangeRequestDAL: Pick<
+ TSecretChangeRequestDALFactory,
+ "create" | "find" | "findOne" | "updateById" | "findByProjectId" | "countByProjectId"
+ >;
+ secretApprovalRequestSecretDAL: Pick<
+ TSecretApprovalRequestSecretDALFactory,
+ | "insertV2Bridge"
+ | "insertApprovalSecretV2Tags"
+ | "updateV2ById"
+ | "findBySecretChangeIdBridgeSecretV2"
+ | "findCommitsBySecretChangeIds"
+ >;
+ membershipUserDAL: Pick<TMembershipUserDALFactory, "find">;
+ secretChangePolicyBridgeService: Pick<TSecretChangePolicyBridgeServiceFactory, "findSecretChangePolicyById">;
+ permissionService: Pick<TPermissionServiceFactory, "getProjectPermission">;
+ licenseService: Pick<TLicenseServiceFactory, "getPlan">;
+ 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,
+ | "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" | "findOne">;
+ identityDAL: Pick<TIdentityDALFactory, "findById">;
+ projectSlackConfigDAL: Pick<TProjectSlackConfigDALFactory, "getIntegrationDetailsByProject">;
+ projectMicrosoftTeamsConfigDAL: Pick<TProjectMicrosoftTeamsConfigDALFactory, "getIntegrationDetailsByProject">;
+ microsoftTeamsService: Pick<TMicrosoftTeamsServiceFactory, "sendNotification">;
+ smtpService: Pick<TSmtpService, "sendMail">;
+ notificationService: Pick<TNotificationServiceFactory, "createUserNotifications">;
+ queueService: Pick<TQueueServiceFactory, "queue">;
+ telemetryService: Pick<TTelemetryServiceFactory, "sendPostHogEvents">;
+};
+
+export type TSecretChangeRequestBridgeServiceFactory = ReturnType<typeof secretChangeRequestBridgeServiceFactory>;
+
+export const secretChangeRequestBridgeServiceFactory = ({
+ approvalRequestDAL,
+ approvalRequestStepsDAL,
+ approvalRequestStepEligibleApproversDAL,
+ approvalRequestApprovalsDAL,
+ approvalPolicyDAL,
+ secretChangeRequestDAL,
+ secretApprovalRequestSecretDAL,
+ membershipUserDAL,
+ secretChangePolicyBridgeService,
+ permissionService,
+ licenseService,
+ userGroupMembershipDAL,
+ folderDAL,
+ projectDAL,
+ projectEnvDAL,
+ kmsService,
+ secretV2BridgeDAL,
+ secretVersionV2BridgeDAL,
+ secretVersionTagV2BridgeDAL,
+ secretTagDAL,
+ resourceMetadataDAL,
+ folderCommitService,
+ secretQueueService,
+ secretValidationRuleService,
+ userDAL,
+ identityDAL,
+ projectSlackConfigDAL,
+ projectMicrosoftTeamsConfigDAL,
+ microsoftTeamsService,
+ smtpService,
+ notificationService,
+ queueService,
+ telemetryService
+}: TSecretChangeRequestBridgeServiceFactoryDep) => {
+ const { buildSecretApprovalCommits, validateSecrets } = secretApprovalRequestCommitFnsFactory({
+ permissionService,
+ folderDAL,
+ projectDAL,
+ kmsService,
+ secretV2BridgeDAL,
+ secretVersionV2BridgeDAL,
+ secretTagDAL,
+ 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,
+ identityDAL,
+ projectDAL,
+ projectEnvDAL,
+ kmsService,
+ projectSlackConfigDAL,
+ projectMicrosoftTeamsConfigDAL,
+ microsoftTeamsService,
+ smtpService,
+ notificationService,
+ queueService,
+ telemetryService
+ });
+
+ const findSecretChangeRequest = (requestId: string, tx?: Knex) => approvalRequestDAL.findById(requestId, tx);
+
+ const findFolderIdsWithOpenSecretChangeRequests = async (folderIds: string[], tx?: Knex) => {
+ if (!folderIds.length) return [];
+
+ const secretChangeRequests = await secretChangeRequestDAL.find({ $in: { folderId: folderIds } }, { tx });
+ if (!secretChangeRequests.length) return [];
+
+ const openRequests = await approvalRequestDAL.find(
+ { $in: { id: secretChangeRequests.map((request) => request.approvalRequestId) }, status: RequestState.Open },
+ { tx }
+ );
+ const openRequestIds = new Set(openRequests.map((request) => request.id));
+
+ return secretChangeRequests
+ .filter((request) => openRequestIds.has(request.approvalRequestId))
+ .map((request) => request.folderId);
+ };
+
+ const $findSecretChangeRequestOrThrow = async (requestId: string, tx?: Knex) => {
+ const approvalRequest = await approvalRequestDAL.findById(requestId, tx);
+ if (!approvalRequest || approvalRequest.type !== ApprovalPolicyType.SecretChange) {
+ throw new NotFoundError({ message: `Secret approval request with ID '${requestId}' not found` });
+ }
+ const secretChangeRequest = await secretChangeRequestDAL.findOne({ approvalRequestId: approvalRequest.id }, tx);
+ if (!secretChangeRequest) {
+ throw new NotFoundError({ message: `Secret approval request with ID '${requestId}' not found` });
+ }
+ return { approvalRequest, secretChangeRequest };
+ };
+
+ const $findSecretChangePolicyOrThrow = async (policyId: string | null | undefined, tx?: Knex) => {
+ const policy = policyId
+ ? await secretChangePolicyBridgeService.findSecretChangePolicyById(policyId, tx)
+ : undefined;
+ if (!policy) {
+ throw new BadRequestError({
+ message: "The policy associated with this secret approval request has been deleted."
+ });
+ }
+ return policy;
+ };
+
+ const $assertCanActOnRequest = async ({
+ approvalRequest,
+ actorId,
+ actorAuthMethod,
+ actorOrgId,
+ action
+ }: {
+ approvalRequest: TApprovalRequests;
+ actorId: string;
+ actorAuthMethod: ActorAuthMethod;
+ actorOrgId: string;
+ action: "review" | "merge" | "update";
+ }) => {
+ const { hasRole, permission } = await permissionService.getProjectPermission({
+ actor: ActorType.USER,
+ actorId,
+ projectId: approvalRequest.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 '${approvalRequest.id}' has no approval step to ${action}.`
+ });
+ }
+
+ 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" });
+ }
+
+ return { hasRole, permission, steps, currentStep, userGroupIds };
+ };
+
+ const $writeSecretChangeRequest = async (
+ {
+ policyId,
+ folderId,
+ projectId,
+ orgId,
+ actor,
+ actorId,
+ commitMessage,
+ isReplicated,
+ commits,
+ commitTags
+ }: {
+ policyId: string;
+ folderId: string;
+ projectId: string;
+ orgId: string;
+ actor: ActorType;
+ actorId: string;
+ commitMessage?: string | null;
+ isReplicated?: boolean | null;
+ commits: TSecretChangeRequestCommitInsert[];
+ commitTags: Record<string, string[]>;
+ },
+ tx: Knex
+ ) => {
+ const policy = await secretChangePolicyBridgeService.findSecretChangePolicyById(policyId, tx);
+ if (!policy) {
+ throw new NotFoundError({ message: `Secret approval policy with ID '${policyId}' not found` });
+ }
+
+ const policySteps = await approvalPolicyDAL.findStepsByPolicyId(policy.id, tx);
+ if (!policySteps.length) {
+ throw new BadRequestError({
+ message: `Secret approval policy '${policy.name}' has no approval step configured. Edit the policy and set its approvers before requesting changes.`
+ });
+ }
+
+ const requester = await resolveRequester(actor, actorId, tx);
+
+ const approvalRequest = await createApprovalRequestWithSteps(
+ {
+ projectId,
+ organizationId: orgId,
+ policyId: policy.id,
+ policyType: ApprovalPolicyType.SecretChange,
+ policySteps,
+ requestData: {},
+ status: ApprovalRequestStatus.Open,
+ ...requester,
+ scopeType: null,
+ scopeId: null
+ },
+ { approvalRequestDAL, approvalRequestStepsDAL, approvalRequestStepEligibleApproversDAL },
+ tx
+ );
+
+ const secretChangeRequest = await secretChangeRequestDAL.create(
+ {
+ approvalRequestId: approvalRequest.id,
+ folderId,
+ slug: alphaNumericNanoId(),
+ hasMerged: false,
+ commitMessage,
+ isReplicated
+ },
+ tx
+ );
+
+ const approvalCommits = await secretApprovalRequestSecretDAL.insertV2Bridge(
+ commits.map((commit) => ({ ...commit, secretChangeId: secretChangeRequest.id })),
+ tx
+ );
+
+ const commitsGroupByKey = groupBy(approvalCommits, (commit) => commit.key);
+ const approvalSecretTags = Object.entries(commitTags).flatMap(([key, keyTagIds]) =>
+ keyTagIds.map((tagId) => ({ secretId: commitsGroupByKey[key][0].id, tagId }))
+ );
+ if (approvalSecretTags.length) {
+ await secretApprovalRequestSecretDAL.insertApprovalSecretV2Tags(approvalSecretTags, tx);
+ }
+
+ return { policy, approvalRequest, secretChangeRequest, commits: approvalCommits };
+ };
+
+ const generateSecretChangeRequest: TSecretChangeRequestBridgeMethods["generateSecretChangeRequest"] = async (dto) => {
+ const { actor, actorId, actorOrgId, projectId, environment, secretPath, commitMessage, trx, skipPostProcessing } =
+ dto;
+ const { folderId, project, commits, commitTagIds, secretKeys } = await buildSecretApprovalCommits(dto);
+
+ const write = (tx: Knex) =>
+ $writeSecretChangeRequest(
+ {
+ policyId: dto.policy.id,
+ folderId,
+ projectId,
+ orgId: project.orgId,
+ actor,
+ actorId,
+ commitMessage,
+ commits: commits.map((commit) => pickApprovalCommitColumns(commit)),
+ commitTags: commitTagIds
+ },
+ tx
+ );
+
+ const created = trx ? await write(trx) : await approvalRequestDAL.transaction(write);
+ const result = toSecretChangeRequest(created);
+
+ if (!skipPostProcessing) {
+ await runSecretChangeRequestSideEffects({
+ ...created,
+ project,
+ environment,
+ secretPath,
+ secretKeys,
+ actor,
+ actorId,
+ actorOrgId,
+ tx: trx
+ });
+ }
+
+ return result;
+ };
+
+ const createSecretChangeRequest: TSecretChangeRequestBridgeMethods["createSecretChangeRequest"] = async (
+ dto,
+ trx
+ ) => {
+ const commitTags = dto.commits.reduce<Record<string, string[]>>((acc, { key, tagIds }) => {
+ if (tagIds?.length) acc[key] = [...(acc[key] ?? []), ...tagIds];
+ return acc;
+ }, {});
+
+ const write = async (tx: Knex) => {
+ const policy = await secretChangePolicyBridgeService.findSecretChangePolicyById(dto.policy.id, tx);
+ if (!policy) {
+ throw new NotFoundError({ message: `Secret approval policy with ID '${dto.policy.id}' not found` });
+ }
+ const project = await projectDAL.findById(policy.projectId, tx);
+ if (!project) throw new NotFoundError({ message: `Project with ID '${policy.projectId}' not found` });
+
+ return $writeSecretChangeRequest(
+ {
+ policyId: policy.id,
+ folderId: dto.folderId,
+ projectId: project.id,
+ orgId: project.orgId,
+ actor: dto.actor,
+ actorId: dto.actorId,
+ commitMessage: dto.commitMessage,
+ isReplicated: dto.isReplicated,
+ commits: dto.commits.map(({ tagIds, ...commit }) => commit),
+ commitTags
+ },
+ tx
+ );
+ };
+
+ const created = trx ? await write(trx) : await approvalRequestDAL.transaction(write);
+ return toSecretChangeRequest(created);
+ };
+
+ const createSecretChangeRequestSideEffects: TSecretChangeRequestBridgeMethods["createSecretChangeRequestSideEffects"] =
+ async ({
+ secretApprovalRequest,
+ projectId,
+ environment,
+ secretPath,
+ secretKeys,
+ actor,
+ actorId,
+ actorOrgId,
+ tx
+ }) => {
+ const { approvalRequest, secretChangeRequest } = await $findSecretChangeRequestOrThrow(
+ secretApprovalRequest.id,
+ tx
+ );
+ const policy = await $findSecretChangePolicyOrThrow(approvalRequest.policyId, tx);
+ const project = await projectDAL.findById(projectId, tx);
+ if (!project) throw new NotFoundError({ message: `Project with ID '${projectId}' not found` });
+
+ await runSecretChangeRequestSideEffects({
+ approvalRequest,
+ secretChangeRequest,
+ policy,
+ project,
+ commits: secretApprovalRequest.commits,
+ environment,
+ secretPath,
+ secretKeys,
+ actor,
+ actorId,
+ actorOrgId,
+ tx
+ });
+ };
+
+ 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 { permission, steps, userGroupIds } = await $assertCanActOnRequest({
+ approvalRequest,
+ actorId,
+ actorAuthMethod,
+ actorOrgId,
+ action: "merge"
+ });
+
+ 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 blindIndexer = await createSecretBlindIndexer({ projectId, orgId: actorOrgId, kmsService });
+
+ 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,
++ blindIndexer,
+ 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,
+ actorId,
+ actorAuthMethod,
+ actorOrgId,
+ status,
+ comment
+ }) => {
+ const plan = await licenseService.getPlan(actorOrgId);
+ if (!plan.secretApproval) {
+ throw new BadRequestError({
+ message:
+ "Failed to review secret approval request due to plan restriction. Upgrade plan to review secret approval request."
+ });
+ }
+
+ const { approvalRequest, secretChangeRequest } = await $findSecretChangeRequestOrThrow(approvalId);
+ if (actor !== ActorType.USER) throw new BadRequestError({ message: "Must be a user" });
+
+ if (approvalRequest.status !== ApprovalRequestStatus.Open) {
+ throw new BadRequestError({ message: "You can only review open approval requests" });
+ }
+
+ const policy = await $findSecretChangePolicyOrThrow(approvalRequest.policyId);
+ if (!policy.allowedSelfApprovals && actorId === approvalRequest.requesterId) {
+ throw new BadRequestError({
+ message: "Failed to review secret approval request. Users are not authorized to review their own request."
+ });
+ }
+
+ const { currentStep } = await $assertCanActOnRequest({
+ approvalRequest,
+ actorId,
+ actorAuthMethod,
+ actorOrgId,
+ action: "review"
+ });
+
+ const decision =
+ status === ApprovalStatus.APPROVED
+ ? ApprovalRequestApprovalDecision.Approved
+ : ApprovalRequestApprovalDecision.Rejected;
+
+ const review = 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 review open approval requests" });
+ }
+ return upsertApprovalRequestStepDecision(
+ { stepId: currentStep.id, approverUserId: actorId, decision, comment },
+ { approvalRequestApprovalsDAL },
+ tx
+ );
+ });
+
+ try {
+ const project = await projectDAL.findById(approvalRequest.projectId);
+ const [folder] = await folderDAL.findSecretPathByFolderIds(approvalRequest.projectId, [
+ secretChangeRequest.folderId
+ ]);
+ if (project && folder) {
+ await queueChangeRequestWebhook({
+ action: ChangeRequestWebhookAction.Reviewed,
+ approvalRequest,
+ secretChangeRequest,
+ policy,
+ project,
+ environment: folder.environmentSlug,
+ environmentName: folder.environmentName,
+ secretPath: folder.path
+ });
+ } else {
+ logger.warn(
+ `Skipping change request webhook, project or folder not found [requestId=${approvalRequest.id}] [action=${ChangeRequestWebhookAction.Reviewed}]`
+ );
+ }
+ } catch (error) {
+ logger.error(
+ error,
+ `Failed to queue change request webhook [requestId=${approvalRequest.id}] [action=${ChangeRequestWebhookAction.Reviewed}]`
+ );
+ }
+
+ return { ...toSecretChangeRequestReview(review, approvalRequest.id), projectId: approvalRequest.projectId };
+ };
+
+ const updateSecretChangeRequestStatus: TSecretChangeRequestBridgeMethods["updateSecretChangeRequestStatus"] = async ({
+ approvalId,
+ actor,
+ actorId,
+ actorAuthMethod,
+ actorOrgId,
+ status
+ }) => {
+ const plan = await licenseService.getPlan(actorOrgId);
+ if (!plan.secretApproval) {
+ throw new BadRequestError({
+ message:
+ "Failed to update secret approval request due to plan restriction. Upgrade plan to update secret approval request."
+ });
+ }
+
+ const { approvalRequest, secretChangeRequest } = await $findSecretChangeRequestOrThrow(approvalId);
+ if (actor !== ActorType.USER) throw new BadRequestError({ message: "Must be a user" });
+
+ const policy = await $findSecretChangePolicyOrThrow(approvalRequest.policyId);
+ await $assertCanActOnRequest({ approvalRequest, actorId, actorAuthMethod, actorOrgId, action: "update" });
+
+ const alreadyInStatusMessage =
+ status === RequestState.Open ? "Approval request is already open" : "Approval request is already closed";
+ if (secretChangeRequest.hasMerged) throw new BadRequestError({ message: "Approval request has been merged" });
+ if (approvalRequest.status === status) throw new BadRequestError({ message: alreadyInStatusMessage });
+
+ const updated = await approvalRequestDAL.transaction(async (tx) => {
+ const locked = await approvalRequestDAL.findByIdForUpdate(approvalRequest.id, tx);
+ if (!locked || locked.status !== approvalRequest.status) {
+ throw new BadRequestError({ message: alreadyInStatusMessage });
+ }
+ const lockedChangeRequest = await secretChangeRequestDAL.findOne({ approvalRequestId: approvalRequest.id }, tx);
+ if (!lockedChangeRequest || lockedChangeRequest.hasMerged) {
+ throw new BadRequestError({ message: "Approval request has been merged" });
+ }
+
+ const updatedApprovalRequest = await approvalRequestDAL.updateById(approvalRequest.id, { status }, tx);
+ const updatedChangeRequest = await secretChangeRequestDAL.updateById(
+ lockedChangeRequest.id,
+ { statusChangedByUserId: actorId },
+ tx
+ );
+ return { approvalRequest: updatedApprovalRequest, secretChangeRequest: updatedChangeRequest };
+ });
+
+ const action =
+ status === RequestState.Open ? ChangeRequestWebhookAction.Reopened : ChangeRequestWebhookAction.Closed;
+ try {
+ const project = await projectDAL.findById(approvalRequest.projectId);
+ const [folder] = await folderDAL.findSecretPathByFolderIds(approvalRequest.projectId, [
+ secretChangeRequest.folderId
+ ]);
+ if (project && folder) {
+ await queueChangeRequestWebhook({
+ action,
+ approvalRequest: updated.approvalRequest,
+ secretChangeRequest: updated.secretChangeRequest,
+ policy,
+ project,
+ environment: folder.environmentSlug,
+ environmentName: folder.environmentName,
+ secretPath: folder.path
+ });
+ } else {
+ logger.warn(
+ `Skipping change request webhook, project or folder not found [requestId=${approvalRequest.id}] [action=${action}]`
+ );
+ }
+ } catch (error) {
+ logger.error(
+ error,
+ `Failed to queue change request webhook [requestId=${approvalRequest.id}] [action=${action}]`
+ );
+ }
+
+ return { ...toSecretChangeRequestBase(updated), projectId: approvalRequest.projectId };
+ };
+
+ const getSecretChangeRequestById: TSecretChangeRequestBridgeMethods["getSecretChangeRequestById"] = async ({
+ id,
+ actor,
+ actorId,
+ actorAuthMethod,
+ actorOrgId
+ }) => {
+ if (actor === ActorType.SERVICE) throw new BadRequestError({ message: "Cannot use service token" });
+
+ const { approvalRequest, secretChangeRequest } = await $findSecretChangeRequestOrThrow(id);
+ const { projectId } = approvalRequest;
+ const [folder] = await folderDAL.findSecretPathByFolderIds(projectId, [secretChangeRequest.folderId]);
+ if (!folder) throw new NotFoundError({ message: `Secret approval request with ID '${id}' not found` });
+
+ const { hasRole, permission } = await permissionService.getProjectPermission({
+ actor,
+ actorId,
+ projectId,
+ actorAuthMethod,
+ actorOrgId,
+ actionProjectType: ActionProjectType.SecretManager
+ });
+
+ const steps = await approvalRequestDAL.findStepsByRequestId(approvalRequest.id);
+ const policy = approvalRequest.policyId
+ ? await secretChangePolicyBridgeService.findSecretChangePolicyById(approvalRequest.policyId)
+ : undefined;
+ const bypassers = policy?.bypassers ?? [];
+ const groupIds = unique(
+ [...steps.flatMap((step) => step.approvers), ...bypassers].filter(isGroupActor).map((actorRef) => actorRef.id)
+ );
+ const groupMembers = groupIds.length ? await userGroupMembershipDAL.find({ $in: { groupId: groupIds } }) : [];
+ const userIdsByGroupId = groupUserIdsByGroupId(groupMembers);
+ // The approvers are the ones recorded on the request's steps when it was opened, which is what reviews and
+ // merges are gated on and what remains once the policy has been deleted.
+ const approverUserIds = resolveActorUserIds(
+ steps.flatMap((step) => step.approvers),
+ userIdsByGroupId
+ );
+ const bypasserUserIds = resolveActorUserIds(bypassers, userIdsByGroupId);
+ const isReviewer = approverUserIds.includes(actorId);
+
+ const canReadApprovalRequests = permission.can(
+ ProjectPermissionSecretApprovalRequestActions.Read,
+ ProjectPermissionSub.SecretApprovalRequest
+ );
+ if (
+ !canReadApprovalRequests &&
+ !hasRole(ProjectMembershipRole.Admin) &&
+ approvalRequest.requesterId !== actorId &&
+ approvalRequest.machineIdentityId !== actorId &&
+ !isReviewer
+ ) {
+ throw new ForbiddenRequestError({ message: "User has insufficient privileges" });
+ }
+
+ const project = await projectDAL.findById(projectId);
+ if (!project) throw new NotFoundError({ message: `Project with ID '${projectId}' not found` });
+
+ const reviews = steps.flatMap((step) => step.approvals);
+ const userIds = unique(
+ [
+ ...approverUserIds,
+ ...bypasserUserIds,
+ ...reviews.map((review) => review.approverUserId),
+ secretChangeRequest.statusChangedByUserId,
+ approvalRequest.requesterId
+ ].filter((userId): userId is string => Boolean(userId))
+ );
+ const [users, memberships] = userIds.length
+ ? await Promise.all([
+ userDAL.find({ $in: { id: userIds } }),
+ membershipUserDAL.find({
+ scope: AccessScope.Organization,
+ scopeOrgId: project.orgId,
+ $in: { actorUserId: userIds }
+ })
+ ])
+ : [[], []];
+ const usersById = new Map(users.map((user) => [user.id, user]));
+ const membershipActiveByUserId = new Map(
+ memberships.flatMap((membership) =>
+ membership.actorUserId ? [[membership.actorUserId, membership.isActive] as const] : []
+ )
+ );
+ const findUser = (userId: string): TApprovalRequestUser | undefined => {
+ const user = usersById.get(userId);
+ return user ? toApprovalRequestUser(user) : undefined;
+ };
+ const withOrgMembership = (user: TApprovalRequestUser) => ({
+ ...user,
+ isOrgMembershipActive: membershipActiveByUserId.get(user.userId) ?? null
+ });
+
+ const policySummary: TSecretChangeRequestPolicySummary = policy
+ ? {
+ id: policy.id,
+ name: policy.name,
+ approvals: policy.approvals,
+ secretPath: policy.secretPath ?? null,
+ enforcementLevel: policy.enforcementLevel,
+ allowedSelfApprovals: policy.allowedSelfApprovals,
+ deletedAt: null
+ }
+ : toDeletedSecretChangePolicyStub(approvalRequest, steps);
+
+ const commits = await secretApprovalRequestSecretDAL.findBySecretChangeIdBridgeSecretV2(secretChangeRequest.id);
+ const { decryptor } = await kmsService.createCipherPairWithDataKey({ type: KmsDataKey.SecretManager, projectId });
+
+ return {
+ ...toSecretChangeRequestBase({ approvalRequest, secretChangeRequest }),
+ projectId,
+ environment: folder.environmentSlug,
+ secretPath: folder.path,
+ policy: {
+ ...policySummary,
+ approvers: approverUserIds.flatMap((userId) => {
+ const user = findUser(userId);
+ return user ? [withOrgMembership(user)] : [];
+ }),
+ bypassers: bypasserUserIds.flatMap((userId) => {
+ const user = findUser(userId);
+ return user ? [user] : [];
+ })
+ },
+ statusChangedByUser: secretChangeRequest.statusChangedByUserId
+ ? findUser(secretChangeRequest.statusChangedByUserId)
+ : undefined,
+ committerUser: approvalRequest.requesterId
+ ? (findUser(approvalRequest.requesterId) ?? {
+ userId: approvalRequest.requesterId,
+ email: approvalRequest.requesterEmail,
+ username: approvalRequest.requesterEmail,
+ firstName: approvalRequest.requesterName,
+ lastName: null
+ })
+ : null,
+ committerIdentity: approvalRequest.machineIdentityId
+ ? { identityId: approvalRequest.machineIdentityId, name: approvalRequest.requesterName }
+ : null,
+ reviewers: reviews.flatMap((review) => {
+ const user = findUser(review.approverUserId);
+ return user
+ ? [
+ {
+ ...withOrgMembership(user),
+ status: review.decision,
+ comment: review.comment ?? "",
+ createdAt: review.createdAt ?? new Date()
+ }
+ ]
+ : [];
+ }),
+ commits: formatSecretApprovalCommitsV2Bridge({
+ commits,
+ decryptor,
+ canReadSecretValue: buildSecretApprovalCommitValueAccess({
+ permission,
+ isReviewer,
+ isRequestOpen: approvalRequest.status === ApprovalRequestStatus.Open,
+ environment: folder.environmentSlug,
+ secretPath: folder.path
+ })
+ })
+ };
+ };
+
+ // The list and count take the access filter the legacy service already derived from the caller's permission,
+ // so they do no permission check of their own.
+ const listSecretChangeRequests: TSecretChangeRequestBridgeMethods["listSecretChangeRequests"] = async (filter) => {
+ const { rows, totalCount } = await secretChangeRequestDAL.findByProjectId(filter);
+ if (!rows.length) return { approvals: [], totalCount };
+
+ const [stepsByRequestId, commits, bypassersByPolicyId] = await Promise.all([
+ approvalRequestDAL.findStepsByRequestIds(rows.map((row) => row.id)),
+ secretApprovalRequestSecretDAL.findCommitsBySecretChangeIds(rows.map((row) => row.secretChangeId)),
+ approvalPolicyDAL.findBypassersByPolicyIds(
+ unique(rows.map((row) => row.policyId).filter((policyId): policyId is string => Boolean(policyId)))
+ )
+ ]);
+ const steps = Object.values(stepsByRequestId).flat();
+ const groupIds = unique(
+ [...steps.flatMap((step) => step.approvers), ...Object.values(bypassersByPolicyId).flat()]
+ .filter(isGroupActor)
+ .map((actorRef) => actorRef.id)
+ );
+ const groupMembers = groupIds.length ? await userGroupMembershipDAL.find({ $in: { groupId: groupIds } }) : [];
+ const userIdsByGroupId = groupUserIdsByGroupId(groupMembers);
+ const commitsBySecretChangeId = groupBy(commits, (commit) => commit.secretChangeId);
+
+ return {
+ approvals: rows.map((row) =>
+ toSecretChangeRequestListItem({
+ row,
+ steps: stepsByRequestId[row.id] ?? [],
+ commits: commitsBySecretChangeId[row.secretChangeId] ?? [],
+ bypassers: row.policyId ? (bypassersByPolicyId[row.policyId] ?? []) : [],
+ userIdsByGroupId
+ })
+ ),
+ totalCount
+ };
+ };
+
+ const countSecretChangeRequests: TSecretChangeRequestBridgeMethods["countSecretChangeRequests"] = ({
+ projectId,
+ userId,
+ policyId
+ }) => secretChangeRequestDAL.countByProjectId(projectId, userId, policyId);
+
+ return {
+ findSecretChangeRequest,
+ findFolderIdsWithOpenSecretChangeRequests,
+ generateSecretChangeRequest,
+ createSecretChangeRequest,
+ createSecretChangeRequestSideEffects,
+ mergeSecretChangeRequest,
+ reviewSecretChangeRequest,
+ updateSecretChangeRequestStatus,
+ getSecretChangeRequestById,
+ listSecretChangeRequests,
+ countSecretChangeRequests
+ };
+};
diff --cc backend/src/services/secret-folder/secret-folder-service.ts
index f9d48a10e6,c5faab2894..bf27db738b
--- a/backend/src/services/secret-folder/secret-folder-service.ts
+++ b/backend/src/services/secret-folder/secret-folder-service.ts
@@@ -2016,10 -2002,12 +2019,11 @@@ export const secretFolderServiceFactor
resourceMetadataDAL,
folderCommitService,
secretApprovalPolicyService,
- secretApprovalRequestDAL,
- secretApprovalRequestSecretDAL,
+ secretApprovalRequestCreationFns,
secretQueueService,
reminderDAL,
- reminderService
+ reminderService,
+ secretValidationRuleService
})
);
}
diff --cc backend/src/services/secret-v2-bridge/secret-v2-bridge-fns.ts
index f033802996,3840787aab..2021cd6aa4
--- a/backend/src/services/secret-v2-bridge/secret-v2-bridge-fns.ts
+++ b/backend/src/services/secret-v2-bridge/secret-v2-bridge-fns.ts
@@@ -1603,10 -1629,12 +1628,11 @@@ export const fnSecretMove = async (dto
resourceMetadataDAL,
folderCommitService,
secretApprovalPolicyService,
- secretApprovalRequestDAL,
- secretApprovalRequestSecretDAL,
+ secretApprovalRequestCreationFns,
secretQueueService,
reminderDAL,
- reminderService
+ reminderService,
+ secretValidationRuleService
} = dto;
const sourceFolder = await folderDAL.findBySecretPath(projectId, sourceEnvironment, sourceSecretPath, tx);
diff --cc backend/src/services/secret-v2-bridge/secret-v2-bridge-service.ts
index 9726730ddb,57d4a0727a..1cf63678f7
--- a/backend/src/services/secret-v2-bridge/secret-v2-bridge-service.ts
+++ b/backend/src/services/secret-v2-bridge/secret-v2-bridge-service.ts
@@@ -3259,10 -3267,12 +3264,11 @@@ export const secretV2BridgeServiceFacto
resourceMetadataDAL,
folderCommitService,
secretApprovalPolicyService,
- secretApprovalRequestDAL,
- secretApprovalRequestSecretDAL,
+ secretApprovalRequestCreationFns,
secretQueueService,
reminderDAL,
- reminderService
+ reminderService,
+ secretValidationRuleService
})
);