Skip to content

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

feat: move list and update secret change approval request into bridge

adilsonb7fd70a7faa9
diff --git a/backend/e2e-test/routes/v1/secret-approval-request-bridge.spec.ts b/backend/e2e-test/routes/v1/secret-approval-request-bridge.spec.ts
index 4a35328949..e3a0817284 100644
--- a/backend/e2e-test/routes/v1/secret-approval-request-bridge.spec.ts
+++ b/backend/e2e-test/routes/v1/secret-approval-request-bridge.spec.ts
@@ -9,7 +9,6 @@ import { ApprovalPolicyType, ApprovalRequestStatus } from "@app/services/approva
const getDb = () => (globalThis as unknown as { testDb: Knex }).testDb;
-const BRIDGE_MESSAGE = "Secret change requests on the approval system are not available yet.";
const projectId = seedData1.projectV3.id;
const envSlug = seedData1.environment.slug;
const GLOBAL_SYSTEM_FOLDER = "sar-bridge-global";
@@ -42,6 +41,22 @@ const deleteSecret = (key: string, secretPath = "/") =>
const getRequest = (id: string) =>
testServer.inject({ method: "GET", url: `/api/v1/secret-approval-requests/${id}`, headers: authHeaders() });
+const listRequests = (query = "") =>
+ testServer.inject({
+ method: "GET",
+ url: `/api/v1/secret-approval-requests?projectId=${projectId}&limit=50${query}`,
+ headers: authHeaders()
+ });
+
+const countRequests = () =>
+ testServer.inject({
+ method: "GET",
+ url: `/api/v1/secret-approval-requests/count?projectId=${projectId}`,
+ headers: authHeaders()
+ });
+
+type TListedRequest = { id: string; status: string };
+
const reviewRequest = (id: string, status: ApprovalStatus) =>
testServer.inject({
method: "POST",
@@ -108,7 +123,7 @@ describe("Secret approval request bridge routing", () => {
let globalSystemPolicyId: string;
let globalSystemFolderId: string;
const globalSystemRequestIds: string[] = [];
- const secretKeys = ["SAR_BRIDGE_MERGE", "SAR_BRIDGE_STATUS"];
+ const secretKeys = ["SAR_BRIDGE_MERGE", "SAR_BRIDGE_STATUS", "SAR_BRIDGE_LIST_LEGACY", "SAR_BRIDGE_STATUS_LEGACY"];
beforeAll(async () => {
const db = getDb();
@@ -233,10 +248,19 @@ describe("Secret approval request bridge routing", () => {
{ approverUserId: seedData1.id, decision: ApprovalStatus.APPROVED }
]);
- for await (const res of [getRequest(approval.id), setRequestStatus(approval.id, RequestState.Closed)]) {
- expect(res.statusCode).toBe(400);
- expect(res.json().message).toBe(BRIDGE_MESSAGE);
- }
+ const detailsRes = await getRequest(approval.id);
+ expect(detailsRes.statusCode).toBe(200);
+ expect(detailsRes.json().approval).toMatchObject({
+ id: approval.id,
+ status: RequestState.Open,
+ environment: envSlug,
+ secretPath: GLOBAL_SYSTEM_PATH,
+ folderId: globalSystemFolderId,
+ committerUser: { userId: seedData1.id, email: seedData1.email },
+ policy: { id: globalSystemPolicyId, deletedAt: null, approvers: [{ userId: seedData1.id }] },
+ reviewers: [{ userId: seedData1.id, status: ApprovalStatus.APPROVED }],
+ commits: [{ secretKey: "SAR_BRIDGE_GLOBAL", op: "create", secretValueHidden: false, secretValue: "value" }]
+ });
const mergeRes = await mergeRequest(approval.id);
expect(mergeRes.statusCode).toBe(200);
@@ -249,4 +273,105 @@ describe("Secret approval request bridge routing", () => {
statusChangedByUserId: seedData1.id
});
});
+
+ test("the list and the count return requests from both systems for one project", async () => {
+ const legacyRes = await createSecret("SAR_BRIDGE_LIST_LEGACY", "value");
+ expect(legacyRes.statusCode).toBe(200);
+ const legacyRequest: TListedRequest = legacyRes.json().approval;
+ const globalRes = await createSecret("SAR_BRIDGE_LIST_GLOBAL", "value", GLOBAL_SYSTEM_PATH);
+ expect(globalRes.statusCode).toBe(200);
+ const globalRequest: TListedRequest = globalRes.json().approval;
+ globalSystemRequestIds.push(globalRequest.id);
+
+ const listRes = await listRequests();
+ expect(listRes.statusCode).toBe(200);
+ const listed: { approvals: TListedRequest[]; totalCount: number } = listRes.json();
+ expect(listed.totalCount).toBeGreaterThanOrEqual(2);
+ expect(listed.approvals.find((row) => row.id === legacyRequest.id)).toMatchObject({
+ policy: { id: legacyPolicyId },
+ environment: envSlug,
+ status: RequestState.Open,
+ committerUser: { userId: seedData1.id },
+ approvers: [{ userId: seedData1.id }],
+ commits: [{ op: "create" }]
+ });
+ expect(listed.approvals.find((row) => row.id === globalRequest.id)).toMatchObject({
+ policy: { id: globalSystemPolicyId, secretPath: GLOBAL_SYSTEM_PATH, deletedAt: null },
+ environment: envSlug,
+ status: RequestState.Open,
+ committerUser: { userId: seedData1.id },
+ approvers: [{ userId: seedData1.id }],
+ reviewers: [],
+ commits: [{ op: "create" }]
+ });
+
+ const openRes = await listRequests(`&status=${RequestState.Open}`);
+ expect(openRes.statusCode).toBe(200);
+ const open: { approvals: TListedRequest[] } = openRes.json();
+ expect(open.approvals.map((row) => row.id)).toEqual(
+ expect.arrayContaining([legacyRequest.id, globalRequest.id]) as string[]
+ );
+ expect(open.approvals.every((row) => row.status === RequestState.Open)).toBe(true);
+
+ const countRes = await countRequests();
+ expect(countRes.statusCode).toBe(200);
+ expect(countRes.json().approvals.open).toBeGreaterThanOrEqual(2);
+ });
+
+ test("a status change keeps a request on the system it was opened on", async () => {
+ const db = getDb();
+
+ const legacyRes = await createSecret("SAR_BRIDGE_STATUS_LEGACY", "value");
+ expect(legacyRes.statusCode).toBe(200);
+ const legacyRequest: TListedRequest = legacyRes.json().approval;
+ const closeLegacyRes = await setRequestStatus(legacyRequest.id, RequestState.Closed);
+ expect(closeLegacyRes.statusCode).toBe(200);
+ expect(closeLegacyRes.json().approval.status).toBe(RequestState.Closed);
+ expect(await db(TableName.SecretApprovalRequest).where({ id: legacyRequest.id }).first()).toMatchObject({
+ status: RequestState.Closed,
+ statusChangedByUserId: seedData1.id
+ });
+ expect(await db(TableName.ApprovalRequests).where({ id: legacyRequest.id }).first()).toBeUndefined();
+ expect(
+ await db(TableName.SecretChangeRequests).where({ approvalRequestId: legacyRequest.id }).first()
+ ).toBeUndefined();
+ const reopenLegacyRes = await setRequestStatus(legacyRequest.id, RequestState.Open);
+ expect(reopenLegacyRes.statusCode).toBe(200);
+ expect(await db(TableName.SecretApprovalRequest).where({ id: legacyRequest.id }).first()).toMatchObject({
+ status: RequestState.Open
+ });
+ expect(await db(TableName.ApprovalRequests).where({ id: legacyRequest.id }).first()).toBeUndefined();
+
+ const globalRes = await createSecret("SAR_BRIDGE_STATUS_GLOBAL", "value", GLOBAL_SYSTEM_PATH);
+ expect(globalRes.statusCode).toBe(200);
+ const globalRequest: TListedRequest = globalRes.json().approval;
+ globalSystemRequestIds.push(globalRequest.id);
+ const closeGlobalRes = await setRequestStatus(globalRequest.id, RequestState.Closed);
+ expect(closeGlobalRes.statusCode).toBe(200);
+ expect(closeGlobalRes.json().approval).toMatchObject({
+ id: globalRequest.id,
+ status: RequestState.Closed,
+ statusChangedByUserId: seedData1.id,
+ hasMerged: false
+ });
+ expect(await db(TableName.ApprovalRequests).where({ id: globalRequest.id }).first()).toMatchObject({
+ status: ApprovalRequestStatus.Closed
+ });
+ expect(
+ await db(TableName.SecretChangeRequests).where({ approvalRequestId: globalRequest.id }).first()
+ ).toMatchObject({ statusChangedByUserId: seedData1.id, hasMerged: false });
+ expect(await db(TableName.SecretApprovalRequest).where({ id: globalRequest.id }).first()).toBeUndefined();
+
+ const closeAgainRes = await setRequestStatus(globalRequest.id, RequestState.Closed);
+ expect(closeAgainRes.statusCode).toBe(400);
+ expect(closeAgainRes.json().message).toBe("Approval request is already closed");
+
+ const reopenGlobalRes = await setRequestStatus(globalRequest.id, RequestState.Open);
+ expect(reopenGlobalRes.statusCode).toBe(200);
+ expect(reopenGlobalRes.json().approval.status).toBe(RequestState.Open);
+ expect(await db(TableName.ApprovalRequests).where({ id: globalRequest.id }).first()).toMatchObject({
+ status: ApprovalRequestStatus.Open
+ });
+ expect(await db(TableName.SecretApprovalRequest).where({ id: globalRequest.id }).first()).toBeUndefined();
+ });
});
diff --git a/backend/e2e-test/routes/v1/secret-approval-request-lifecycle.spec.ts b/backend/e2e-test/routes/v1/secret-approval-request-lifecycle.spec.ts
index 35f246344c..f2ed3f2ce1 100644
--- a/backend/e2e-test/routes/v1/secret-approval-request-lifecycle.spec.ts
+++ b/backend/e2e-test/routes/v1/secret-approval-request-lifecycle.spec.ts
@@ -15,7 +15,6 @@ import { SecretOperations } from "@app/services/secret/secret-types";
const getDb = () => (globalThis as unknown as { testDb: Knex }).testDb;
-const BRIDGE_MESSAGE = "Secret change requests on the approval system are not available yet.";
const projectId = seedData1.projectV3.id;
const envSlug = seedData1.environment.slug;
const BASE_KEY = "LIFECYCLE_BASE";
@@ -261,11 +260,29 @@ describe("Secret change request lifecycle on a policy on the global approval sys
]);
});
- test("reading details is refused until the bridge supports it", async () => {
+ test("reading details returns the request from the global tables", async () => {
+ const [rejectedRequestId] = requestIds;
for await (const requestId of requestIds) {
const res = await getRequest(requestId);
- expect(res.statusCode).toBe(400);
- expect(res.json().message).toBe(BRIDGE_MESSAGE);
+ expect(res.statusCode).toBe(200);
+ const { approval } = res.json();
+ expect(approval).toMatchObject({
+ id: requestId,
+ folderId,
+ secretPath,
+ environment: envSlug,
+ status: RequestState.Open,
+ committerUser: { userId: seedData1.id },
+ policy: { id: policyId, deletedAt: null, approvers: [{ userId: seedData1.id }] },
+ reviewers: [
+ {
+ userId: seedData1.id,
+ status: requestId === rejectedRequestId ? ApprovalStatus.REJECTED : ApprovalStatus.APPROVED
+ }
+ ]
+ });
+ expect(approval.commits).toHaveLength(1);
+ expect(approval.commits[0]).toMatchObject({ secretValueHidden: false });
}
});
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-dal.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-dal.ts
index 70d09cae5f..fc2db70f3d 100644
--- a/backend/src/ee/services/secret-approval-request/secret-approval-request-dal.ts
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-dal.ts
@@ -21,7 +21,7 @@ import { RequestState, SecretApprovalRequestOrderBy } from "./secret-approval-re
export type TSecretApprovalRequestDALFactory = ReturnType<typeof secretApprovalRequestDALFactory>;
-type TFindQueryFilter = {
+export type TSecretApprovalRequestListFilter = {
projectId: string;
userId?: string;
status?: RequestState;
@@ -34,6 +34,8 @@ type TFindQueryFilter = {
orderDirection?: OrderByDirection;
};
+type TFindQueryFilter = TSecretApprovalRequestListFilter;
+
// Type for the query result documents in findByProjectId and findByProjectIdBridgeSecretV2
type TSecretApprovalRequestDoc = TSecretApprovalRequests & {
environment: string;
@@ -97,7 +99,7 @@ const getOrderExpression = (orderBy = SecretApprovalRequestOrderBy.CreatedAt) =>
}
};
-const applyRequestOrdering = (
+export const applyRequestOrdering = (
query: Knex.QueryBuilder,
orderBy?: SecretApprovalRequestOrderBy,
orderDirection = OrderByDirection.DESC
@@ -642,6 +644,7 @@ export const secretApprovalRequestDALFactory = (db: TDbClient) => {
parentMapper: (el) => ({
...SecretApprovalRequestsSchema.parse(el),
environment: el.environment,
+ environmentName: el.environmentName,
projectId: el.projectId,
policy: {
id: el.policyId,
@@ -906,6 +909,7 @@ export const secretApprovalRequestDALFactory = (db: TDbClient) => {
parentMapper: (el) => ({
...SecretApprovalRequestsSchema.parse(el),
environment: el.environment,
+ environmentName: el.environmentName,
projectId: el.projectId,
policy: {
id: el.policyId,
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-details-fns.test.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-details-fns.test.ts
new file mode 100644
index 0000000000..53d70ac6ef
--- /dev/null
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-details-fns.test.ts
@@ -0,0 +1,168 @@
+import { describe, expect, test, vi } from "vitest";
+
+import { INFISICAL_SECRET_VALUE_HIDDEN_MASK } from "@app/services/secret/secret-fns";
+
+import { ProjectPermissionSecretActions } from "../permission/project-permission";
+import {
+ buildSecretApprovalCommitValueAccess,
+ formatSecretApprovalCommitsV2Bridge
+} from "./secret-approval-request-details-fns";
+import { TSecretApprovalBridgeCommit } from "./secret-approval-request-merge-fns";
+
+const decryptor = vi.fn(({ cipherTextBlob }: { cipherTextBlob: Buffer }) =>
+ Buffer.from(`plain:${cipherTextBlob.toString()}`)
+);
+
+const commit = (overrides: Partial<TSecretApprovalBridgeCommit> = {}) =>
+ ({
+ id: "commit-1",
+ op: "update",
+ key: "KEY",
+ version: 2,
+ encryptedValue: Buffer.from("new"),
+ encryptedComment: Buffer.from("comment"),
+ skipMultilineEncoding: true,
+ secretMetadata: [
+ { key: "plain", value: "visible" },
+ { key: "hidden", encryptedValue: Buffer.from("meta").toString("base64") }
+ ],
+ tags: [{ id: "tag-1", name: "t", slug: "t", color: "red" }],
+ secret: {
+ id: "secret-1",
+ version: 1,
+ key: "KEY",
+ encryptedValue: Buffer.from("live"),
+ encryptedComment: null,
+ isRotatedSecret: false,
+ rotationId: null
+ },
+ secretVersion: {
+ id: "version-1",
+ version: 1,
+ key: "KEY",
+ encryptedValue: Buffer.from("old"),
+ encryptedComment: Buffer.from("old comment"),
+ skipMultilineEncoding: false,
+ tags: []
+ },
+ oldSecretMetadata: [{ id: "meta-1", key: "old", value: null, encryptedValue: Buffer.from("old meta") }],
+ ...overrides
+ }) as unknown as TSecretApprovalBridgeCommit;
+
+describe("formatSecretApprovalCommitsV2Bridge", () => {
+ test("decrypts the commit, the live secret and the reviewed version when the value is readable", () => {
+ const [formatted] = formatSecretApprovalCommitsV2Bridge({
+ commits: [commit()],
+ decryptor,
+ canReadSecretValue: () => true
+ });
+
+ expect(formatted).toMatchObject({
+ id: "commit-1",
+ secretKey: "KEY",
+ version: 2,
+ secretValueHidden: false,
+ secretValue: "plain:new",
+ secretComment: "plain:comment",
+ skipMultilineEncoding: true,
+ isRotatedSecret: false,
+ secretMetadata: [
+ { key: "plain", isEncrypted: false, value: "visible" },
+ { key: "hidden", isEncrypted: true, value: "plain:meta" }
+ ],
+ secret: {
+ id: "secret-1",
+ secretKey: "KEY",
+ secretValueHidden: false,
+ secretValue: "plain:live",
+ secretComment: ""
+ },
+ secretVersion: {
+ id: "version-1",
+ secretKey: "KEY",
+ secretValueHidden: false,
+ secretValue: "plain:old",
+ secretComment: "plain:old comment",
+ skipMultilineEncoding: false,
+ secretMetadata: [{ key: "old", isEncrypted: true, value: "plain:old meta" }]
+ }
+ });
+ });
+
+ test("masks every value when the caller cannot read it and still decrypts the comment", () => {
+ const canReadSecretValue = vi.fn().mockReturnValue(false);
+ const [formatted] = formatSecretApprovalCommitsV2Bridge({ commits: [commit()], decryptor, canReadSecretValue });
+
+ expect(canReadSecretValue).toHaveBeenCalledTimes(1);
+ expect(canReadSecretValue).toHaveBeenCalledWith([{ id: "tag-1", name: "t", slug: "t", color: "red" }]);
+ expect(formatted).toMatchObject({
+ secretValueHidden: true,
+ secretValue: INFISICAL_SECRET_VALUE_HIDDEN_MASK,
+ secretComment: "plain:comment",
+ secret: { secretValueHidden: true, secretValue: INFISICAL_SECRET_VALUE_HIDDEN_MASK },
+ secretVersion: { secretValueHidden: true, secretValue: INFISICAL_SECRET_VALUE_HIDDEN_MASK }
+ });
+ });
+
+ test("leaves a rotated secret's value out and tolerates a commit without relations", () => {
+ const [rotated, bare] = formatSecretApprovalCommitsV2Bridge({
+ commits: [
+ commit({ secret: { ...commit().secret, isRotatedSecret: true } }),
+ commit({
+ id: "commit-2",
+ encryptedValue: null,
+ encryptedComment: null,
+ skipMultilineEncoding: null,
+ secretMetadata: null,
+ secret: undefined,
+ secretVersion: undefined,
+ oldSecretMetadata: []
+ })
+ ],
+ decryptor,
+ canReadSecretValue: () => true
+ });
+
+ expect(rotated).toMatchObject({ isRotatedSecret: true, secretValue: undefined, secretValueHidden: false });
+ expect(bare).toMatchObject({
+ id: "commit-2",
+ secretValue: undefined,
+ secretComment: undefined,
+ skipMultilineEncoding: undefined,
+ secretMetadata: [],
+ secret: undefined,
+ secretVersion: undefined
+ });
+ });
+});
+
+describe("buildSecretApprovalCommitValueAccess", () => {
+ test("grants a reviewer access while the request is open without consulting the permission", () => {
+ const permission = { can: vi.fn().mockReturnValue(false) };
+ const canRead = buildSecretApprovalCommitValueAccess({
+ permission: permission as never,
+ isReviewer: true,
+ isRequestOpen: true,
+ environment: "dev",
+ secretPath: "/app"
+ });
+ expect(canRead([{ slug: "t" }])).toBe(true);
+ expect(permission.can).not.toHaveBeenCalled();
+ });
+
+ test("otherwise asks the permission about the environment, path and tags", () => {
+ const permission = { can: vi.fn().mockReturnValue(true) };
+ const canRead = buildSecretApprovalCommitValueAccess({
+ permission: permission as never,
+ isReviewer: true,
+ isRequestOpen: false,
+ environment: "dev",
+ secretPath: null
+ });
+ expect(canRead([{ slug: "t" }])).toBe(true);
+ expect(permission.can).toHaveBeenCalledWith(
+ ProjectPermissionSecretActions.ReadValue,
+ expect.objectContaining({ environment: "dev", secretPath: "/", secretTags: ["t"] })
+ );
+ });
+});
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-details-fns.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-details-fns.ts
new file mode 100644
index 0000000000..95bf592541
--- /dev/null
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-details-fns.ts
@@ -0,0 +1,122 @@
+import { MongoAbility } from "@casl/ability";
+
+import { INFISICAL_SECRET_VALUE_HIDDEN_MASK } from "@app/services/secret/secret-fns";
+
+import { hasSecretReadValueOrDescribePermission } from "../permission/permission-fns";
+import { ProjectPermissionSecretActions, ProjectPermissionSet } from "../permission/project-permission";
+import { TSecretApprovalBridgeCommit } from "./secret-approval-request-merge-fns";
+
+export type TSecretApprovalCommitValueAccess = (tags: { slug: string }[]) => boolean;
+
+type TSecretApprovalCommitMetadata = { key: string; value?: string | null; encryptedValue?: string | null };
+
+// Reviewers get temporary read access only while the request is open for review. Everyone else is
+// bound by their own secret read permissions on the request's environment, path and tags.
+export const buildSecretApprovalCommitValueAccess =
+ ({
+ permission,
+ isReviewer,
+ isRequestOpen,
+ environment,
+ secretPath
+ }: {
+ permission: MongoAbility<ProjectPermissionSet>;
+ isReviewer: boolean;
+ isRequestOpen: boolean;
+ environment: string;
+ secretPath?: string | null;
+ }): TSecretApprovalCommitValueAccess =>
+ (tags) =>
+ (isReviewer && isRequestOpen) ||
+ hasSecretReadValueOrDescribePermission(permission, ProjectPermissionSecretActions.ReadValue, {
+ environment,
+ secretPath: secretPath || "/",
+ secretTags: tags.map((tag) => tag.slug)
+ });
+
+export const formatSecretApprovalCommitsV2Bridge = ({
+ commits,
+ decryptor,
+ canReadSecretValue
+}: {
+ commits: TSecretApprovalBridgeCommit[];
+ decryptor: (arg: { cipherTextBlob: Buffer }) => Buffer;
+ canReadSecretValue: TSecretApprovalCommitValueAccess;
+}) =>
+ commits.map((el) => {
+ const secretValueHidden = !canReadSecretValue(el.tags);
+ const decryptValue = (encryptedValue?: Buffer | null) =>
+ encryptedValue ? decryptor({ cipherTextBlob: encryptedValue }).toString() : "";
+ const commitSecretValue = () => {
+ if (secretValueHidden) return INFISICAL_SECRET_VALUE_HIDDEN_MASK;
+ if (el.secret?.isRotatedSecret) return undefined;
+ return el.encryptedValue !== undefined && el.encryptedValue !== null
+ ? decryptor({ cipherTextBlob: el.encryptedValue }).toString()
+ : undefined;
+ };
+
+ return {
+ ...el,
+ secretKey: el.key,
+ id: el.id,
+ version: el.version,
+ secretMetadata: (Array.isArray(el.secretMetadata)
+ ? (el.secretMetadata as TSecretApprovalCommitMetadata[])
+ : []
+ ).map((meta) => ({
+ key: meta.key,
+ isEncrypted: Boolean(meta.encryptedValue),
+ value: meta.encryptedValue
+ ? decryptor({ cipherTextBlob: Buffer.from(meta.encryptedValue, "base64") }).toString()
+ : meta.value || ""
+ })),
+ isRotatedSecret: el.secret?.isRotatedSecret ?? false,
+ secretValueHidden,
+ secretValue: commitSecretValue(),
+ secretComment:
+ el.encryptedComment !== undefined && el.encryptedComment !== null
+ ? decryptor({ cipherTextBlob: el.encryptedComment }).toString()
+ : undefined,
+ skipMultilineEncoding:
+ el.skipMultilineEncoding !== undefined && el.skipMultilineEncoding !== null
+ ? el.skipMultilineEncoding
+ : undefined,
+ secret: el.secret
+ ? {
+ secretKey: el.secret.key,
+ id: el.secret.id,
+ version: el.secret.version,
+ secretValueHidden,
+ secretValue: secretValueHidden
+ ? INFISICAL_SECRET_VALUE_HIDDEN_MASK
+ : decryptValue(el.secret.encryptedValue),
+ secretComment: decryptValue(el.secret.encryptedComment)
+ }
+ : undefined,
+ secretVersion: el.secretVersion
+ ? {
+ secretKey: el.secretVersion.key,
+ id: el.secretVersion.id,
+ version: el.secretVersion.version,
+ secretValueHidden,
+ secretValue: secretValueHidden
+ ? INFISICAL_SECRET_VALUE_HIDDEN_MASK
+ : decryptValue(el.secretVersion.encryptedValue),
+ secretComment: decryptValue(el.secretVersion.encryptedComment),
+ tags: el.secretVersion.tags,
+ // The live secret's metadata is stored as raw ciphertext while the commit's proposed metadata is
+ // base64 encoded, so the two decode differently.
+ secretMetadata: el.oldSecretMetadata?.map((meta) => ({
+ key: meta.key,
+ isEncrypted: Boolean(meta.encryptedValue),
+ value: meta.encryptedValue
+ ? decryptor({ cipherTextBlob: Buffer.from(meta.encryptedValue) }).toString()
+ : meta.value || ""
+ })),
+ skipMultilineEncoding: el.secretVersion.skipMultilineEncoding
+ }
+ : undefined
+ };
+ });
+
+export type TFormattedSecretApprovalCommitV2Bridge = ReturnType<typeof formatSecretApprovalCommitsV2Bridge>[number];
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-fns.test.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-fns.test.ts
new file mode 100644
index 0000000000..7147be7c99
--- /dev/null
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-fns.test.ts
@@ -0,0 +1,124 @@
+import { describe, expect, test } from "vitest";
+
+import { OrderByDirection } from "@app/lib/types";
+
+import {
+ compareSecretApprovalRequests,
+ mergeSecretApprovalRequestPages,
+ TSecretApprovalRequestSortable
+} from "./secret-approval-request-fns";
+import { SecretApprovalRequestOrderBy } from "./secret-approval-request-types";
+
+const request = (
+ overrides: Partial<TSecretApprovalRequestSortable> & { id: string }
+): TSecretApprovalRequestSortable => ({
+ createdAt: new Date("2026-01-01"),
+ environment: "dev",
+ environmentName: "Development",
+ policy: { secretPath: "/" },
+ committerUser: { firstName: "Alice", lastName: "Smith", email: "[email protected]" },
+ committerIdentity: null,
+ ...overrides
+});
+
+const idsSortedBy = (
+ requests: TSecretApprovalRequestSortable[],
+ orderBy?: SecretApprovalRequestOrderBy,
+ orderDirection?: OrderByDirection
+) => [...requests].sort(compareSecretApprovalRequests(orderBy, orderDirection)).map((el) => el.id);
+
+describe("compareSecretApprovalRequests", () => {
+ test("orders by createdAt descending by default and breaks ties on id ascending", () => {
+ const requests = [
+ request({ id: "b", createdAt: new Date("2026-01-02") }),
+ request({ id: "c", createdAt: new Date("2026-01-03") }),
+ request({ id: "a", createdAt: new Date("2026-01-02") })
+ ];
+ expect(idsSortedBy(requests)).toEqual(["c", "a", "b"]);
+ expect(idsSortedBy(requests, SecretApprovalRequestOrderBy.CreatedAt, OrderByDirection.ASC)).toEqual([
+ "a",
+ "b",
+ "c"
+ ]);
+ });
+
+ test("orders by environment name case-insensitively and falls back to the slug", () => {
+ const requests = [
+ request({ id: "a", environment: "prod", environmentName: "Production" }),
+ request({ id: "b", environment: "zeta", environmentName: null }),
+ request({ id: "c", environment: "dev", environmentName: "development" })
+ ];
+ expect(idsSortedBy(requests, SecretApprovalRequestOrderBy.Environment, OrderByDirection.ASC)).toEqual([
+ "c",
+ "a",
+ "b"
+ ]);
+ expect(idsSortedBy(requests, SecretApprovalRequestOrderBy.Environment, OrderByDirection.DESC)).toEqual([
+ "b",
+ "a",
+ "c"
+ ]);
+ });
+
+ test("orders by the policy secret path", () => {
+ const requests = [
+ request({ id: "a", policy: { secretPath: "/b" } }),
+ request({ id: "b", policy: { secretPath: null } }),
+ request({ id: "c", policy: { secretPath: "/A" } })
+ ];
+ expect(idsSortedBy(requests, SecretApprovalRequestOrderBy.SecretPath, OrderByDirection.ASC)).toEqual([
+ "b",
+ "c",
+ "a"
+ ]);
+ });
+
+ test("orders by author falling back from the name to the email to the identity name", () => {
+ const requests = [
+ request({ id: "a", committerUser: { firstName: "zoe", lastName: null, email: "[email protected]" } }),
+ request({ id: "b", committerUser: { firstName: null, lastName: null, email: "[email protected]" } }),
+ request({ id: "c", committerUser: null, committerIdentity: { name: "Deploy bot" } }),
+ request({ id: "d", committerUser: null, committerIdentity: null })
+ ];
+ expect(idsSortedBy(requests, SecretApprovalRequestOrderBy.Author, OrderByDirection.ASC)).toEqual([
+ "d",
+ "b",
+ "c",
+ "a"
+ ]);
+ });
+});
+
+describe("mergeSecretApprovalRequestPages", () => {
+ const legacy = {
+ approvals: [
+ request({ id: "legacy-new", createdAt: new Date("2026-01-04") }),
+ request({ id: "legacy-old", createdAt: new Date("2026-01-01") })
+ ],
+ totalCount: 7
+ };
+ const global = {
+ approvals: [
+ request({ id: "global-new", createdAt: new Date("2026-01-05") }),
+ request({ id: "global-old", createdAt: new Date("2026-01-02") })
+ ],
+ totalCount: 3
+ };
+
+ test("sorts both pages together, slices the requested window and sums the totals", () => {
+ const merged = mergeSecretApprovalRequestPages({ pages: [legacy, global], offset: 1, limit: 2 });
+ expect(merged.approvals.map((el) => el.id)).toEqual(["legacy-new", "global-old"]);
+ expect(merged.totalCount).toBe(10);
+ });
+
+ test("honours the requested ordering", () => {
+ const merged = mergeSecretApprovalRequestPages({
+ pages: [legacy, global],
+ offset: 0,
+ limit: 10,
+ orderBy: SecretApprovalRequestOrderBy.CreatedAt,
+ orderDirection: OrderByDirection.ASC
+ });
+ expect(merged.approvals.map((el) => el.id)).toEqual(["legacy-old", "global-old", "legacy-new", "global-new"]);
+ });
+});
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-fns.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-fns.ts
index 03cbbde20b..38aeaf90ba 100644
--- a/backend/src/ee/services/secret-approval-request/secret-approval-request-fns.ts
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-fns.ts
@@ -1,11 +1,13 @@
import { TSecretApprovalRequests } from "@app/db/schemas";
import { getConfig } from "@app/lib/config/env";
+import { OrderByDirection } from "@app/lib/types";
import { TNotificationServiceFactory } from "@app/services/notification/notification-service";
import { NotificationType } from "@app/services/notification/notification-types";
import { TProjectDALFactory } from "@app/services/project/project-dal";
import { SmtpTemplates, TSmtpService } from "@app/services/smtp/smtp-service";
import { TSecretApprovalPolicyDALFactory } from "../secret-approval-policy/secret-approval-policy-dal";
+import { SecretApprovalRequestOrderBy } from "./secret-approval-request-types";
type TSendApprovalEmails = {
secretApprovalPolicyDAL: Pick<TSecretApprovalPolicyDALFactory, "findById">;
@@ -86,3 +88,73 @@ export const hasSecretUpdateCommitConflict = (
const reviewedKey = commit.secretVersion?.key ?? commit.secret.key;
return commit.key === reviewedKey;
};
+
+export type TSecretApprovalRequestSortable = {
+ id: string;
+ createdAt: Date;
+ environment: string;
+ environmentName?: string | null;
+ policy: { secretPath?: string | null };
+ committerUser?: { firstName?: string | null; lastName?: string | null; email?: string | null } | null;
+ committerIdentity?: { name?: string | null } | null;
+};
+
+const lowerSortKey = (value?: string | null) => (value ?? "").toLowerCase();
+
+const sortKeyOf = (request: TSecretApprovalRequestSortable, orderBy: SecretApprovalRequestOrderBy) => {
+ switch (orderBy) {
+ case SecretApprovalRequestOrderBy.Environment:
+ return lowerSortKey(request.environmentName ?? request.environment);
+ case SecretApprovalRequestOrderBy.SecretPath:
+ return lowerSortKey(request.policy.secretPath);
+ case SecretApprovalRequestOrderBy.Author:
+ return lowerSortKey(
+ `${request.committerUser?.firstName ?? ""} ${request.committerUser?.lastName ?? ""}`.trim() ||
+ request.committerUser?.email ||
+ request.committerIdentity?.name
+ );
+ case SecretApprovalRequestOrderBy.CreatedAt:
+ default:
+ return request.createdAt.getTime();
+ }
+};
+
+// Mirrors the ordering the list queries apply in SQL so pages read from the legacy and the global approval
+// system can be merged in memory. String keys compare by code point, which can differ from the database
+// collation for non-ASCII names.
+export const compareSecretApprovalRequests =
+ (
+ orderBy: SecretApprovalRequestOrderBy = SecretApprovalRequestOrderBy.CreatedAt,
+ orderDirection: OrderByDirection = OrderByDirection.DESC
+ ) =>
+ (a: TSecretApprovalRequestSortable, b: TSecretApprovalRequestSortable) => {
+ const direction = orderDirection === OrderByDirection.ASC ? 1 : -1;
+ const keyA = sortKeyOf(a, orderBy);
+ const keyB = sortKeyOf(b, orderBy);
+ if (keyA < keyB) return -direction;
+ if (keyA > keyB) return direction;
+ if (a.id === b.id) return 0;
+ return a.id < b.id ? -1 : 1;
+ };
+
+// Each source is asked for the first offset + limit rows in the requested order, so the slice taken here is
+// exactly what one query over both systems would return. Deep pages cost offset + limit rows per source.
+export const mergeSecretApprovalRequestPages = <T extends TSecretApprovalRequestSortable>({
+ pages,
+ offset,
+ limit,
+ orderBy,
+ orderDirection
+}: {
+ pages: { approvals: T[]; totalCount: number }[];
+ offset: number;
+ limit: number;
+ orderBy?: SecretApprovalRequestOrderBy;
+ orderDirection?: OrderByDirection;
+}) => ({
+ approvals: pages
+ .flatMap((page) => page.approvals)
+ .sort(compareSecretApprovalRequests(orderBy, orderDirection))
+ .slice(offset, offset + limit),
+ totalCount: pages.reduce((total, page) => total + page.totalCount, 0)
+});
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-secret-dal.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-secret-dal.ts
index 7d74c5f181..b885f201e3 100644
--- a/backend/src/ee/services/secret-approval-request/secret-approval-request-secret-dal.ts
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-secret-dal.ts
@@ -402,6 +402,17 @@ export const secretApprovalRequestSecretDALFactory = (db: TDbClient) => {
const findBySecretChangeIdBridgeSecretV2 = (secretChangeId: string, tx?: Knex) =>
$findBridgeSecretV2({ secretChangeId }, "FindBySecretChangeIdBridgeSecretV2", tx);
+ const findCommitsBySecretChangeIds = async (secretChangeIds: string[], tx?: Knex) => {
+ if (!secretChangeIds.length) return [];
+ const rows = await secretApprovalRequestSecretV2Orm.find({ $in: { secretChangeId: secretChangeIds } }, { tx });
+ return rows.map(({ id, op, secretId, secretChangeId }) => ({
+ id,
+ op,
+ secretId: secretId ?? null,
+ secretChangeId: secretChangeId as string
+ }));
+ };
+
// special query for migration to v2 secret
const findByProjectId = async (projectId: string, tx?: Knex) => {
try {
@@ -463,6 +474,7 @@ export const secretApprovalRequestSecretDALFactory = (db: TDbClient) => {
findByRequestId,
findByRequestIdBridgeSecretV2,
findBySecretChangeIdBridgeSecretV2,
+ findCommitsBySecretChangeIds,
bulkUpdateNoVersionIncrement,
findByProjectId,
insertApprovalSecretTags: secretApprovalRequestSecretTagOrm.insertMany,
diff --git a/backend/src/ee/services/secret-approval-request/secret-approval-request-service.ts b/backend/src/ee/services/secret-approval-request/secret-approval-request-service.ts
index 35666bc35f..64fc77bda1 100644
--- a/backend/src/ee/services/secret-approval-request/secret-approval-request-service.ts
+++ b/backend/src/ee/services/secret-approval-request/secret-approval-request-service.ts
@@ -42,8 +42,7 @@ import {
fnSecretBulkDelete,
fnSecretBulkInsert,
fnSecretBulkUpdate,
- getAllNestedSecretReferences,
- INFISICAL_SECRET_VALUE_HIDDEN_MASK
+ getAllNestedSecretReferences
} from "@app/services/secret/secret-fns";
import { TSecretQueueFactory } from "@app/services/secret/secret-queue";
import { SecretOperations } from "@app/services/secret/secret-types";
@@ -64,10 +63,7 @@ import { TUserDALFactory } from "@app/services/user/user-dal";
import { ChangeRequestWebhookAction, TWebhookActor, WebhookEvents } from "@app/services/webhook/webhook-types";
import { TLicenseServiceFactory } from "../license/license-service";
-import {
- hasSecretReadValueOrDescribePermission,
- throwIfMissingSecretReadValueOrDescribePermission
-} from "../permission/permission-fns";
+import { throwIfMissingSecretReadValueOrDescribePermission } from "../permission/permission-fns";
import { TPermissionServiceFactory } from "../permission/permission-service-types";
import {
ProjectPermissionSecretActions,
@@ -79,9 +75,14 @@ import { TSecretApprovalPolicyDALFactory } from "../secret-approval-policy/secre
import { getCommitterIds } from "../secret-approval-policy/secret-approval-policy-fns";
import { TSecretChangePolicyBridgeServiceFactory } from "../secret-change-policy-bridge/secret-change-policy-bridge-service";
import { TSecretChangeRequestBridgeServiceFactory } from "../secret-change-request-bridge/secret-change-request-bridge-service";
+import { TSecretChangeRequestListItem } from "../secret-change-request-bridge/secret-change-request-bridge-types";
import { pickApprovalCommitColumns, secretApprovalRequestCommitFnsFactory } from "./secret-approval-request-commit-fns";
import { TSecretApprovalRequestDALFactory } from "./secret-approval-request-dal";
-import { sendApprovalEmailsFn } from "./secret-approval-request-fns";
+import {
+ buildSecretApprovalCommitValueAccess,
+ formatSecretApprovalCommitsV2Bridge
+} from "./secret-approval-request-details-fns";
+import { mergeSecretApprovalRequestPages, sendApprovalEmailsFn } from "./secret-approval-request-fns";
import { buildRequestedByActor, secretApprovalRequestMergeFnsFactory } from "./secret-approval-request-merge-fns";
import { TSecretApprovalRequestReviewerDALFactory } from "./secret-approval-request-reviewer-dal";
import { TSecretApprovalRequestSecretDALFactory } from "./secret-approval-request-secret-dal";
@@ -165,6 +166,8 @@ type TSecretApprovalRequestServiceFactoryDep = {
| "reviewSecretChangeRequest"
| "updateSecretChangeRequestStatus"
| "getSecretChangeRequestById"
+ | "listSecretChangeRequests"
+ | "countSecretChangeRequests"
>;
};
@@ -264,8 +267,14 @@ export const secretApprovalRequestServiceFactory = ({
// If user has the permission, count all requests; otherwise count only their requests
const userIdFilter = canReadAllApprovalRequests ? undefined : actorId;
- const count = await secretApprovalRequestDAL.findProjectRequestCount(projectId, userIdFilter, policyId);
- return count;
+ const [legacyCount, secretChangeCount] = await Promise.all([
+ secretApprovalRequestDAL.findProjectRequestCount(projectId, userIdFilter, policyId),
+ secretChangeRequestBridgeService.countSecretChangeRequests({ projectId, userId: userIdFilter, policyId })
+ ]);
+ return {
+ open: legacyCount.open + secretChangeCount.open,
+ closed: legacyCount.closed + secretChangeCount.closed
+ };
};
const getSecretApprovals = async ({
@@ -277,8 +286,8 @@ export const secretApprovalRequestServiceFactory = ({
status,
environment,
committer,
- limit,
- offset,
+ limit = 20,
+ offset = 0,
search,
orderBy,
orderDirection
@@ -307,16 +316,30 @@ export const secretApprovalRequestServiceFactory = ({
const { shouldUseSecretV2Bridge } = await projectBotService.getBotKey(projectId);
if (shouldUseSecretV2Bridge) {
- return secretApprovalRequestDAL.findByProjectIdBridgeSecretV2({
+ // Policies on the global approval system only exist on upgraded projects, so only this branch has
+ // requests on both systems. Each is asked for the head of the list up to the requested page.
+ const headOfList = {
projectId,
committer,
environment,
status,
userId: userIdFilter,
- limit,
- offset,
search,
orderBy,
+ orderDirection,
+ limit: offset + limit,
+ offset: 0
+ };
+ const [legacyRequests, secretChangeRequests] = await Promise.all([
+ secretApprovalRequestDAL.findByProjectIdBridgeSecretV2(headOfList),
+ secretChangeRequestBridgeService.listSecretChangeRequests(headOfList)
+ ]);
+ type TListedRequest = (typeof legacyRequests)["approvals"][number] | TSecretChangeRequestListItem;
+ return mergeSecretApprovalRequestPages<TListedRequest>({
+ pages: [legacyRequests, secretChangeRequests],
+ offset,
+ limit,
+ orderBy,
orderDirection
});
}
@@ -378,123 +401,32 @@ export const secretApprovalRequestServiceFactory = ({
) {
throw new ForbiddenRequestError({ message: "User has insufficient privileges" });
}
- const getHasSecretReadAccess = (environment: string, tags: { slug: string }[], secretPath?: string) => {
- const isReviewer = policy.approvers.some(({ userId }) => userId === actorId);
-
- // Reviewers get temporary read access only while the request is open for review
- if (isReviewer && secretApprovalRequest.status === RequestState.Open) {
- return true;
- }
-
- // Otherwise check actual read permissions
- const canRead = hasSecretReadValueOrDescribePermission(permission, ProjectPermissionSecretActions.ReadValue, {
- environment,
- secretPath: secretPath || "/",
- secretTags: tags.map((i) => i.slug)
- });
- return canRead;
- };
-
let secrets;
const secretPath = await folderDAL.findSecretPathByFolderIds(secretApprovalRequest.projectId, [
secretApprovalRequest.folderId
]);
+ const canReadSecretValue = buildSecretApprovalCommitValueAccess({
+ permission,
+ isReviewer: policy.approvers.some(({ userId }) => userId === actorId),
+ isRequestOpen: secretApprovalRequest.status === RequestState.Open,
+ environment: secretApprovalRequest.environment,
+ secretPath: secretPath?.[0]?.path
+ });
if (shouldUseSecretV2Bridge) {
- const { decryptor: secretManagerDecryptor } = await kmsService.createCipherPairWithDataKey({
+ const { decryptor } = await kmsService.createCipherPairWithDataKey({
type: KmsDataKey.SecretManager,
projectId
});
const encryptedSecrets = await secretApprovalRequestSecretDAL.findByRequestIdBridgeSecretV2(
secretApprovalRequest.id
);
- secrets = encryptedSecrets.map((el) => ({
- ...el,
- secretKey: el.key,
- id: el.id,
- version: el.version,
- secretMetadata: (Array.isArray(el.secretMetadata)
- ? (el.secretMetadata as { key: string; value?: string | null; encryptedValue?: string | null }[])
- : []
- ).map((meta) => ({
- key: meta.key,
- isEncrypted: Boolean(meta.encryptedValue),
- value: meta.encryptedValue
- ? secretManagerDecryptor({ cipherTextBlob: Buffer.from(meta.encryptedValue, "base64") }).toString()
- : meta.value || ""
- })),
- isRotatedSecret: el.secret?.isRotatedSecret ?? false,
- secretValueHidden: !getHasSecretReadAccess(secretApprovalRequest.environment, el.tags, secretPath?.[0]?.path),
- secretValue: !getHasSecretReadAccess(secretApprovalRequest.environment, el.tags, secretPath?.[0]?.path)
- ? INFISICAL_SECRET_VALUE_HIDDEN_MASK
- : el.secret && el.secret.isRotatedSecret
- ? undefined
- : el.encryptedValue !== undefined && el.encryptedValue !== null
- ? secretManagerDecryptor({ cipherTextBlob: el.encryptedValue }).toString()
- : undefined,
- secretComment:
- el.encryptedComment !== undefined && el.encryptedComment !== null
- ? secretManagerDecryptor({ cipherTextBlob: el.encryptedComment }).toString()
- : undefined,
- skipMultilineEncoding:
- el.skipMultilineEncoding !== undefined && el.skipMultilineEncoding !== null
- ? el.skipMultilineEncoding
- : undefined,
- secret: el.secret
- ? {
- secretKey: el.secret.key,
- id: el.secret.id,
- version: el.secret.version,
- secretValueHidden: !getHasSecretReadAccess(
- secretApprovalRequest.environment,
- el.tags,
- secretPath?.[0]?.path
- ),
- secretValue: !getHasSecretReadAccess(secretApprovalRequest.environment, el.tags, secretPath?.[0]?.path)
- ? INFISICAL_SECRET_VALUE_HIDDEN_MASK
- : el.secret.encryptedValue
- ? secretManagerDecryptor({ cipherTextBlob: el.secret.encryptedValue }).toString()
- : "",
- secretComment: el.secret.encryptedComment
- ? secretManagerDecryptor({ cipherTextBlob: el.secret.encryptedComment }).toString()
- : ""
- }
- : undefined,
- secretVersion: el.secretVersion
- ? {
- secretKey: el.secretVersion.key,
- id: el.secretVersion.id,
- version: el.secretVersion.version,
- secretValueHidden: !getHasSecretReadAccess(
- secretApprovalRequest.environment,
- el.tags,
- secretPath?.[0]?.path
- ),
- secretValue: !getHasSecretReadAccess(secretApprovalRequest.environment, el.tags, secretPath?.[0]?.path)
- ? INFISICAL_SECRET_VALUE_HIDDEN_MASK
- : el.secretVersion.encryptedValue
- ? secretManagerDecryptor({ cipherTextBlob: el.secretVersion.encryptedValue }).toString()
- : "",
- secretComment: el.secretVersion.encryptedComment
- ? secretManagerDecryptor({ cipherTextBlob: el.secretVersion.encryptedComment }).toString()
- : "",
- tags: el.secretVersion.tags,
- secretMetadata: el.oldSecretMetadata?.map((meta) => ({
- key: meta.key,
- isEncrypted: Boolean(meta.encryptedValue),
- value: meta.encryptedValue
- ? secretManagerDecryptor({ cipherTextBlob: Buffer.from(meta.encryptedValue) }).toString()
- : meta.value || ""
- })),
- skipMultilineEncoding: el.secretVersion.skipMultilineEncoding
- }
- : undefined
- }));
+ secrets = formatSecretApprovalCommitsV2Bridge({ commits: encryptedSecrets, decryptor, canReadSecretValue });
} else {
if (!botKey) throw new NotFoundError({ message: `Project bot key not found`, name: "BotKeyNotFound" }); // CLI depends on this error message. TODO(daniel): Make API check for name BotKeyNotFound instead of message
const encryptedSecrets = await secretApprovalRequestSecretDAL.findByRequestId(secretApprovalRequest.id);
secrets = encryptedSecrets.map((el) => ({
...el,
- secretValueHidden: !getHasSecretReadAccess(secretApprovalRequest.environment, el.tags, secretPath?.[0]?.path),
+ secretValueHidden: !canReadSecretValue(el.tags),
...decryptSecretWithBot(el, botKey),
secret: el.secret
? {
diff --git a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-fns.ts b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-fns.ts
index 52eb5ddb02..90d0a11c92 100644
--- a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-fns.ts
+++ b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-fns.ts
@@ -5,7 +5,8 @@ import {
TApprovalRequests,
TSecretApprovalRequestsReviewers,
TSecretApprovalRequestsSecretsV2,
- TSecretChangeRequests
+ TSecretChangeRequests,
+ TUsers
} from "@app/db/schemas";
import { getConfig } from "@app/lib/config/env";
import { BadRequestError, NotFoundError } from "@app/lib/errors";
@@ -14,9 +15,11 @@ import { logger } from "@app/lib/logger";
import { alphaNumericNanoId } from "@app/lib/nanoid";
import { requestMemoKeys } from "@app/lib/request-context/memo-keys";
import { requestMemoize } from "@app/lib/request-context/request-memoizer";
+import { EnforcementLevel } from "@app/lib/types";
import { triggerWorkflowIntegrationNotification } from "@app/lib/workflow-integrations/trigger-notification";
import { TriggerFeature } from "@app/lib/workflow-integrations/types";
import { QueueJobs, QueueName, TQueueServiceFactory } from "@app/queue";
+import { ApproverType } from "@app/services/approval-policy/approval-policy-enums";
import { ActorType } from "@app/services/auth/auth-type";
import { TIdentityDALFactory } from "@app/services/identity/identity-dal";
import { TKmsServiceFactory } from "@app/services/kms/kms-service";
@@ -33,9 +36,17 @@ import { PostHogEventTypes } from "@app/services/telemetry/telemetry-types";
import { TUserDALFactory } from "@app/services/user/user-dal";
import { ChangeRequestWebhookAction, TWebhookActor, WebhookEvents } from "@app/services/webhook/webhook-types";
+import { BypasserType } from "../access-approval-policy/access-approval-policy-types";
import { TSecretApprovalBridgeCommit } from "../secret-approval-request/secret-approval-request-merge-fns";
+import { readSecretChangePolicyConstraints } from "../secret-change-policy-bridge/secret-change-policy-bridge-fns";
import { TSecretChangePolicy } from "../secret-change-policy-bridge/secret-change-policy-bridge-types";
-import { TSecretChangeRequest } from "./secret-change-request-bridge-types";
+import {
+ TApprovalRequestUser,
+ TSecretChangeRequest,
+ TSecretChangeRequestListItem,
+ TSecretChangeRequestPolicySummary
+} from "./secret-change-request-bridge-types";
+import { TSecretChangeRequestListRow } from "./secret-change-request-dal";
type TSecretChangeRequestFnsFactoryDep = {
userDAL: Pick<TUserDALFactory, "findById" | "find">;
@@ -76,15 +87,13 @@ export type TSecretChangeRequestSideEffectsDTO = {
export type TSecretChangeRequestFnsFactory = ReturnType<typeof secretChangeRequestFnsFactory>;
-export const toSecretChangeRequest = ({
+export const toSecretChangeRequestBase = ({
approvalRequest,
- secretChangeRequest,
- commits
+ secretChangeRequest
}: {
approvalRequest: TApprovalRequests;
secretChangeRequest: TSecretChangeRequests;
- commits: TSecretApprovalRequestsSecretsV2[];
-}): TSecretChangeRequest => ({
+}): Omit<TSecretChangeRequest, "commits"> => ({
id: approvalRequest.id,
policyId: approvalRequest.policyId as string,
status: approvalRequest.status,
@@ -99,10 +108,18 @@ export const toSecretChangeRequest = ({
committerIdentityId: approvalRequest.machineIdentityId ?? null,
statusChangedByUserId: secretChangeRequest.statusChangedByUserId ?? null,
bypassReason: secretChangeRequest.bypassReason ?? null,
- commitMessage: secretChangeRequest.commitMessage ?? null,
- commits
+ commitMessage: secretChangeRequest.commitMessage ?? null
});
+export const toSecretChangeRequest = ({
+ commits,
+ ...request
+}: {
+ approvalRequest: TApprovalRequests;
+ secretChangeRequest: TSecretChangeRequests;
+ commits: TSecretApprovalRequestsSecretsV2[];
+}): TSecretChangeRequest => ({ ...toSecretChangeRequestBase(request), commits });
+
export const toSecretChangeRequestCommit = ({
secret,
secretVersion,
@@ -366,3 +383,122 @@ export const secretChangeRequestFnsFactory = ({
return { resolveRequester, queueChangeRequestWebhook, runSecretChangeRequestSideEffects };
};
+
+export const toApprovalRequestUser = (
+ user: Pick<TUsers, "id" | "email" | "firstName" | "lastName" | "username">
+): TApprovalRequestUser => ({
+ userId: user.id,
+ email: user.email,
+ firstName: user.firstName,
+ lastName: user.lastName,
+ username: user.username
+});
+
+// The global approval system hard-deletes policies and keeps no timestamp, so a request whose policy is gone
+// only knows that it is gone. Consumers test deletedAt for presence.
+export const toDeletedSecretChangePolicyStub = (
+ approvalRequest: Pick<TApprovalRequests, "policyId">,
+ steps: { requiredApprovals: number }[]
+): TSecretChangeRequestPolicySummary => ({
+ id: approvalRequest.policyId ?? "",
+ name: "Deleted policy",
+ approvals: steps[0]?.requiredApprovals ?? 1,
+ secretPath: null,
+ enforcementLevel: EnforcementLevel.Hard,
+ allowedSelfApprovals: true,
+ deletedAt: new Date()
+});
+
+export type TSecretChangeActor = { type: ApproverType | BypasserType; id: string };
+
+export const groupUserIdsByGroupId = (members: { groupId: string; userId: string }[]) =>
+ members.reduce<Record<string, string[]>>((acc, member) => {
+ const userIds = acc[member.groupId] || [];
+ userIds.push(member.userId);
+ acc[member.groupId] = userIds;
+ return acc;
+ }, {});
+
+export const isGroupActor = (actor: TSecretChangeActor) =>
+ actor.type === ApproverType.Group || actor.type === BypasserType.Group;
+
+export const resolveActorUserIds = (actors: TSecretChangeActor[], userIdsByGroupId: Record<string, string[]>) =>
+ unique(actors.flatMap((actor) => (isGroupActor(actor) ? (userIdsByGroupId[actor.id] ?? []) : [actor.id])));
+
+export type TSecretChangeRequestListStep = {
+ requiredApprovals: number;
+ approvers: TSecretChangeActor[];
+ approvals: Pick<TApprovalRequestApprovals, "approverUserId" | "decision">[];
+};
+
+export const toSecretChangeRequestListItem = ({
+ row,
+ steps,
+ commits,
+ bypassers,
+ userIdsByGroupId
+}: {
+ row: TSecretChangeRequestListRow;
+ steps: TSecretChangeRequestListStep[];
+ commits: { op: string; secretId: string | null }[];
+ bypassers: TSecretChangeActor[];
+ userIdsByGroupId: Record<string, string[]>;
+}): TSecretChangeRequestListItem => {
+ const approvers = resolveActorUserIds(
+ steps.flatMap((step) => step.approvers),
+ userIdsByGroupId
+ ).map((userId) => ({ userId }));
+ const bypasserUsers = resolveActorUserIds(bypassers, userIdsByGroupId).map((userId) => ({ userId }));
+ const policy: TSecretChangeRequestPolicySummary = row.policyId
+ ? {
+ id: row.policyId,
+ name: row.policyName ?? "",
+ approvals: row.policyApprovals ?? steps[0]?.requiredApprovals ?? 1,
+ secretPath: row.policySecretPath,
+ enforcementLevel: row.policyEnforcementLevel ?? EnforcementLevel.Hard,
+ allowedSelfApprovals: readSecretChangePolicyConstraints(row.policyConstraints).allowedSelfApprovals ?? true,
+ deletedAt: null
+ }
+ : toDeletedSecretChangePolicyStub(row, steps);
+
+ return {
+ ...toSecretChangeRequestBase({
+ approvalRequest: row,
+ secretChangeRequest: {
+ id: row.secretChangeId,
+ approvalRequestId: row.id,
+ folderId: row.folderId,
+ slug: row.slug,
+ hasMerged: row.hasMerged,
+ conflicts: row.conflicts,
+ commitMessage: row.commitMessage,
+ bypassReason: row.bypassReason,
+ statusChangedByUserId: row.statusChangedByUserId,
+ createdAt: row.createdAt,
+ updatedAt: row.updatedAt
+ }
+ }),
+ projectId: row.projectId,
+ environment: row.environment,
+ environmentName: row.environmentName,
+ policy: { ...policy, approvers, bypassers: bypasserUsers },
+ committerUser: row.requesterId
+ ? {
+ userId: row.requesterId,
+ email: row.committerUserEmail ?? row.requesterEmail,
+ username: row.committerUserUsername ?? row.requesterEmail,
+ firstName: row.committerUserFirstName,
+ lastName: row.committerUserLastName
+ }
+ : null,
+ committerIdentity: row.machineIdentityId
+ ? { identityId: row.machineIdentityId, name: row.committerIdentityName ?? row.requesterName }
+ : null,
+ reviewers: steps
+ .flatMap((step) => step.approvals)
+ .map((approval) => ({ userId: approval.approverUserId, status: approval.decision })),
+ commits: commits.map(({ op, secretId }) => ({ op, secretId })),
+ approvers,
+ bypassers: bypasserUsers
+ };
+};
diff --git a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.test.ts b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.test.ts
index 29cbe5dfc9..0b4cd72e29 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
@@ -11,6 +11,7 @@ import {
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";
@@ -121,7 +122,10 @@ const MERGED_FOLDER = {
environmentSlug: "dev",
environmentName: "Development"
};
-const CIPHER = { cipher: "secret-manager" };
+const CIPHER = {
+ cipher: "secret-manager",
+ decryptor: ({ cipherTextBlob }: { cipherTextBlob: Buffer }) => Buffer.from(`plain:${cipherTextBlob.toString()}`)
+};
const COMMIT_ROWS = [
{
id: "commit-1",
@@ -153,6 +157,7 @@ const buildService = ({
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") })
),
@@ -182,12 +187,17 @@ const buildService = ({
Promise.resolve({ id, stepId: "step-1", approverUserId: "approver-1", createdAt: REVIEW_CREATED_AT, ...row })
)
},
- approvalPolicyDAL: { findStepsByPolicyId: vi.fn().mockResolvedValue(steps) },
+ 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,
@@ -197,7 +207,18 @@ const buildService = ({
})
)
},
- permissionService: { getProjectPermission: vi.fn().mockResolvedValue({ hasRole, permission: { can: vi.fn() } }) },
+ 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([]),
@@ -216,7 +237,8 @@ const buildService = ({
(rows) => Promise.resolve(rows.map((row, index) => ({ id: `commit-${index}`, ...row })))
),
insertApprovalSecretV2Tags: vi.fn().mockResolvedValue([]),
- findBySecretChangeIdBridgeSecretV2: vi.fn().mockResolvedValue(COMMIT_ROWS)
+ findBySecretChangeIdBridgeSecretV2: vi.fn().mockResolvedValue(COMMIT_ROWS),
+ findCommitsBySecretChangeIds: vi.fn().mockResolvedValue([])
},
secretChangePolicyBridgeService: { findSecretChangePolicyById: vi.fn().mockResolvedValue(policy) }
};
@@ -877,3 +899,487 @@ describe("secretChangeRequestBridge mergeSecretChangeRequest", () => {
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.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].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");
+ });
+});
diff --git a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.ts b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-service.ts
index 5073ee99eb..aa719f8b51 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,6 +1,6 @@
import { Knex } from "knex";
-import { ActionProjectType, ProjectMembershipRole } from "@app/db/schemas";
+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";
@@ -25,11 +25,12 @@ import {
resolveStepApproverUserIds,
upsertApprovalRequestStepDecision
} from "@app/services/approval-policy/approval-request-fns";
-import { ActorType } from "@app/services/auth/auth-type";
+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";
@@ -53,41 +54,71 @@ import { BypasserType } from "../access-approval-policy/access-approval-policy-t
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 } from "../secret-approval-request/secret-approval-request-types";
+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 { TSecretChangeRequestBridgeMethods } from "./secret-change-request-bridge-types";
+import {
+ TApprovalRequestUser,
+ TSecretChangeRequestBridgeMethods,
+ TSecretChangeRequestPolicySummary
+} from "./secret-change-request-bridge-types";
import { TSecretChangeRequestDALFactory } from "./secret-change-request-dal";
type TSecretChangeRequestBridgeServiceFactoryDep = {
approvalRequestDAL: Pick<
TApprovalRequestDALFactory,
- "findById" | "findByIdForUpdate" | "findStepsByRequestId" | "create" | "updateById" | "transaction"
+ | "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">;
- secretChangeRequestDAL: Pick<TSecretChangeRequestDALFactory, "create" | "findOne" | "updateById">;
+ approvalPolicyDAL: Pick<TApprovalPolicyDALFactory, "findStepsByPolicyId" | "findBypassersByPolicyIds">;
+ secretChangeRequestDAL: Pick<
+ TSecretChangeRequestDALFactory,
+ "create" | "findOne" | "updateById" | "findByProjectId" | "countByProjectId"
+ >;
secretApprovalRequestSecretDAL: Pick<
TSecretApprovalRequestSecretDALFactory,
- "insertV2Bridge" | "insertApprovalSecretV2Tags" | "updateV2ById" | "findBySecretChangeIdBridgeSecretV2"
+ | "insertV2Bridge"
+ | "insertApprovalSecretV2Tags"
+ | "updateV2ById"
+ | "findBySecretChangeIdBridgeSecretV2"
+ | "findCommitsBySecretChangeIds"
>;
+ membershipUserDAL: Pick<TMembershipUserDALFactory, "find">;
secretChangePolicyBridgeService: Pick<TSecretChangePolicyBridgeServiceFactory, "findSecretChangePolicyById">;
permissionService: Pick<TPermissionServiceFactory, "getProjectPermission">;
licenseService: Pick<TLicenseServiceFactory, "getPlan">;
@@ -142,6 +173,7 @@ export const secretChangeRequestBridgeServiceFactory = ({
approvalPolicyDAL,
secretChangeRequestDAL,
secretApprovalRequestSecretDAL,
+ membershipUserDAL,
secretChangePolicyBridgeService,
permissionService,
licenseService,
@@ -241,6 +273,49 @@ export const secretChangeRequestBridgeServiceFactory = ({
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 generateSecretChangeRequest: TSecretChangeRequestBridgeMethods["generateSecretChangeRequest"] = async (dto) => {
const { actor, actorId, actorOrgId, projectId, environment, secretPath, commitMessage, trx, skipPostProcessing } =
dto;
@@ -327,10 +402,6 @@ export const secretChangeRequestBridgeServiceFactory = ({
return result;
};
- const createSecretChangeRequest: TSecretChangeRequestBridgeMethods["createSecretChangeRequest"] = async () => {
- throw notAvailable();
- };
-
const mergeSecretChangeRequest: TSecretChangeRequestBridgeMethods["mergeSecretChangeRequest"] = async ({
approvalId,
actor,
@@ -360,33 +431,14 @@ export const secretChangeRequestBridgeServiceFactory = ({
const policy = await $findSecretChangePolicyOrThrow(approvalRequest.policyId);
const { projectId } = approvalRequest;
- const { hasRole, permission } = await permissionService.getProjectPermission({
- actor: ActorType.USER,
+ const { permission, steps, userGroupIds } = await $assertCanActOnRequest({
+ approvalRequest,
actorId,
- projectId,
actorAuthMethod,
actorOrgId,
- actionProjectType: ActionProjectType.SecretManager
+ action: "merge"
});
- const steps = await approvalRequestDAL.findStepsByRequestId(approvalRequest.id);
- const currentStep = steps.find((step) => step.stepNumber === approvalRequest.currentStep);
- if (!currentStep) {
- throw new BadRequestError({
- message: `Secret approval request with ID '${approvalId}' has no approval step to merge.`
- });
- }
-
- const userGroups = await userGroupMembershipDAL.findGroupMembershipsByUserIdInOrg(actorId, actorOrgId);
- const userGroupIds = new Set(userGroups.map((group) => group.groupId));
- if (
- !hasRole(ProjectMembershipRole.Admin) &&
- approvalRequest.requesterId !== actorId &&
- !isEligibleStepApprover(currentStep, actorId, userGroupIds)
- ) {
- throw new ForbiddenRequestError({ message: "User has insufficient privileges" });
- }
-
const stepApprovals = await Promise.all(
steps.map(async (step) => {
const eligibleUserIds = await resolveStepApproverUserIds(step, userGroupMembershipDAL);
@@ -559,33 +611,14 @@ export const secretChangeRequestBridgeServiceFactory = ({
});
}
- const { hasRole } = await permissionService.getProjectPermission({
- actor: ActorType.USER,
+ const { currentStep } = await $assertCanActOnRequest({
+ approvalRequest,
actorId,
- projectId: approvalRequest.projectId,
actorAuthMethod,
actorOrgId,
- actionProjectType: ActionProjectType.SecretManager
+ action: "review"
});
- const steps = await approvalRequestDAL.findStepsByRequestId(approvalRequest.id);
- const currentStep = steps.find((step) => step.stepNumber === approvalRequest.currentStep);
- if (!currentStep) {
- throw new BadRequestError({
- message: `Secret approval request with ID '${approvalId}' has no approval step to review.`
- });
- }
-
- const userGroups = await userGroupMembershipDAL.findGroupMembershipsByUserIdInOrg(actorId, actorOrgId);
- const userGroupIds = new Set(userGroups.map((group) => group.groupId));
- if (
- !hasRole(ProjectMembershipRole.Admin) &&
- approvalRequest.requesterId !== actorId &&
- !isEligibleStepApprover(currentStep, actorId, userGroupIds)
- ) {
- throw new ForbiddenRequestError({ message: "User has insufficient privileges" });
- }
-
const decision =
status === ApprovalStatus.APPROVED
? ApprovalRequestApprovalDecision.Approved
@@ -634,22 +667,303 @@ export const secretChangeRequestBridgeServiceFactory = ({
return { ...toSecretChangeRequestReview(review, approvalRequest.id), projectId: approvalRequest.projectId };
};
- const updateSecretChangeRequestStatus: TSecretChangeRequestBridgeMethods["updateSecretChangeRequestStatus"] =
- async () => {
- throw notAvailable();
+ 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
+ })
+ })
};
+ };
- const getSecretChangeRequestById: TSecretChangeRequestBridgeMethods["getSecretChangeRequestById"] = async () => {
- throw notAvailable();
+ // 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,
generateSecretChangeRequest,
- createSecretChangeRequest,
mergeSecretChangeRequest,
reviewSecretChangeRequest,
updateSecretChangeRequestStatus,
- getSecretChangeRequestById
+ getSecretChangeRequestById,
+ listSecretChangeRequests,
+ countSecretChangeRequests
};
};
diff --git a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-types.ts b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-types.ts
index ed5db3be23..c64dc59b3d 100644
--- a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-types.ts
+++ b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-bridge-types.ts
@@ -7,6 +7,8 @@ import {
} from "@app/db/schemas";
import { Actor, Event } from "@app/ee/services/audit-log/audit-log-types";
+import { TSecretApprovalRequestListFilter } from "../secret-approval-request/secret-approval-request-dal";
+import { TFormattedSecretApprovalCommitV2Bridge } from "../secret-approval-request/secret-approval-request-details-fns";
import { TMergedSecretsV2Bridge } from "../secret-approval-request/secret-approval-request-merge-fns";
import {
TCreateSecretApprovalRequestV2BridgeDTO,
@@ -34,6 +36,68 @@ export type TSecretChangeRequestMergeResult = {
requestedByActor?: Actor;
};
+export type TSecretChangeRequestStatusResult = Omit<TSecretChangeRequest, "commits"> & { projectId: string };
+
+export type TApprovalRequestUser = {
+ userId: string;
+ email?: string | null;
+ firstName?: string | null;
+ lastName?: string | null;
+ username: string;
+};
+
+export type TSecretChangeRequestPolicySummary = {
+ id: string;
+ name: string;
+ approvals: number;
+ secretPath: string | null;
+ enforcementLevel: string;
+ allowedSelfApprovals: boolean;
+ deletedAt: Date | null;
+};
+
+export type TSecretChangeRequestCommitter = {
+ committerUser: TApprovalRequestUser | null;
+ committerIdentity: { identityId: string; name: string } | null;
+};
+
+export type TSecretChangeRequestDetails = Omit<TSecretChangeRequest, "commits"> &
+ TSecretChangeRequestCommitter & {
+ projectId: string;
+ environment: string;
+ secretPath: string;
+ policy: TSecretChangeRequestPolicySummary & {
+ approvers: (TApprovalRequestUser & { isOrgMembershipActive: boolean | null })[];
+ bypassers: TApprovalRequestUser[];
+ };
+ statusChangedByUser?: TApprovalRequestUser;
+ reviewers: (TApprovalRequestUser & {
+ status: string;
+ comment: string;
+ createdAt: Date;
+ isOrgMembershipActive: boolean | null;
+ })[];
+ commits: TFormattedSecretApprovalCommitV2Bridge[];
+ };
+
+export type TSecretChangeRequestListItem = Omit<TSecretChangeRequest, "commits"> &
+ TSecretChangeRequestCommitter & {
+ projectId: string;
+ environment: string;
+ environmentName: string | null;
+ policy: TSecretChangeRequestPolicySummary & { approvers: { userId: string }[]; bypassers: { userId: string }[] };
+ reviewers: { userId: string; status: string }[];
+ commits: { op: string; secretId: string | null }[];
+ approvers: { userId: string }[];
+ bypassers: { userId: string }[];
+ };
+
+export type TSecretChangeRequestListResult = { approvals: TSecretChangeRequestListItem[]; totalCount: number };
+
+export type TSecretChangeRequestCount = { open: number; closed: number };
+
+export type TCountSecretChangeRequestsDTO = { projectId: string; userId?: string; policyId?: string };
+
export type TSecretChangeRequestBridgeMethods = {
generateSecretChangeRequest: (
dto: TGenerateSecretApprovalRequestV2BridgeDTO & { trx?: Knex; skipPostProcessing?: boolean }
@@ -41,6 +105,8 @@ export type TSecretChangeRequestBridgeMethods = {
createSecretChangeRequest: (dto: TCreateSecretApprovalRequestV2BridgeDTO, tx?: Knex) => Promise<never>;
mergeSecretChangeRequest: (dto: TMergeSecretApprovalRequestDTO) => Promise<TSecretChangeRequestMergeResult>;
reviewSecretChangeRequest: (dto: TReviewRequestDTO) => Promise<TSecretChangeRequestReview>;
- updateSecretChangeRequestStatus: (dto: TStatusChangeDTO) => Promise<never>;
- getSecretChangeRequestById: (dto: TSecretApprovalDetailsDTO) => Promise<never>;
+ updateSecretChangeRequestStatus: (dto: TStatusChangeDTO) => Promise<TSecretChangeRequestStatusResult>;
+ getSecretChangeRequestById: (dto: TSecretApprovalDetailsDTO) => Promise<TSecretChangeRequestDetails>;
+ listSecretChangeRequests: (filter: TSecretApprovalRequestListFilter) => Promise<TSecretChangeRequestListResult>;
+ countSecretChangeRequests: (dto: TCountSecretChangeRequestsDTO) => Promise<TSecretChangeRequestCount>;
};
diff --git a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-dal.ts b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-dal.ts
index 3935d0c750..4c22c8dc69 100644
--- a/backend/src/ee/services/secret-change-request-bridge/secret-change-request-dal.ts
+++ b/backend/src/ee/services/secret-change-request-bridge/secret-change-request-dal.ts
@@ -1,7 +1,239 @@
+import { Knex } from "knex";
+
import { TDbClient } from "@app/db";
-import { TableName } from "@app/db/schemas";
-import { ormify } from "@app/lib/knex";
+import { TableName, TApprovalRequests, TSecretChangeRequests } from "@app/db/schemas";
+import { DatabaseError } from "@app/lib/errors";
+import { sanitizeSqlLikeString } from "@app/lib/fn";
+import { ormify, selectAllTableCols } from "@app/lib/knex";
+import { ApprovalPolicyType } from "@app/services/approval-policy/approval-policy-enums";
+
+import {
+ applyRequestOrdering,
+ TSecretApprovalRequestListFilter
+} from "../secret-approval-request/secret-approval-request-dal";
+import { RequestState } from "../secret-approval-request/secret-approval-request-types";
export type TSecretChangeRequestDALFactory = ReturnType<typeof secretChangeRequestDALFactory>;
-export const secretChangeRequestDALFactory = (db: TDbClient) => ormify(db, TableName.SecretChangeRequests);
+export type TSecretChangeRequestListRow = TApprovalRequests &
+ Pick<
+ TSecretChangeRequests,
+ "folderId" | "slug" | "hasMerged" | "conflicts" | "commitMessage" | "bypassReason" | "statusChangedByUserId"
+ > & {
+ secretChangeId: string;
+ environment: string;
+ environmentName: string;
+ requestFolderPath: string;
+ policyName: string | null;
+ policyEnforcementLevel: string | null;
+ policyConstraints: unknown;
+ policySecretPath: string | null;
+ policyApprovals: number | null;
+ committerUserEmail: string | null;
+ committerUserUsername: string | null;
+ committerUserFirstName: string | null;
+ committerUserLastName: string | null;
+ committerIdentityName: string | null;
+ };
+
+export type TSecretChangeRequestListResultRows = { rows: TSecretChangeRequestListRow[]; totalCount: number };
+
+// A user without the project-wide read permission sees the requests they opened and the ones they can approve,
+// which on the global approval system is recorded per request step rather than on the policy.
+const buildAccessFilter = (qb: Knex.QueryBuilder, dbInstance: Knex, userId?: string) => {
+ if (!userId) return;
+ void qb.andWhere((bd) => {
+ void bd.where(`${TableName.ApprovalRequests}.requesterId`, userId).orWhereExists(
+ dbInstance(TableName.ApprovalRequestSteps)
+ .select(dbInstance.raw("1"))
+ .join(
+ TableName.ApprovalRequestStepEligibleApprovers,
+ `${TableName.ApprovalRequestSteps}.id`,
+ `${TableName.ApprovalRequestStepEligibleApprovers}.stepId`
+ )
+ .leftJoin(
+ TableName.UserGroupMembership,
+ `${TableName.ApprovalRequestStepEligibleApprovers}.groupId`,
+ `${TableName.UserGroupMembership}.groupId`
+ )
+ .whereRaw("?? = ??", [`${TableName.ApprovalRequestSteps}.requestId`, `${TableName.ApprovalRequests}.id`])
+ .andWhere((inner) => {
+ void inner
+ .where(`${TableName.ApprovalRequestStepEligibleApprovers}.userId`, userId)
+ .orWhere(`${TableName.UserGroupMembership}.userId`, userId);
+ })
+ );
+ });
+};
+
+const buildCoreQuery = (dbInstance: Knex, projectId: string) =>
+ dbInstance(TableName.ApprovalRequests)
+ .where(`${TableName.ApprovalRequests}.type`, ApprovalPolicyType.SecretChange)
+ .where(`${TableName.ApprovalRequests}.projectId`, projectId)
+ .join(
+ TableName.SecretChangeRequests,
+ `${TableName.SecretChangeRequests}.approvalRequestId`,
+ `${TableName.ApprovalRequests}.id`
+ )
+ .join(TableName.SecretFolder, `${TableName.SecretFolder}.id`, `${TableName.SecretChangeRequests}.folderId`)
+ .join(TableName.Environment, function joinActiveEnvForSecretFolder() {
+ this.on(`${TableName.SecretFolder}.envId`, `${TableName.Environment}.id`).andOnNull(
+ `${TableName.Environment}.deleteAfter`
+ );
+ })
+ .join(TableName.Project, `${TableName.Environment}.projectId`, `${TableName.Project}.id`)
+ .whereNull(`${TableName.Project}.deleteAfter`);
+
+export const secretChangeRequestDALFactory = (db: TDbClient) => {
+ const orm = ormify(db, TableName.SecretChangeRequests);
+
+ const findByProjectId = async (
+ {
+ projectId,
+ userId,
+ status,
+ environment,
+ committer,
+ limit = 20,
+ offset = 0,
+ search,
+ orderBy,
+ orderDirection
+ }: TSecretApprovalRequestListFilter,
+ tx?: Knex
+ ): Promise<TSecretChangeRequestListResultRows> => {
+ try {
+ const dbInstance = tx || db.replicaNode();
+ const innerQuery = buildCoreQuery(dbInstance, projectId)
+ .leftJoin(
+ TableName.ApprovalPolicies,
+ `${TableName.ApprovalPolicies}.id`,
+ `${TableName.ApprovalRequests}.policyId`
+ )
+ .leftJoin(TableName.ApprovalPolicySecretEnvironment, function joinPolicyEnvironment() {
+ this.on(`${TableName.ApprovalPolicySecretEnvironment}.policyId`, `${TableName.ApprovalPolicies}.id`).andOn(
+ `${TableName.ApprovalPolicySecretEnvironment}.envId`,
+ `${TableName.SecretFolder}.envId`
+ );
+ })
+ .leftJoin(db(TableName.ApprovalPolicySteps).as("firstPolicyStep"), function joinFirstPolicyStep() {
+ this.on("firstPolicyStep.policyId", `${TableName.ApprovalPolicies}.id`).andOnVal(
+ "firstPolicyStep.stepNumber",
+ "=",
+ 1
+ );
+ })
+ .leftJoin(
+ db(TableName.Users).as("committerUser"),
+ `${TableName.ApprovalRequests}.requesterId`,
+ "committerUser.id"
+ )
+ .leftJoin(
+ db(TableName.Identity).as("committerIdentity"),
+ `${TableName.ApprovalRequests}.machineIdentityId`,
+ "committerIdentity.id"
+ )
+ .where((qb) => {
+ if (environment) void qb.where(`${TableName.Environment}.slug`, environment);
+ if (status) void qb.where(`${TableName.ApprovalRequests}.status`, status);
+ if (committer) void qb.where(`${TableName.ApprovalRequests}.requesterId`, committer);
+ })
+ .modify((qb) => buildAccessFilter(qb, dbInstance, userId))
+ .select(selectAllTableCols(TableName.ApprovalRequests))
+ .select(
+ db.ref("id").withSchema(TableName.SecretChangeRequests).as("secretChangeId"),
+ db.ref("folderId").withSchema(TableName.SecretChangeRequests),
+ db.ref("slug").withSchema(TableName.SecretChangeRequests),
+ db.ref("hasMerged").withSchema(TableName.SecretChangeRequests),
+ db.ref("conflicts").withSchema(TableName.SecretChangeRequests),
+ db.ref("commitMessage").withSchema(TableName.SecretChangeRequests),
+ db.ref("bypassReason").withSchema(TableName.SecretChangeRequests),
+ db.ref("statusChangedByUserId").withSchema(TableName.SecretChangeRequests),
+ db.ref("slug").withSchema(TableName.Environment).as("environment"),
+ db.ref("name").withSchema(TableName.Environment).as("environmentName"),
+ db.ref("name").withSchema(TableName.SecretFolder).as("requestFolderPath"),
+ db.ref("name").withSchema(TableName.ApprovalPolicies).as("policyName"),
+ db.ref("enforcementLevel").withSchema(TableName.ApprovalPolicies).as("policyEnforcementLevel"),
+ db.ref("constraints").withSchema(TableName.ApprovalPolicies).as("policyConstraints"),
+ db.ref("secretPath").withSchema(TableName.ApprovalPolicySecretEnvironment).as("policySecretPath"),
+ db.ref("requiredApprovals").withSchema("firstPolicyStep").as("policyApprovals"),
+ db.ref("email").withSchema("committerUser").as("committerUserEmail"),
+ db.ref("username").withSchema("committerUser").as("committerUserUsername"),
+ db.ref("firstName").withSchema("committerUser").as("committerUserFirstName"),
+ db.ref("lastName").withSchema("committerUser").as("committerUserLastName"),
+ db.ref("name").withSchema("committerIdentity").as("committerIdentityName")
+ )
+ .as("inner");
+
+ const baseQuery = dbInstance.select("*").from(innerQuery);
+
+ if (search) {
+ const pattern = `%${sanitizeSqlLikeString(search)}%`;
+ void baseQuery.where((qb) => {
+ void qb
+ .whereRaw(`CONCAT_WS(' ', ??, ??) ilike ?`, [
+ db.ref("committerUserFirstName"),
+ db.ref("committerUserLastName"),
+ pattern
+ ])
+ .orWhereRaw(`?? ilike ?`, [db.ref("committerUserUsername"), pattern])
+ .orWhereRaw(`?? ilike ?`, [db.ref("committerUserEmail"), pattern])
+ .orWhereRaw(`?? ilike ?`, [db.ref("committerIdentityName"), pattern])
+ .orWhereILike("environmentName", pattern)
+ .orWhereILike("environment", pattern)
+ .orWhereILike("policySecretPath", pattern)
+ .orWhereILike("requestFolderPath", pattern)
+ .orWhereExists(
+ dbInstance(TableName.SecretApprovalRequestSecretV2)
+ .select(dbInstance.raw("1"))
+ .whereRaw("?? = ??", [
+ `${TableName.SecretApprovalRequestSecretV2}.secretChangeId`,
+ "inner.secretChangeId"
+ ])
+ .whereILike(`${TableName.SecretApprovalRequestSecretV2}.key`, pattern)
+ );
+ });
+ }
+
+ const pageQuery = applyRequestOrdering(baseQuery.clone(), orderBy, orderDirection)
+ .select(db.raw("COUNT(*) OVER () as total"))
+ .offset(offset)
+ .limit(limit);
+ const rows = (await pageQuery) as (TSecretChangeRequestListRow & { total: string })[];
+ let totalCount = Number(rows[0]?.total ?? 0);
+
+ if (!rows.length) {
+ const countResult = (await dbInstance
+ .count({ count: "*" })
+ .from(baseQuery.clone().as("count_query"))
+ .first()) as { count: string } | undefined;
+ totalCount = Number(countResult?.count ?? 0);
+ }
+
+ return { rows: rows.map(({ total, ...row }) => row), totalCount };
+ } catch (error) {
+ throw new DatabaseError({ error, name: "FindSecretChangeRequestsByProjectId" });
+ }
+ };
+
+ const countByProjectId = async (projectId: string, userId?: string, policyId?: string, tx?: Knex) => {
+ try {
+ const dbInstance = tx || db.replicaNode();
+ const rows = (await buildCoreQuery(dbInstance, projectId)
+ .where((qb) => {
+ if (policyId) void qb.where(`${TableName.ApprovalRequests}.policyId`, policyId);
+ })
+ .modify((qb) => buildAccessFilter(qb, dbInstance, userId))
+ .select(`${TableName.ApprovalRequests}.status`)
+ .count(`${TableName.ApprovalRequests}.id as count`)
+ .groupBy(`${TableName.ApprovalRequests}.status`)) as { status: string; count: string }[];
+
+ const countOf = (state: RequestState) => parseInt(rows.find((row) => row.status === state)?.count || "0", 10);
+ return { open: countOf(RequestState.Open), closed: countOf(RequestState.Closed) };
+ } catch (error) {
+ throw new DatabaseError({ error, name: "CountSecretChangeRequestsByProjectId" });
+ }
+ };
+
+ return { ...orm, findByProjectId, countByProjectId };
+};
diff --git a/backend/src/server/routes/index.ts b/backend/src/server/routes/index.ts
index 2882127371..20c80b57cb 100644
--- a/backend/src/server/routes/index.ts
+++ b/backend/src/server/routes/index.ts
@@ -2375,6 +2375,7 @@ export const registerRoutes = async (
const secretChangeRequestBridgeService = secretChangeRequestBridgeServiceFactory({
approvalRequestDAL,
+ membershipUserDAL,
approvalRequestStepsDAL,
approvalRequestStepEligibleApproversDAL,
approvalRequestApprovalsDAL,
diff --git a/backend/src/services/approval-policy/approval-request-dal.ts b/backend/src/services/approval-policy/approval-request-dal.ts
index 7728745812..60d4a38cfa 100644
--- a/backend/src/services/approval-policy/approval-request-dal.ts
+++ b/backend/src/services/approval-policy/approval-request-dal.ts
@@ -17,51 +17,72 @@ export type TApprovalRequestDALFactory = ReturnType<typeof approvalRequestDALFac
export const approvalRequestDALFactory = (db: TDbClient) => {
const orm = ormify(db, TableName.ApprovalRequests);
- const findStepsByRequestId = async (requestId: string, tx?: Knex) => {
- try {
- const dbInstance = tx || db.replicaNode();
- const steps = await dbInstance(TableName.ApprovalRequestSteps).where({ requestId }).orderBy("stepNumber", "asc");
+ const $attachStepRelations = async (steps: TApprovalRequestSteps[], dbInstance: Knex) => {
+ if (!steps.length) {
+ return [];
+ }
- if (!steps.length) {
- return [];
- }
+ const stepIds = steps.map((step) => step.id);
+
+ const [approvers, approvals] = await Promise.all([
+ dbInstance(TableName.ApprovalRequestStepEligibleApprovers)
+ .whereIn("stepId", stepIds)
+ .select("stepId", "userId", "groupId"),
+ dbInstance(TableName.ApprovalRequestApprovals).whereIn("stepId", stepIds)
+ ]);
+
+ const approversByStepId = approvers.reduce<Record<string, { type: ApproverType; id: string }[]>>(
+ (acc, approver) => {
+ const stepApprovers = acc[approver.stepId] || [];
+ stepApprovers.push({
+ type: approver.userId ? ApproverType.User : ApproverType.Group,
+ id: (approver.userId || approver.groupId) as string
+ });
+ acc[approver.stepId] = stepApprovers;
+ return acc;
+ },
+ {}
+ );
+
+ const approvalsByStepId = approvals.reduce<Record<string, TApprovalRequestApprovals[]>>((acc, approval) => {
+ const stepApprovals = acc[approval.stepId] || [];
+ stepApprovals.push(approval);
+ acc[approval.stepId] = stepApprovals;
+ return acc;
+ }, {});
+
+ return steps.map((step) => ({
+ ...step,
+ approvers: approversByStepId[step.id] || [],
+ approvals: approvalsByStepId[step.id] || []
+ }));
+ };
- const stepIds = steps.map((step) => step.id);
-
- const [approvers, approvals] = await Promise.all([
- dbInstance(TableName.ApprovalRequestStepEligibleApprovers)
- .whereIn("stepId", stepIds)
- .select("stepId", "userId", "groupId"),
- dbInstance(TableName.ApprovalRequestApprovals).whereIn("stepId", stepIds)
- ]);
-
- const approversByStepId = approvers.reduce<Record<string, { type: ApproverType; id: string }[]>>(
- (acc, approver) => {
- const stepApprovers = acc[approver.stepId] || [];
- stepApprovers.push({
- type: approver.userId ? ApproverType.User : ApproverType.Group,
- id: (approver.userId || approver.groupId) as string
- });
- acc[approver.stepId] = stepApprovers;
- return acc;
- },
- {}
- );
+ const findStepsByRequestIds = async (requestIds: string[], tx?: Knex) => {
+ try {
+ if (!requestIds.length) return {};
+ const dbInstance = tx || db.replicaNode();
+ const steps = await dbInstance(TableName.ApprovalRequestSteps)
+ .whereIn("requestId", requestIds)
+ .orderBy("stepNumber", "asc");
+ const stepsWithRelations = await $attachStepRelations(steps, dbInstance);
- const approvalsByStepId = approvals.reduce<Record<string, TApprovalRequestApprovals[]>>((acc, approval) => {
- const stepApprovals = acc[approval.stepId] || [];
- stepApprovals.push(approval);
- acc[approval.stepId] = stepApprovals;
+ return stepsWithRelations.reduce<Record<string, typeof stepsWithRelations>>((acc, step) => {
+ const requestSteps = acc[step.requestId] || [];
+ requestSteps.push(step);
+ acc[step.requestId] = requestSteps;
return acc;
}, {});
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find approval request steps by request ids" });
+ }
+ };
- return steps.map((step) => {
- return {
- ...step,
- approvers: approversByStepId[step.id] || [],
- approvals: approvalsByStepId[step.id] || []
- };
- });
+ const findStepsByRequestId = async (requestId: string, tx?: Knex) => {
+ try {
+ const dbInstance = tx || db.replicaNode();
+ const steps = await dbInstance(TableName.ApprovalRequestSteps).where({ requestId }).orderBy("stepNumber", "asc");
+ return await $attachStepRelations(steps, dbInstance);
} catch (error) {
throw new DatabaseError({ error, name: "Find approval request steps" });
}
@@ -93,63 +114,10 @@ export const approvalRequestDALFactory = (db: TDbClient) => {
return [];
}
- const requestIds = requests.map((req) => req.id);
-
- const steps = await dbInstance(TableName.ApprovalRequestSteps)
- .whereIn("requestId", requestIds)
- .orderBy("stepNumber", "asc");
-
- const stepsByRequestId: Record<
- string,
- (TApprovalRequestSteps & {
- approvers: { type: ApproverType; id: string }[];
- approvals: TApprovalRequestApprovals[];
- })[]
- > = {};
-
- if (steps.length) {
- const stepIds = steps.map((step) => step.id);
-
- const [approvers, approvals] = await Promise.all([
- dbInstance(TableName.ApprovalRequestStepEligibleApprovers)
- .whereIn("stepId", stepIds)
- .select("stepId", "userId", "groupId"),
- dbInstance(TableName.ApprovalRequestApprovals).whereIn("stepId", stepIds)
- ]);
-
- const approversByStepId = approvers.reduce<Record<string, { type: ApproverType; id: string }[]>>(
- (acc, approver) => {
- const stepApprovers = acc[approver.stepId] || [];
- stepApprovers.push({
- type: approver.userId ? ApproverType.User : ApproverType.Group,
- id: (approver.userId || approver.groupId) as string
- });
- acc[approver.stepId] = stepApprovers;
- return acc;
- },
- {}
- );
-
- const approvalsByStepId = approvals.reduce<Record<string, TApprovalRequestApprovals[]>>((acc, approval) => {
- const stepApprovals = acc[approval.stepId] || [];
- stepApprovals.push(approval);
- acc[approval.stepId] = stepApprovals;
- return acc;
- }, {});
-
- steps.forEach((step) => {
- const formattedStep = {
- ...step,
- approvers: approversByStepId[step.id] || [],
- approvals: approvalsByStepId[step.id] || []
- };
-
- if (!stepsByRequestId[step.requestId]) {
- stepsByRequestId[step.requestId] = [];
- }
- stepsByRequestId[step.requestId].push(formattedStep);
- });
- }
+ const stepsByRequestId = await findStepsByRequestIds(
+ requests.map((req) => req.id),
+ dbInstance
+ );
return requests.map((req) => ({
...req,
@@ -186,6 +154,7 @@ export const approvalRequestDALFactory = (db: TDbClient) => {
return {
...orm,
findStepsByRequestId,
+ findStepsByRequestIds,
findByProjectId,
findByIdForUpdate,
markExpiredRequests