Skip to content

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

feat: add requests UI and retry mechanism

adilson45e87bc4b1b6
diff --git a/CLAUDE.md b/CLAUDE.md
index 8f5f1fe0f6..3489d0c78f 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -162,7 +162,11 @@ Delivery to the delegated system is asynchronous and lives in `delegated-approva
bridge creates the `delegated_approval_requests` row inside the request's own transaction and enqueues the
`DelegatedApprovalDispatch` job after commit; the worker moves the row `pending_dispatch` → `waiting_approval` (storing the provider's record id in
`providerRequestId`) or `failed_dispatch` with a `statusReason` a user can read, and BullMQ retries put it back
-to `pending_dispatch`. Every provider implements `TDelegatedApprovalProvider` against the same
+to `pending_dispatch`. A user resends a `failed_dispatch` request with
+`POST /api/v1/access-approvals/requests/:requestId/retry-delegated-dispatch`. The product's bridge checks who may
+retry, and `delegatedApprovalService.retryDispatch` checks the request can be retried and only re-enqueues the
+fixed-id dispatch job: the worker stays the only writer of the status, so a retry cannot run beside an attempt
+BullMQ already has scheduled, and a retry that loses that race leaves the row retryable. Every provider implements `TDelegatedApprovalProvider` against the same
`TDelegatedApprovalDispatchInput` and registers in `DELEGATED_APPROVAL_PROVIDER_MAP`
(`dispatch/providers/<name>/`); a new policy type adds an arm to `TDelegatedApprovalDispatchDetails` and a
builder in `DELEGATED_APPROVAL_DISPATCH_DETAILS_BUILDER_MAP` rather than branching in a provider. The worker
diff --git a/backend/src/ee/routes/v1/access-approval-request-router.ts b/backend/src/ee/routes/v1/access-approval-request-router.ts
index c5bce91ce1..53cb012afe 100644
--- a/backend/src/ee/routes/v1/access-approval-request-router.ts
+++ b/backend/src/ee/routes/v1/access-approval-request-router.ts
@@ -9,6 +9,10 @@ import { getTelemetryDistinctId } from "@app/server/lib/telemetry";
import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
import { SanitizedUserSchema } from "@app/server/routes/sanitizedSchemas";
import { AuthMode } from "@app/services/auth/auth-type";
+import {
+ DelegatedApprovalRequestSchema,
+ DelegatedApprovalSchema
+} from "@app/services/delegated-approval/delegated-approval-schemas";
import { PostHogEventTypes } from "@app/services/telemetry/telemetry-types";
const approvalRequestUser = z.object({ userId: z.string() }).merge(
@@ -188,8 +192,10 @@ export const registerAccessApprovalRequestRouter = async (server: FastifyZodProv
deletedAt: z.date().nullish(),
allowedSelfApprovals: z.boolean(),
maxTimePeriod: z.string().nullable().optional(),
- requestExpirationTime: z.string().nullable().optional()
+ requestExpirationTime: z.string().nullable().optional(),
+ delegatedApproval: DelegatedApprovalSchema.pick({ type: true }).nullable().optional()
}),
+ delegatedApproval: DelegatedApprovalRequestSchema.nullable().optional(),
reviewers: z
.object({
isOrgMembershipActive: z.boolean().nullable().optional(),
@@ -328,6 +334,52 @@ export const registerAccessApprovalRequestRouter = async (server: FastifyZodProv
}
});
+ server.route({
+ url: "/:requestId/retry-delegated-dispatch",
+ method: "POST",
+ config: {
+ rateLimit: writeLimit
+ },
+ schema: {
+ operationId: "retryAccessApprovalRequestDelegatedDispatch",
+ params: z.object({
+ requestId: z.string().uuid()
+ }),
+ response: {
+ 200: z.object({
+ request: AccessApprovalRequestsSchema
+ })
+ }
+ },
+ onRequest: verifyAuth([AuthMode.JWT]),
+ handler: async (req) => {
+ const result = await server.services.accessApprovalRequest.retryDelegatedApprovalDispatch({
+ requestId: req.params.requestId,
+ actor: req.permission.type,
+ actorId: req.permission.id,
+ actorOrgId: req.permission.orgId,
+ actorAuthMethod: req.permission.authMethod
+ });
+
+ await server.services.auditLog.createAuditLog({
+ ...req.auditLogInfo,
+ orgId: req.permission.orgId,
+ projectId: result.projectId,
+ event: {
+ type: EventType.ACCESS_APPROVAL_REQUEST_DELEGATED_DISPATCH_RETRY,
+ metadata: {
+ requestId: result.request.id,
+ requestedByUserId: result.request.requestedByUserId,
+ policyId: result.request.policyId,
+ delegatedApprovalType: result.delegatedApprovalType
+ }
+ }
+ });
+
+ return { request: result.request };
+ }
+ });
+
server.route({
url: "/:requestId",
method: "PATCH",
diff --git a/backend/src/ee/services/access-approval-request/access-approval-request-service.ts b/backend/src/ee/services/access-approval-request/access-approval-request-service.ts
index 20ee3a5fc7..422acec93d 100644
--- a/backend/src/ee/services/access-approval-request/access-approval-request-service.ts
+++ b/backend/src/ee/services/access-approval-request/access-approval-request-service.ts
@@ -85,6 +85,7 @@ type TSecretApprovalRequestServiceFactoryDep = {
| "isGlobalAccessApprovalRequest"
| "reviewAccessApprovalRequest"
| "revokeAccessApprovalRequest"
+ | "retryDelegatedApprovalDispatch"
>;
accessApprovalRequestReviewerDAL: Pick<
TAccessApprovalRequestReviewerDALFactory,
@@ -1165,6 +1166,23 @@ export const accessApprovalRequestServiceFactory = ({
};
};
+ const retryDelegatedApprovalDispatch: TAccessApprovalRequestServiceFactory["retryDelegatedApprovalDispatch"] =
+ async ({ requestId, actor, actorId, actorOrgId, actorAuthMethod }) => {
+ if (await secretAccessApprovalGlobalRequestBridge.isGlobalAccessApprovalRequest(requestId)) {
+ return secretAccessApprovalGlobalRequestBridge.retryDelegatedApprovalDispatch({
+ requestId,
+ actor,
+ actorId,
+ actorOrgId,
+ actorAuthMethod
+ });
+ }
+
+ throw new BadRequestError({
+ message: `Access request with ID '${requestId}' is not reviewed in an external approval system`
+ });
+ };
+
const revokeAccessRequest: TAccessApprovalRequestServiceFactory["revokeAccessRequest"] = async ({
requestId,
actor,
@@ -1329,6 +1347,7 @@ export const accessApprovalRequestServiceFactory = ({
listApprovalRequests,
reviewAccessRequest,
revokeAccessRequest,
+ retryDelegatedApprovalDispatch,
getCount
};
};
diff --git a/backend/src/ee/services/access-approval-request/access-approval-request-types.ts b/backend/src/ee/services/access-approval-request/access-approval-request-types.ts
index a7fb54820e..fa6563d9a2 100644
--- a/backend/src/ee/services/access-approval-request/access-approval-request-types.ts
+++ b/backend/src/ee/services/access-approval-request/access-approval-request-types.ts
@@ -1,4 +1,8 @@
import { TProjectPermission } from "@app/lib/types";
+import {
+ DelegatedApprovalPolicyType,
+ DelegatedApprovalRequestStatus
+} from "@app/services/delegated-approval/delegated-approval-enums";
export enum ApprovalStatus {
PENDING = "pending",
@@ -35,6 +39,10 @@ export type TRevokeAccessRequestDTO = {
requestId: string;
} & Omit<TProjectPermission, "projectId">;
+export type TRetryDelegatedApprovalDispatchDTO = {
+ requestId: string;
+} & Omit<TProjectPermission, "projectId">;
+
export type TUpdateAccessApprovalRequestDTO = {
requestId: string;
temporaryRange: string;
@@ -118,7 +126,9 @@ export interface TAccessApprovalRequestServiceFactory {
deletedAt: Date | null | undefined;
maxTimePeriod?: string | null;
requestExpirationTime?: string | null;
+ delegatedApproval?: { type: DelegatedApprovalPolicyType } | null;
};
+ delegatedApproval?: { status: DelegatedApprovalRequestStatus; statusReason: string | null } | null;
projectId: string;
environment: string;
environmentName: string;
@@ -212,6 +222,24 @@ export interface TAccessApprovalRequestServiceFactory {
finalizedCount: number;
};
}>;
+ retryDelegatedApprovalDispatch: (arg: TRetryDelegatedApprovalDispatchDTO) => Promise<{
+ request: {
+ status: string;
+ id: string;
+ createdAt: Date;
+ updatedAt: Date;
+ policyId: string;
+ isTemporary: boolean;
+ requestedByUserId: string;
+ privilegeId?: string | null | undefined;
+ temporaryRange?: string | null | undefined;
+ permissions?: unknown;
+ note?: string | null | undefined;
+ expiresAt?: Date | null | undefined;
+ };
+ projectId: string;
+ delegatedApprovalType: DelegatedApprovalPolicyType;
+ }>;
revokeAccessRequest: (arg: TRevokeAccessRequestDTO) => Promise<{
request: {
status: string;
diff --git a/backend/src/ee/services/audit-log/audit-log-types.ts b/backend/src/ee/services/audit-log/audit-log-types.ts
index 30faead9fb..2bf15fbf3a 100644
--- a/backend/src/ee/services/audit-log/audit-log-types.ts
+++ b/backend/src/ee/services/audit-log/audit-log-types.ts
@@ -851,6 +851,7 @@ export enum EventType {
ACCESS_APPROVAL_REQUEST_CREATE = "access-approval-request-create",
ACCESS_APPROVAL_REQUEST_REVIEW = "access-approval-request-review",
ACCESS_APPROVAL_REQUEST_REVOKE = "access-approval-request-revoke",
+ ACCESS_APPROVAL_REQUEST_DELEGATED_DISPATCH_RETRY = "access-approval-request-delegated-dispatch-retry",
ACCESS_APPROVAL_REQUEST_UPDATE = "access-approval-request-update",
VIEW_AUDIT_LOGS = "view-audit-logs",
@@ -7136,6 +7137,16 @@ interface AccessApprovalRequestRevokeEvent {
};
}
+interface AccessApprovalRequestDelegatedDispatchRetryEvent {
+ type: EventType.ACCESS_APPROVAL_REQUEST_DELEGATED_DISPATCH_RETRY;
+ metadata: {
+ requestId: string;
+ requestedByUserId: string;
+ policyId: string;
+ delegatedApprovalType: string;
+ };
+}
+
interface AccessApprovalRequestUpdateEvent {
type: EventType.ACCESS_APPROVAL_REQUEST_UPDATE;
metadata: {
@@ -8617,6 +8628,7 @@ export type Event =
| AccessApprovalRequestCreateEvent
| AccessApprovalRequestReviewEvent
| AccessApprovalRequestRevokeEvent
+ | AccessApprovalRequestDelegatedDispatchRetryEvent
| AccessApprovalRequestUpdateEvent
| CreateAcmeAccountEvent
| RetrieveAcmeAccountEvent
diff --git a/backend/src/server/routes/index.ts b/backend/src/server/routes/index.ts
index 68ca86b958..0a7cb16ec7 100644
--- a/backend/src/server/routes/index.ts
+++ b/backend/src/server/routes/index.ts
@@ -3242,14 +3242,6 @@ export const registerRoutes = async (
keyStore
});
- const delegatedApprovalService = delegatedApprovalServiceFactory({
- delegatedApprovalPolicyDAL,
- delegatedApprovalRequestDAL,
- approvalPolicyDAL,
- appConnectionDAL,
- appConnectionService
- });
-
const delegatedApprovalCallbackService = delegatedApprovalCallbackServiceFactory({
delegatedApprovalRequestDAL,
kmsService
@@ -3266,6 +3258,15 @@ export const registerRoutes = async (
queueService
});
+ const delegatedApprovalService = delegatedApprovalServiceFactory({
+ delegatedApprovalPolicyDAL,
+ delegatedApprovalRequestDAL,
+ approvalPolicyDAL,
+ appConnectionDAL,
+ appConnectionService,
+ delegatedApprovalDispatchQueue
+ });
+
const secretAccessApprovalGlobalRequestBridgeService = secretAccessApprovalGlobalRequestBridgeServiceFactory({
projectDAL,
projectEnvDAL,
diff --git a/backend/src/services/delegated-approval/delegated-approval-schemas.ts b/backend/src/services/delegated-approval/delegated-approval-schemas.ts
index 437ebd29a4..c1245e60d7 100644
--- a/backend/src/services/delegated-approval/delegated-approval-schemas.ts
+++ b/backend/src/services/delegated-approval/delegated-approval-schemas.ts
@@ -1,6 +1,6 @@
import { z } from "zod";
-import { DelegatedApprovalPolicyType } from "./delegated-approval-enums";
+import { DelegatedApprovalPolicyType, DelegatedApprovalRequestStatus } from "./delegated-approval-enums";
export const DelegatedApprovalSchema = z.object({
type: z
@@ -8,3 +8,13 @@ export const DelegatedApprovalSchema = z.object({
.describe("The delegated approval system that reviews requests made against this policy."),
connectionId: z.string().uuid().describe("The ID of the App Connection used to reach the delegated approval system.")
});
+
+export const DelegatedApprovalRequestSchema = z.object({
+ status: z
+ .nativeEnum(DelegatedApprovalRequestStatus)
+ .describe("Where the request stands in the delegated approval system that reviews it."),
+ statusReason: z
+ .string()
+ .nullable()
+ .describe("Why the request could not be sent to the delegated approval system, when it could not.")
+});
diff --git a/backend/src/services/delegated-approval/delegated-approval-service.test.ts b/backend/src/services/delegated-approval/delegated-approval-service.test.ts
new file mode 100644
index 0000000000..3a6871befc
--- /dev/null
+++ b/backend/src/services/delegated-approval/delegated-approval-service.test.ts
@@ -0,0 +1,98 @@
+import { describe, expect, test, vi } from "vitest";
+
+import { BadRequestError } from "@app/lib/errors";
+import { ApprovalRequestStatus } from "@app/services/approval-policy/approval-policy-enums";
+
+import { DelegatedApprovalPolicyType, DelegatedApprovalRequestStatus } from "./delegated-approval-enums";
+import { delegatedApprovalServiceFactory } from "./delegated-approval-service";
+
+const failedRequest = { id: "delegated-1", requestId: "req-1", status: DelegatedApprovalRequestStatus.FailedDispatch };
+const serviceNowPolicy = {
+ id: "delegated-policy-1",
+ policyId: "policy-1",
+ type: DelegatedApprovalPolicyType.ServiceNow
+};
+const pendingApprovalRequest = {
+ id: "req-1",
+ policyId: "policy-1",
+ status: ApprovalRequestStatus.Pending,
+ expiresAt: null
+};
+
+const createService = ({
+ delegatedRequest = failedRequest as unknown,
+ delegatedPolicy = serviceNowPolicy as unknown
+} = {}) => {
+ const queueDispatch = vi.fn().mockResolvedValue(undefined);
+ const service = delegatedApprovalServiceFactory({
+ delegatedApprovalRequestDAL: { findOne: vi.fn().mockResolvedValue(delegatedRequest) },
+ delegatedApprovalPolicyDAL: { findOne: vi.fn().mockResolvedValue(delegatedPolicy) },
+ delegatedApprovalDispatchQueue: { queueDispatch }
+ } as never);
+ return { service, queueDispatch };
+};
+
+describe("delegatedApprovalService.retryDispatch", () => {
+ test("re-enqueues a pending request that failed to reach the delegated system", async () => {
+ const { service, queueDispatch } = createService();
+
+ await expect(service.retryDispatch({ approvalRequest: pendingApprovalRequest })).resolves.toEqual({
+ delegatedRequest: failedRequest,
+ delegatedPolicy: serviceNowPolicy
+ });
+ expect(queueDispatch).toHaveBeenCalledWith({ delegatedRequestId: "delegated-1" });
+ });
+
+ test("refuses a request without a delegated approval", async () => {
+ const { service, queueDispatch } = createService({ delegatedRequest: null });
+
+ await expect(service.retryDispatch({ approvalRequest: pendingApprovalRequest })).rejects.toThrow(
+ new BadRequestError({ message: "Request with ID 'req-1' is not reviewed in an external approval system" })
+ );
+ expect(queueDispatch).not.toHaveBeenCalled();
+ });
+
+ test("refuses a request that is no longer pending", async () => {
+ const { service, queueDispatch } = createService();
+
+ await expect(
+ service.retryDispatch({
+ approvalRequest: { ...pendingApprovalRequest, status: ApprovalRequestStatus.Cancelled }
+ })
+ ).rejects.toThrow("Only pending requests can be sent again");
+ expect(queueDispatch).not.toHaveBeenCalled();
+ });
+
+ test("refuses an expired request", async () => {
+ const { service, queueDispatch } = createService();
+
+ await expect(
+ service.retryDispatch({
+ approvalRequest: { ...pendingApprovalRequest, expiresAt: new Date("2020-01-01T00:00:00.000Z") }
+ })
+ ).rejects.toThrow("This request has expired. Create a new request instead.");
+ expect(queueDispatch).not.toHaveBeenCalled();
+ });
+
+ test("refuses a request whose policy no longer delegates approval", async () => {
+ const { service, queueDispatch } = createService({ delegatedPolicy: null });
+
+ await expect(service.retryDispatch({ approvalRequest: pendingApprovalRequest })).rejects.toThrow(
+ "The policy for this request no longer uses an external approval system. Create a new request instead."
+ );
+ expect(queueDispatch).not.toHaveBeenCalled();
+ });
+
+ test.each([
+ DelegatedApprovalRequestStatus.PendingDispatch,
+ DelegatedApprovalRequestStatus.WaitingApproval,
+ DelegatedApprovalRequestStatus.Approved
+ ])("refuses a request in the %s state", async (status) => {
+ const { service, queueDispatch } = createService({ delegatedRequest: { ...failedRequest, status } });
+
+ await expect(service.retryDispatch({ approvalRequest: pendingApprovalRequest })).rejects.toThrow(
+ "Only requests that failed to reach ServiceNow can be sent again"
+ );
+ expect(queueDispatch).not.toHaveBeenCalled();
+ });
+});
diff --git a/backend/src/services/delegated-approval/delegated-approval-service.ts b/backend/src/services/delegated-approval/delegated-approval-service.ts
index c4f164dedd..f4aa21d3c5 100644
--- a/backend/src/services/delegated-approval/delegated-approval-service.ts
+++ b/backend/src/services/delegated-approval/delegated-approval-service.ts
@@ -9,6 +9,7 @@ import { AppConnection } from "@app/services/app-connection/app-connection-enums
import { APP_CONNECTION_NAME_MAP } from "@app/services/app-connection/app-connection-maps";
import { TAppConnectionServiceFactory } from "@app/services/app-connection/app-connection-service";
import { TApprovalPolicyDALFactory } from "@app/services/approval-policy/approval-policy-dal";
+import { ApprovalRequestStatus } from "@app/services/approval-policy/approval-policy-enums";
import { DelegatedApprovalPolicyType, DelegatedApprovalRequestStatus } from "./delegated-approval-enums";
import { assertPolicyTypeSupportsDelegatedApproval, listDelegatedApprovalOptions } from "./delegated-approval-fns";
@@ -20,10 +21,12 @@ import {
TCreateDelegatedApprovalRequestDTO,
TDelegatedApprovalPolicy,
TDelegatedApprovalRequest,
+ TRetryDelegatedApprovalRequestDispatchDTO,
TUpdateDelegatedApprovalPolicyDTO,
TUpdateDelegatedApprovalRequestDTO,
TValidateDelegatedApprovalConnectionDTO
} from "./delegated-approval-types";
+import { TDelegatedApprovalDispatchQueueFactory } from "./dispatch/delegated-approval-dispatch-queue";
type TDelegatedApprovalServiceFactoryDep = {
delegatedApprovalPolicyDAL: TDelegatedApprovalPolicyDALFactory;
@@ -31,6 +34,7 @@ type TDelegatedApprovalServiceFactoryDep = {
approvalPolicyDAL: Pick<TApprovalPolicyDALFactory, "findById">;
appConnectionDAL: Pick<TAppConnectionDALFactory, "findById">;
appConnectionService: Pick<TAppConnectionServiceFactory, "validateAppConnectionUsageById">;
+ delegatedApprovalDispatchQueue: Pick<TDelegatedApprovalDispatchQueueFactory, "queueDispatch">;
};
export type TDelegatedApprovalServiceFactory = ReturnType<typeof delegatedApprovalServiceFactory>;
@@ -40,7 +44,8 @@ export const delegatedApprovalServiceFactory = ({
delegatedApprovalRequestDAL,
approvalPolicyDAL,
appConnectionDAL,
- appConnectionService
+ appConnectionService,
+ delegatedApprovalDispatchQueue
}: TDelegatedApprovalServiceFactoryDep) => {
const $assertConnectionMatches = async (
{
@@ -177,6 +182,46 @@ export const delegatedApprovalServiceFactory = ({
return (request as TDelegatedApprovalRequest | undefined) ?? null;
};
+ const getRequestsByRequestIds = async (requestIds: string[], tx?: Knex) => {
+ if (!requestIds.length) return [];
+ const requests = await delegatedApprovalRequestDAL.find({ $in: { requestId: requestIds } }, { tx });
+ return requests as TDelegatedApprovalRequest[];
+ };
+
+ const retryDispatch = async ({ approvalRequest }: TRetryDelegatedApprovalRequestDispatchDTO) => {
+ const delegatedRequest = await getRequestByRequestId(approvalRequest.id);
+ if (!delegatedRequest) {
+ throw new BadRequestError({
+ message: `Request with ID '${approvalRequest.id}' is not reviewed in an external approval system`
+ });
+ }
+
+ if (approvalRequest.status !== ApprovalRequestStatus.Pending) {
+ throw new BadRequestError({ message: "Only pending requests can be sent again" });
+ }
+
+ if (approvalRequest.expiresAt && new Date(approvalRequest.expiresAt) < new Date()) {
+ throw new BadRequestError({ message: "This request has expired. Create a new request instead." });
+ }
+
+ const delegatedPolicy = approvalRequest.policyId ? await getPolicyByPolicyId(approvalRequest.policyId) : null;
+ if (!delegatedPolicy) {
+ throw new BadRequestError({
+ message: "The policy for this request no longer uses an external approval system. Create a new request instead."
+ });
+ }
+
+ if (delegatedRequest.status !== DelegatedApprovalRequestStatus.FailedDispatch) {
+ throw new BadRequestError({
+ message: `Only requests that failed to reach ${DELEGATED_APPROVAL_NAME_MAP[delegatedPolicy.type]} can be sent again`
+ });
+ }
+
+ await delegatedApprovalDispatchQueue.queueDispatch({ delegatedRequestId: delegatedRequest.id });
+
+ return { delegatedRequest, delegatedPolicy };
+ };
+
const updateRequest = async ({ requestId, status, statusReason }: TUpdateDelegatedApprovalRequestDTO, tx?: Knex) => {
const patch = {
...(status !== undefined && { status }),
@@ -214,6 +259,8 @@ export const delegatedApprovalServiceFactory = ({
deletePolicyByPolicyId,
createRequest,
getRequestByRequestId,
+ getRequestsByRequestIds,
+ retryDispatch,
updateRequest,
deleteRequestByRequestId
};
diff --git a/backend/src/services/delegated-approval/delegated-approval-types.ts b/backend/src/services/delegated-approval/delegated-approval-types.ts
index acceae0f47..74f3bf714e 100644
--- a/backend/src/services/delegated-approval/delegated-approval-types.ts
+++ b/backend/src/services/delegated-approval/delegated-approval-types.ts
@@ -44,6 +44,10 @@ export type TCreateDelegatedApprovalRequestDTO = {
statusReason?: string | null;
};
+export type TRetryDelegatedApprovalRequestDispatchDTO = {
+ approvalRequest: Pick<TApprovalRequests, "id" | "policyId" | "status" | "expiresAt">;
+};
+
export type TUpdateDelegatedApprovalRequestDTO = {
requestId: string;
status?: DelegatedApprovalRequestStatus;
diff --git a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.test.ts b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.test.ts
index 22ecc5da66..ee0de1ceb8 100644
--- a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.test.ts
+++ b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.test.ts
@@ -9,6 +9,10 @@ import {
ApprovalRequestStatus,
ApproverType
} from "@app/services/approval-policy/approval-policy-enums";
+import {
+ DelegatedApprovalPolicyType,
+ DelegatedApprovalRequestStatus
+} from "@app/services/delegated-approval/delegated-approval-enums";
import {
collectSecretAccessRequestUserIds,
@@ -133,6 +137,7 @@ const listInput = (overrides: Partial<TSecretAccessRequestListInput> = {}): TSec
{ actorUserId: "requester", isActive: true },
{ actorUserId: "approver-a", isActive: true }
],
+ delegatedRequests: [],
...overrides
});
@@ -401,6 +406,41 @@ describe("composeSecretAccessRequestRows", () => {
expect(row.requestedByUser).toBeNull();
});
+
+ test("attaches the delegated approval status to its own request only", () => {
+ const rows = composeSecretAccessRequestRows(
+ listInput({
+ requests: [request(), request({ id: "req-2" })],
+ policies: [
+ policy({
+ approvers: [],
+ delegatedApproval: { type: DelegatedApprovalPolicyType.ServiceNow, connectionId: "connection-1" }
+ })
+ ],
+ delegatedRequests: [
+ {
+ requestId: "req-1",
+ status: DelegatedApprovalRequestStatus.FailedDispatch,
+ statusReason: "ServiceNow could not be reached."
+ }
+ ]
+ })
+ );
+
+ expect(rows[0].delegatedApproval).toEqual({
+ status: DelegatedApprovalRequestStatus.FailedDispatch,
+ statusReason: "ServiceNow could not be reached."
+ });
+ expect(rows[1].delegatedApproval).toBeNull();
+ expect(rows[0].policy?.delegatedApproval).toEqual({ type: DelegatedApprovalPolicyType.ServiceNow });
+ });
+
+ test("a policy reviewed in Infisical reports no delegated approval", () => {
+ const [row] = composeSecretAccessRequestRows(listInput({ policies: [policy({ delegatedApproval: null })] }));
+
+ expect(row.delegatedApproval).toBeNull();
+ expect(row.policy?.delegatedApproval).toBeNull();
+ });
});
describe("toSecretAccessRequestListItem", () => {
@@ -438,13 +478,29 @@ describe("toSecretAccessRequestListItem", () => {
maxTimePeriod: null,
requestExpirationTime: null,
approvers: [],
- bypassers: []
+ bypassers: [],
+ delegatedApproval: null
});
expect(item?.environment).toBe("dev");
expect(item?.status).toBe(ApprovalStatus.PENDING);
expect(item?.isApproved).toBe(false);
});
+ test("a delegated request keeps its status after its policy is deleted", () => {
+ const item = toItem({
+ requests: [request({ policyId: null, status: ApprovalRequestStatus.Cancelled })],
+ delegatedRequests: [
+ { requestId: "req-1", status: DelegatedApprovalRequestStatus.WaitingApproval, statusReason: null }
+ ]
+ });
+
+ expect(item?.policy.delegatedApproval).toBeNull();
+ expect(item?.delegatedApproval).toEqual({
+ status: DelegatedApprovalRequestStatus.WaitingApproval,
+ statusReason: null
+ });
+ });
+
test("a grant revoked by the policy's deletion reads as revoked", () => {
const item = toItem({
requests: [request({ policyId: null, status: ApprovalRequestStatus.Approved })],
diff --git a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.ts b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.ts
index 47151f0611..2f127108d6 100644
--- a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.ts
+++ b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-fns.ts
@@ -23,6 +23,7 @@ import {
parseSecretAccessRequestData
} from "@app/services/approval-policy/secret-access/secret-access-policy-fns";
import { TSecretAccessRequestData } from "@app/services/approval-policy/secret-access/secret-access-policy-types";
+import { TDelegatedApprovalRequest } from "@app/services/delegated-approval/delegated-approval-types";
import { NotificationType } from "@app/services/notification/notification-types";
import { TSecretAccessApprovalGlobalPolicyBridgeDALFactory } from "@app/services/secret-access-approval-global-policy-bridge/secret-access-approval-global-policy-bridge-dal";
import { SmtpTemplates } from "@app/services/smtp/smtp-service";
@@ -331,6 +332,7 @@ export type TSecretAccessRequestListInput = {
groupMembers: { groupId: string; userId: string }[];
users: Pick<TUsers, "id" | "email" | "username" | "firstName" | "lastName">[];
orgMemberships: { actorUserId?: string | null; isActive: boolean }[];
+ delegatedRequests: Pick<TDelegatedApprovalRequest, "requestId" | "status" | "statusReason">[];
};
export type TPolicySubject = { type: string; id?: string | null };
@@ -385,7 +387,8 @@ export const composeSecretAccessRequestRows = ({
approvals,
groupMembers,
users,
- orgMemberships
+ orgMemberships,
+ delegatedRequests
}: TSecretAccessRequestListInput) => {
const policiesById = new Map(policies.map((policy) => [policy.id, policy]));
const userById = new Map(users.map((user) => [user.id, user]));
@@ -394,6 +397,10 @@ export const composeSecretAccessRequestRows = ({
orgMemberships.map((membership) => [membership.actorUserId as string, membership.isActive])
);
+ const delegatedRequestByRequestId = new Map(
+ delegatedRequests.map((delegatedRequest) => [delegatedRequest.requestId, delegatedRequest])
+ );
+
const grantByRequestId = new Map<string, TApprovalRequestGrants>();
grants.forEach((grant) => {
if (grant.requestId && !grantByRequestId.has(grant.requestId)) grantByRequestId.set(grant.requestId, grant);
@@ -443,6 +450,7 @@ export const composeSecretAccessRequestRows = ({
}))
);
const bypassers = (policy?.bypassers ?? []).flatMap(expandSubject);
+ const delegatedRequest = delegatedRequestByRequestId.get(request.id);
return {
request,
@@ -474,7 +482,14 @@ export const composeSecretAccessRequestRows = ({
maxTimePeriod: policy.maxTimePeriod,
requestExpirationTime: policy.requestExpirationTime,
approvers,
- bypassers
+ bypassers,
+ delegatedApproval: policy.delegatedApproval ? { type: policy.delegatedApproval.type } : null
+ }
+ : null,
+ delegatedApproval: delegatedRequest
+ ? {
+ status: delegatedRequest.status,
+ statusReason: delegatedRequest.statusReason ?? null
}
: null,
environment: policy?.environment ?? null,
@@ -546,7 +561,8 @@ export const toSecretAccessRequestListItem = (
maxTimePeriod: null,
requestExpirationTime: null,
approvers: [],
- bypassers: []
+ bypassers: [],
+ delegatedApproval: null
};
// Legacy left a deleted policy's open requests pending, and the UI shows "Policy Deleted" only for a
// request that was neither approved nor rejected.
@@ -567,7 +583,8 @@ export const toSecretAccessRequestListItem = (
isApproved: status === ApprovalStatus.APPROVED,
reviewers: row.reviewers,
approvers: policy.approvers,
- bypassers: policy.bypassers
+ bypassers: policy.bypassers,
+ delegatedApproval: row.delegatedApproval
};
};
diff --git a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-service.ts b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-service.ts
index 156c50c690..ac9d26783c 100644
--- a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-service.ts
+++ b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-service.ts
@@ -1,11 +1,15 @@
-import { subject } from "@casl/ability";
+import { ForbiddenError, subject } from "@casl/ability";
import { ActionProjectType, ProjectMembershipRole } from "@app/db/schemas";
import { ApproverType } from "@app/ee/services/access-approval-policy/access-approval-policy-types";
import { verifyRequestedPermissions } from "@app/ee/services/access-approval-request/access-approval-request-fns";
import { ApprovalStatus } from "@app/ee/services/access-approval-request/access-approval-request-types";
import { flattenActiveRolesFromMemberships } from "@app/ee/services/permission/permission-service";
-import { ProjectPermissionMemberActions, ProjectPermissionSub } from "@app/ee/services/permission/project-permission";
+import {
+ ProjectPermissionApprovalRequestActions,
+ ProjectPermissionMemberActions,
+ ProjectPermissionSub
+} from "@app/ee/services/permission/project-permission";
import { isGlobSubsetOfGlob } from "@app/lib/casl/glob-subset";
import { getConfig } from "@app/lib/config/env";
import { BadRequestError, ForbiddenRequestError, NotFoundError } from "@app/lib/errors";
@@ -47,6 +51,7 @@ import {
TCountSecretAccessApprovalGlobalRequestsDTO,
TCreateSecretAccessApprovalGlobalRequestDTO,
TListSecretAccessApprovalGlobalRequestsDTO,
+ TRetrySecretAccessApprovalGlobalRequestDispatchDTO,
TReviewSecretAccessApprovalGlobalRequestDTO,
TRevokeSecretAccessApprovalGlobalRequestDTO,
TSecretAccessApprovalGlobalRequestBridgeServiceFactoryDep
@@ -111,10 +116,11 @@ export const secretAccessApprovalGlobalRequestBridgeServiceFactory = ({
if (!requests.length) return [];
const requestIds = requests.map((request) => request.id);
- const [policies, grants, approvals] = await Promise.all([
+ const [policies, grants, approvals, delegatedRequests] = await Promise.all([
secretAccessApprovalGlobalPolicyBridgeDAL.findSecretAccessPolicies({ projectId: filter.projectId }),
secretAccessApprovalGlobalRequestBridgeDAL.findGrantsByRequestIds(requestIds),
- secretAccessApprovalGlobalRequestBridgeDAL.findApprovalsByRequestIds(requestIds)
+ secretAccessApprovalGlobalRequestBridgeDAL.findApprovalsByRequestIds(requestIds),
+ delegatedApprovalService.getRequestsByRequestIds(requestIds)
]);
const [privileges, groupMembers] = await Promise.all([
@@ -136,7 +142,8 @@ export const secretAccessApprovalGlobalRequestBridgeServiceFactory = ({
approvals,
groupMembers,
users,
- orgMemberships
+ orgMemberships,
+ delegatedRequests
});
};
@@ -828,12 +835,47 @@ export const secretAccessApprovalGlobalRequestBridgeServiceFactory = ({
return { request: revoked, projectId: request.projectId };
};
+ const retryDelegatedApprovalDispatch = async ({
+ requestId,
+ actor,
+ actorId,
+ actorOrgId,
+ actorAuthMethod
+ }: TRetrySecretAccessApprovalGlobalRequestDispatchDTO) => {
+ const request = await $findRequestById(requestId);
+
+ const { permission } = await permissionService.getProjectPermission({
+ actor,
+ actorId,
+ projectId: request.projectId,
+ actorAuthMethod,
+ actorOrgId,
+ actionProjectType: ActionProjectType.SecretManager
+ });
+
+ if (request.requesterId !== actorId) {
+ ForbiddenError.from(permission).throwUnlessCan(
+ ProjectPermissionApprovalRequestActions.Read,
+ ProjectPermissionSub.ApprovalRequests
+ );
+ }
+
+ const { delegatedPolicy } = await delegatedApprovalService.retryDispatch({ approvalRequest: request });
+
+ return {
+ request: { ...toLegacyAccessApprovalRequest(request), policyId: delegatedPolicy.policyId },
+ projectId: request.projectId,
+ delegatedApprovalType: delegatedPolicy.type
+ };
+ };
+
return {
isGlobalAccessApprovalRequest,
listAccessApprovalRequests,
countAccessApprovalRequests,
createAccessApprovalRequest,
reviewAccessApprovalRequest,
- revokeAccessApprovalRequest
+ revokeAccessApprovalRequest,
+ retryDelegatedApprovalDispatch
};
};
diff --git a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-types.ts b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-types.ts
index 64af143a0b..f104604e77 100644
--- a/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-types.ts
+++ b/backend/src/services/secret-access-approval-global-request-bridge/secret-access-approval-global-request-bridge-types.ts
@@ -1,4 +1,5 @@
import {
+ TRetryDelegatedApprovalDispatchDTO,
TReviewAccessRequestDTO,
TRevokeAccessRequestDTO
} from "@app/ee/services/access-approval-request/access-approval-request-types";
@@ -61,7 +62,10 @@ export type TSecretAccessApprovalGlobalRequestBridgeServiceFactoryDep = {
| "findUsersByIds"
| "findOrgMembershipActivity"
>;
- delegatedApprovalService: Pick<TDelegatedApprovalServiceFactory, "getPolicyByPolicyId" | "createRequest">;
+ delegatedApprovalService: Pick<
+ TDelegatedApprovalServiceFactory,
+ "getPolicyByPolicyId" | "createRequest" | "getRequestsByRequestIds" | "retryDispatch"
+ >;
delegatedApprovalDispatchQueue: Pick<TDelegatedApprovalDispatchQueueFactory, "queueDispatch">;
smtpService: Pick<TSmtpService, "sendMail">;
notificationService: Pick<TNotificationServiceFactory, "createUserNotifications">;
@@ -99,3 +103,5 @@ export type TCountSecretAccessApprovalGlobalRequestsDTO = {
};
export type TReviewSecretAccessApprovalGlobalRequestDTO = TReviewAccessRequestDTO;
export type TRevokeSecretAccessApprovalGlobalRequestDTO = TRevokeAccessRequestDTO;
+
+export type TRetrySecretAccessApprovalGlobalRequestDispatchDTO = TRetryDelegatedApprovalDispatchDTO;
diff --git a/docs/documentation/platform/audit-logs.mdx b/docs/documentation/platform/audit-logs.mdx
index c5fc01c2b6..f0da0b2c22 100644
--- a/docs/documentation/platform/audit-logs.mdx
+++ b/docs/documentation/platform/audit-logs.mdx
@@ -1021,6 +1021,7 @@ Infisical emits hundreds of event types. Here are some of the most common ones y
| ---------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
| `approval-request-create`, `approval-request-approve`, `approval-request-reject`, `approval-request-cancel` | The lifecycle of an approval request. |
| `access-approval-request-create`, `access-approval-request-review`, `access-approval-request-update`, `access-approval-request-revoke` | The lifecycle of an access approval request. |
+ | `access-approval-request-delegated-dispatch-retry` | A user retried an access approval request that never reached its external approval system, such as [ServiceNow](/documentation/platform/workflow-integrations/servicenow-integration). |
| `secret-approval-request`, `secret-approval-request-review`, `secret-approval-merged`, `secret-approval-closed`, `secret-approval-reopened` | The lifecycle of a secret change request. |
| `approval-policy-create`, `approval-policy-update`, `approval-policy-delete` | An admin changed an approval policy. |
</Accordion>
diff --git a/frontend/src/hooks/api/accessApproval/index.tsx b/frontend/src/hooks/api/accessApproval/index.tsx
index 085d390cb0..c769de160d 100644
--- a/frontend/src/hooks/api/accessApproval/index.tsx
+++ b/frontend/src/hooks/api/accessApproval/index.tsx
@@ -2,6 +2,7 @@ export {
useCreateAccessApprovalPolicy,
useCreateAccessRequest,
useDeleteAccessApprovalPolicy,
+ useRetryDelegatedApprovalDispatch,
useReviewAccessRequest,
useRevokeAccessRequest,
useUpdateAccessApprovalPolicy
diff --git a/frontend/src/hooks/api/accessApproval/mutation.tsx b/frontend/src/hooks/api/accessApproval/mutation.tsx
index be0a366618..02c297ba66 100644
--- a/frontend/src/hooks/api/accessApproval/mutation.tsx
+++ b/frontend/src/hooks/api/accessApproval/mutation.tsx
@@ -193,6 +193,30 @@ export const useRevokeAccessRequest = () => {
});
};
+export const useRetryDelegatedApprovalDispatch = () => {
+ const queryClient = useQueryClient();
+ return useMutation<
+ object,
+ object,
+ {
+ requestId: string;
+ projectSlug: string;
+ }
+ >({
+ mutationFn: async ({ requestId }) => {
+ const { data } = await apiRequest.post(
+ `/api/v1/access-approvals/requests/${requestId}/retry-delegated-dispatch`
+ );
+ return data;
+ },
+ onSuccess: (_, { projectSlug }) => {
+ queryClient.invalidateQueries({
+ queryKey: accessApprovalKeys.getAccessApprovalRequestsAllForProject(projectSlug)
+ });
+ }
+ });
+};
+
export const useReviewAccessRequest = () => {
const queryClient = useQueryClient();
return useMutation<
diff --git a/frontend/src/hooks/api/accessApproval/types.ts b/frontend/src/hooks/api/accessApproval/types.ts
index fa50ecc633..3b69ebf10b 100644
--- a/frontend/src/hooks/api/accessApproval/types.ts
+++ b/frontend/src/hooks/api/accessApproval/types.ts
@@ -1,4 +1,8 @@
-import { TDelegatedApprovalPolicyInput } from "../delegatedApprovals/types";
+import { DelegatedApprovalPolicyType } from "../delegatedApprovals/enums";
+import {
+ TDelegatedApprovalPolicyInput,
+ TDelegatedApprovalRequest
+} from "../delegatedApprovals/types";
import { EnforcementLevel, PolicyType } from "../policies/enums";
import { ProjectEnv } from "../projects/types";
import { TProjectPermission } from "../roles/types";
@@ -129,8 +133,11 @@ export type TAccessApprovalRequest = {
allowedSelfApprovals: boolean;
maxTimePeriod?: string | null;
requestExpirationTime?: string | null;
+ delegatedApproval?: { type: DelegatedApprovalPolicyType } | null;
};
+ delegatedApproval?: TDelegatedApprovalRequest | null;
+
reviewers: {
isOrgMembershipActive: boolean;
userId: string;
diff --git a/frontend/src/hooks/api/delegatedApprovals/enums.ts b/frontend/src/hooks/api/delegatedApprovals/enums.ts
index 7d6a9ce084..d33a2dce33 100644
--- a/frontend/src/hooks/api/delegatedApprovals/enums.ts
+++ b/frontend/src/hooks/api/delegatedApprovals/enums.ts
@@ -1,3 +1,12 @@
export enum DelegatedApprovalPolicyType {
ServiceNow = "servicenow"
}
+
+export enum DelegatedApprovalRequestStatus {
+ PendingDispatch = "pending_dispatch",
+ WaitingApproval = "waiting_approval",
+ FailedDispatch = "failed_dispatch",
+ Approved = "approved",
+ Rejected = "rejected",
+ Failed = "failed"
+}
diff --git a/frontend/src/hooks/api/delegatedApprovals/types.ts b/frontend/src/hooks/api/delegatedApprovals/types.ts
index 041554668d..15c14b2e16 100644
--- a/frontend/src/hooks/api/delegatedApprovals/types.ts
+++ b/frontend/src/hooks/api/delegatedApprovals/types.ts
@@ -1,5 +1,5 @@
import { AppConnection } from "../appConnections/enums";
-import { DelegatedApprovalPolicyType } from "./enums";
+import { DelegatedApprovalPolicyType, DelegatedApprovalRequestStatus } from "./enums";
export type TDelegatedApprovalOption = {
name: string;
@@ -15,3 +15,8 @@ export type TDelegatedApprovalPolicyInput = {
type: DelegatedApprovalPolicyType;
connectionId: string;
};
+
+export type TDelegatedApprovalRequest = {
+ status: DelegatedApprovalRequestStatus;
+ statusReason?: string | null;
+};
diff --git a/frontend/src/pages/secret-manager/SecretApprovalsPage/components/AccessApprovalRequest/AccessApprovalRequest.tsx b/frontend/src/pages/secret-manager/SecretApprovalsPage/components/AccessApprovalRequest/AccessApprovalRequest.tsx
index 486feddea9..34420ffdf5 100644
--- a/frontend/src/pages/secret-manager/SecretApprovalsPage/components/AccessApprovalRequest/AccessApprovalRequest.tsx
+++ b/frontend/src/pages/secret-manager/SecretApprovalsPage/components/AccessApprovalRequest/AccessApprovalRequest.tsx
@@ -16,7 +16,8 @@ import {
PlusIcon,
SearchIcon,
ShieldBanIcon,
- TimerIcon
+ TimerIcon,
+ TriangleAlertIcon
} from "lucide-react";
import {
@@ -90,6 +91,10 @@ import {
useGetAccessRequestsCount
} from "@app/hooks/api/accessApproval/queries";
import { TAccessApprovalRequest } from "@app/hooks/api/accessApproval/types";
+import {
+ DelegatedApprovalRequestStatus,
+ useDelegatedApprovalOptions
+} from "@app/hooks/api/delegatedApprovals";
import { EnforcementLevel } from "@app/hooks/api/policies/enums";
import { queryClient } from "@app/hooks/api/reactQuery";
import { ApprovalStatus, TWorkspaceUser } from "@app/hooks/api/types";
@@ -237,6 +242,10 @@ export const AccessApprovalRequest = ({
envSlug: validEnvFilter
});
+ const { data: delegatedApprovalOptions } = useDelegatedApprovalOptions({
+ enabled: Boolean(requests?.some((request) => request.delegatedApproval))
+ });
+
const { search, setSearch, setPage, page, perPage, setPerPage, offset } = usePagination("", {
initPerPage: getUserTablePreference("accessRequestsTable", PreferenceKey.PerPage, 20)
});
@@ -466,7 +475,25 @@ export const AccessApprovalRequest = ({
type: "danger",
icon: ShieldBanIcon
};
- else if (userReviewStatus === ApprovalStatus.APPROVED) {
+ else if (request.delegatedApproval?.status === DelegatedApprovalRequestStatus.FailedDispatch)
+ displayData = {
+ label: "Not Submitted",
+ type: "danger",
+ icon: TriangleAlertIcon,
+ tooltipContent: request.delegatedApproval.statusReason ?? undefined
+ };
+ else if (request.delegatedApproval) {
+ const delegatedApprovalName = delegatedApprovalOptions?.find(
+ (option) => option.type === request.policy.delegatedApproval?.type
+ )?.name;
+ displayData = {
+ label: delegatedApprovalName
+ ? `Pending in ${delegatedApprovalName}`
+ : "Pending External Review",
+ type: "warning",
+ icon: HourglassIcon
+ };
+ } else if (userReviewStatus === ApprovalStatus.APPROVED) {
displayData = {
label: "Pending Additional Reviews",
type: "warning",
@@ -492,7 +519,7 @@ export const AccessApprovalRequest = ({
isSelfApproveAllowed
};
},
- [user]
+ [user, delegatedApprovalOptions]
);
const handleSelectRequest = useCallback(
diff --git a/frontend/src/pages/secret-manager/SecretApprovalsPage/components/AccessApprovalRequest/components/ReviewAccessModal.tsx b/frontend/src/pages/secret-manager/SecretApprovalsPage/components/AccessApprovalRequest/components/ReviewAccessModal.tsx
index 3132d1037e..7099efc2d4 100644
--- a/frontend/src/pages/secret-manager/SecretApprovalsPage/components/AccessApprovalRequest/components/ReviewAccessModal.tsx
+++ b/frontend/src/pages/secret-manager/SecretApprovalsPage/components/AccessApprovalRequest/components/ReviewAccessModal.tsx
@@ -1,4 +1,4 @@
-import { Fragment, useCallback, useMemo, useState } from "react";
+import { Fragment, ReactNode, useCallback, useMemo, useState } from "react";
import { format } from "date-fns";
import {
BanIcon,
@@ -6,6 +6,7 @@ import {
FilterIcon,
HourglassIcon,
InfoIcon,
+ RefreshCwIcon,
ShieldAlertIcon,
TimerIcon,
TriangleAlertIcon,
@@ -75,10 +76,14 @@ import {
useProjectPermission,
useUser
} from "@app/context";
-import { PermissionConditionOperators } from "@app/context/ProjectPermissionContext/types";
+import {
+ PermissionConditionOperators,
+ ProjectPermissionApprovalRequestActions
+} from "@app/context/ProjectPermissionContext/types";
import { usePopUp } from "@app/hooks";
import {
useListWorkspaceGroups,
+ useRetryDelegatedApprovalDispatch,
useReviewAccessRequest,
useRevokeAccessRequest
} from "@app/hooks/api";
@@ -88,6 +93,10 @@ import {
TAccessApprovalPolicy,
TAccessApprovalRequest
} from "@app/hooks/api/accessApproval/types";
+import {
+ DelegatedApprovalRequestStatus,
+ useDelegatedApprovalOptions
+} from "@app/hooks/api/delegatedApprovals";
import { EnforcementLevel } from "@app/hooks/api/policies/enums";
import { ApprovalStatus, TWorkspaceUser } from "@app/hooks/api/types";
import { groupBy } from "@app/lib/fn/array";
@@ -170,6 +179,53 @@ const formatConditions = (conditions: Record<string, unknown>): FormattedConditi
}));
});
+const DELEGATED_STATUS_PRESENTATION: Record<
+ DelegatedApprovalRequestStatus,
+ {
+ label: string;
+ variant: "warning" | "danger" | "success";
+ icon: ReactNode;
+ getMessage: (delegatedApprovalName: string) => string;
+ }
+> = {
+ [DelegatedApprovalRequestStatus.PendingDispatch]: {
+ label: "Sending",
+ variant: "warning",
+ icon: <HourglassIcon />,
+ getMessage: (name) => `Sending this request to ${name}.`
+ },
+ [DelegatedApprovalRequestStatus.WaitingApproval]: {
+ label: "Pending",
+ variant: "warning",
+ icon: <HourglassIcon />,
+ getMessage: (name) => `Awaiting review in ${name}.`
+ },
+ [DelegatedApprovalRequestStatus.FailedDispatch]: {
+ label: "Not Submitted",
+ variant: "danger",
+ icon: <TriangleAlertIcon />,
+ getMessage: (name) => `This request did not reach ${name}.`
+ },
+ [DelegatedApprovalRequestStatus.Approved]: {
+ label: "Approved",
+ variant: "success",
+ icon: <CheckIcon />,
+ getMessage: (name) => `Approved in ${name}.`
+ },
+ [DelegatedApprovalRequestStatus.Rejected]: {
+ label: "Rejected",
+ variant: "danger",
+ icon: <BanIcon />,
+ getMessage: (name) => `Rejected in ${name}.`
+ },
+ [DelegatedApprovalRequestStatus.Failed]: {
+ label: "Failed",
+ variant: "danger",
+ icon: <TriangleAlertIcon />,
+ getMessage: (name) => `This request could not be completed in ${name}.`
+ }
+};
+
export const ReviewAccessRequestModal = ({
isOpen,
onOpenChange,
@@ -206,6 +262,18 @@ export const ReviewAccessRequestModal = ({
const isSoftEnforcement = request.policy.enforcementLevel === EnforcementLevel.Soft;
+ const isDelegatedRequest = Boolean(request.delegatedApproval);
+ const { data: delegatedApprovalOptions } = useDelegatedApprovalOptions({
+ enabled: isDelegatedRequest
+ });
+ const delegatedApprovalName =
+ delegatedApprovalOptions?.find(
+ (option) => option.type === request.policy.delegatedApproval?.type
+ )?.name ?? "the external approval system";
+ const delegatedStatus = request.delegatedApproval
+ ? DELEGATED_STATUS_PRESENTATION[request.delegatedApproval.status]
+ : undefined;
+
const assignPrivilegesConditions = useMemo(
() => getMemberAssignPrivilegesConditions(permission),
[permission]
@@ -300,6 +368,26 @@ export const ReviewAccessRequestModal = ({
const reviewAccessRequest = useReviewAccessRequest();
const revokeAccessRequest = useRevokeAccessRequest();
+ const retryDelegatedApprovalDispatch = useRetryDelegatedApprovalDispatch();
+
+ const handleRetryDispatch = useCallback(async () => {
+ try {
+ await retryDelegatedApprovalDispatch.mutateAsync({ requestId: request.id, projectSlug });
+ } catch {
+ return;
+ }
+ createNotification({
+ text: `Request sent to ${delegatedApprovalName} again`,
+ type: "success"
+ });
+ onOpenChange(false);
+ }, [
+ retryDelegatedApprovalDispatch,
+ request.id,
+ projectSlug,
+ delegatedApprovalName,
+ onOpenChange
+ ]);
const handleReview = useCallback(
async (status: "approved" | "rejected") => {
@@ -433,8 +521,23 @@ export const ReviewAccessRequestModal = ({
request.isApproved &&
new Date() > new Date(request.privilege.temporaryAccessEndTime || ("" as string));
const isReviewedByMe = request.reviewers.find((i) => i.userId === user.id);
+ const isDelegatedPending =
+ isDelegatedRequest &&
+ request.status === ApprovalStatus.PENDING &&
+ !hasExpired &&
+ !request.policy.deletedAt;
+
+ const canRetryDispatch =
+ isDelegatedPending &&
+ request.delegatedApproval?.status === DelegatedApprovalRequestStatus.FailedDispatch &&
+ (request.isRequestedByCurrentUser ||
+ permission.can(
+ ProjectPermissionApprovalRequestActions.Read,
+ ProjectPermissionSub.ApprovalRequests
+ ));
const shouldBlockRequestActions =
+ isDelegatedRequest ||
hasRejected ||
hasApproved ||
hasRevoked ||
@@ -746,10 +849,14 @@ export const ReviewAccessRequestModal = ({
>
<SheetHeader className="border-b">
<SheetTitle>Review Request</SheetTitle>
- <SheetDescription>Review the request and approve or deny access.</SheetDescription>
+ <SheetDescription>
+ {isDelegatedRequest
+ ? "Review the details of this access request."
+ : "Review the request and approve or deny access."}
+ </SheetDescription>
</SheetHeader>
<div className="flex min-h-0 thin-scrollbar flex-1 flex-col gap-4 overflow-y-auto p-4">
- {shouldBlockRequestActions && (
+ {shouldBlockRequestActions && !isDelegatedPending && (
<Alert variant={completedMessageVariant}>
{renderBannerIcon()}
<AlertTitle>{renderCompletedMessages()}</AlertTitle>
@@ -908,59 +1015,124 @@ export const ReviewAccessRequestModal = ({
</Table>
</section>
- <section className="flex flex-col gap-3">
- <h3 className="text-sm font-normal text-foreground">Approvers</h3>
- {approvers.length === 1 ? (
- <ItemGroup className="gap-0 rounded-lg border border-border bg-container">
- <Item className="flex-nowrap items-start rounded-none border-0">
- <ItemContent className="min-w-0 gap-1.5">
- {renderApproverMembers(approvers[0])}
- </ItemContent>
- <ItemActions className="shrink-0">
- {renderReviewerProgress(approvers[0], getStatusBadge(approvers[0]))}
- <span className="text-xs whitespace-nowrap text-muted">
- {approvers[0].approvals ?? 1} approval
- {(approvers[0].approvals ?? 1) === 1 ? "" : "s"} required
- </span>
- </ItemActions>
- </Item>
- </ItemGroup>
- ) : (
- <ItemGroup className="gap-0 rounded-lg border border-border bg-container">
- {approvers.map((approver, index) => {
- const isInactive =
- approverSequence?.currentSequence < (approver.sequence ?? approvers.length);
- const badge = getStatusBadge(approver);
-
- return (
- <Fragment key={`approval-list-${index + 1}`}>
- {index > 0 && <ItemSeparator className="m-0" />}
- <Item
- className={twMerge(
- "flex-nowrap items-start rounded-none border-0",
- isInactive && "opacity-50"
- )}
- >
- <ItemMedia>
- <Badge variant="neutral">Step {index + 1}</Badge>
- </ItemMedia>
- <ItemContent className="min-w-0 gap-1.5">
- {renderApproverMembers(approver)}
- </ItemContent>
- <ItemActions className="shrink-0">
- {renderReviewerProgress(approver, badge)}
- <span className="text-xs whitespace-nowrap text-muted">
- {approver.approvals ?? 1} approval
- {(approver.approvals ?? 1) === 1 ? "" : "s"} required
+ {isDelegatedRequest ? (
+ <>
+ {isDelegatedPending && (
+ <section className="flex flex-col gap-3">
+ <h3 className="text-sm font-normal text-foreground">Approval</h3>
+ <Alert variant="info">
+ <InfoIcon />
+ <AlertTitle>This request is reviewed in {delegatedApprovalName}.</AlertTitle>
+ <AlertDescription>
+ It cannot be approved or rejected in Infisical. Infisical grants access once{" "}
+ {delegatedApprovalName} approves it.
+ </AlertDescription>
+ </Alert>
+ </section>
+ )}
+ {delegatedStatus && (
+ <section className="flex flex-col gap-3">
+ <h3 className="text-sm font-normal text-foreground">Status</h3>
+ <ItemGroup
+ className={twMerge(
+ "gap-0 rounded-lg border border-border bg-container",
+ delegatedStatus.variant === "danger" && "border-danger/25"
+ )}
+ >
+ <Item className="flex-nowrap items-start rounded-none border-0">
+ <ItemMedia>
+ <Badge variant={delegatedStatus.variant}>
+ {delegatedStatus.icon}
+ {delegatedStatus.label}
+ </Badge>
+ </ItemMedia>
+ <ItemContent className="min-w-0 gap-1">
+ <span className="text-sm text-foreground">
+ {delegatedStatus.getMessage(delegatedApprovalName)}
+ </span>
+ {request.delegatedApproval?.statusReason && (
+ <span className="text-xs break-words text-muted">
+ {request.delegatedApproval.statusReason}
</span>
- </ItemActions>
- </Item>
- </Fragment>
- );
- })}
- </ItemGroup>
- )}
- </section>
+ )}
+ </ItemContent>
+ <ItemActions className="shrink-0 items-center gap-3">
+ <span className="text-xs whitespace-nowrap text-muted">
+ Requested {format(new Date(request.createdAt), "MMM d, yyyy h:mm aa")}
+ </span>
+ {canRetryDispatch && (
+ <Button
+ type="button"
+ size="sm"
+ variant="outline"
+ isPending={retryDelegatedApprovalDispatch.isPending}
+ onClick={handleRetryDispatch}
+ >
+ <RefreshCwIcon />
+ Retry
+ </Button>
+ )}
+ </ItemActions>
+ </Item>
+ </ItemGroup>
+ </section>
+ )}
+ </>
+ ) : (
+ <section className="flex flex-col gap-3">
+ <h3 className="text-sm font-normal text-foreground">Approvers</h3>
+ {approvers.length === 1 ? (
+ <ItemGroup className="gap-0 rounded-lg border border-border bg-container">
+ <Item className="flex-nowrap items-start rounded-none border-0">
+ <ItemContent className="min-w-0 gap-1.5">
+ {renderApproverMembers(approvers[0])}
+ </ItemContent>
+ <ItemActions className="shrink-0">
+ {renderReviewerProgress(approvers[0], getStatusBadge(approvers[0]))}
+ <span className="text-xs whitespace-nowrap text-muted">
+ {approvers[0].approvals ?? 1} approval
+ {(approvers[0].approvals ?? 1) === 1 ? "" : "s"} required
+ </span>
+ </ItemActions>
+ </Item>
+ </ItemGroup>
+ ) : (
+ <ItemGroup className="gap-0 rounded-lg border border-border bg-container">
+ {approvers.map((approver, index) => {
+ const isInactive =
+ approverSequence?.currentSequence < (approver.sequence ?? approvers.length);
+ const badge = getStatusBadge(approver);
+
+ return (
+ <Fragment key={`approval-list-${index + 1}`}>
+ {index > 0 && <ItemSeparator className="m-0" />}
+ <Item
+ className={twMerge(
+ "flex-nowrap items-start rounded-none border-0",
+ isInactive && "opacity-50"
+ )}
+ >
+ <ItemMedia>
+ <Badge variant="neutral">Step {index + 1}</Badge>
+ </ItemMedia>
+ <ItemContent className="min-w-0 gap-1.5">
+ {renderApproverMembers(approver)}
+ </ItemContent>
+ <ItemActions className="shrink-0">
+ {renderReviewerProgress(approver, badge)}
+ <span className="text-xs whitespace-nowrap text-muted">
+ {approver.approvals ?? 1} approval
+ {(approver.approvals ?? 1) === 1 ? "" : "s"} required
+ </span>
+ </ItemActions>
+ </Item>
+ </Fragment>
+ );
+ })}
+ </ItemGroup>
+ )}
+ </section>
+ )}
</div>
<SheetFooter className={twMerge("flex-col border-t", !showFooter && "hidden")}>
{!shouldBlockRequestActions && (