Skip to content

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

Merge origin/main into PAM-517

Andrey9f8d96c3bbb1
diff --cc backend/src/server/routes/index.ts
index 056f85d55e,3a9cd70be4..3fd772c69b
--- a/backend/src/server/routes/index.ts
+++ b/backend/src/server/routes/index.ts
@@@ -249,12 -251,13 +251,15 @@@ import { alertProviderRegistryFactory
import { alertQueueServiceFactory } from "@app/services/alert/alert-queue";
import { alertRecipientResolverFactory } from "@app/services/alert/alert-recipient-resolver";
import { alertServiceFactory } from "@app/services/alert/alert-service";
- import { certManagerApplicationAlertDALFactory } from "@app/services/alert/providers/cert-manager-application-alert-dal";
+ import { certManagerAlertProviderFactory } from "@app/services/alert/providers/cert-manager-alert-provider";
import { certManagerApplicationAlertProviderFactory } from "@app/services/alert/providers/cert-manager-application-alert-provider";
+ import { certManagerCertificateAlertDALFactory } from "@app/services/alert/providers/cert-manager-certificate-alert-dal";
+ import { certManagerSignerAlertDALFactory } from "@app/services/alert/providers/cert-manager-signer-alert-dal";
+ import { certManagerSignerAlertProviderFactory } from "@app/services/alert/providers/cert-manager-signer-alert-provider";
import { identityCredentialAlertDALFactory } from "@app/services/alert/providers/identity-credential-alert-dal";
import { identityCredentialAlertProviderFactory } from "@app/services/alert/providers/identity-credential-alert-provider";
+import { pamFolderAlertDALFactory } from "@app/services/alert/providers/pam-folder-alert-dal";
+import { pamFolderAlertProviderFactory } from "@app/services/alert/providers/pam-folder-alert-provider";
import { announcementServiceFactory } from "@app/services/announcement/announcement-service";
import { appConnectionDALFactory } from "@app/services/app-connection/app-connection-dal";
import { appConnectionServiceFactory } from "@app/services/app-connection/app-connection-service";
@@@ -1102,13 -1118,22 +1120,29 @@@ export const registerRoutes = async
licenseService
})
);
+ alertProviderRegistry.register(
+ certManagerAlertProviderFactory({
+ certManagerCertificateAlertDAL,
+ permissionService,
+ licenseService,
+ certManagerProjectResolver
+ })
+ );
+ alertProviderRegistry.register(
+ certManagerSignerAlertProviderFactory({
+ certManagerSignerAlertDAL: certManagerSignerAlertDALFactory(db),
+ permissionService,
+ licenseService,
+ certManagerProjectResolver
+ })
+ );
+ alertProviderRegistry.register(
+ pamFolderAlertProviderFactory({
+ pamFolderAlertDAL: pamFolderAlertDALFactory(db),
+ permissionService,
+ licenseService
+ })
+ );
const alertRecipientResolver = alertRecipientResolverFactory({
userDAL,
userGroupMembershipDAL,
diff --cc backend/src/services/alert/providers/pam-folder-alert-dal.ts
index afa02a0ad9,0000000000..63782c0cc2
mode 100644,000000..100644
--- a/backend/src/services/alert/providers/pam-folder-alert-dal.ts
+++ b/backend/src/services/alert/providers/pam-folder-alert-dal.ts
@@@ -1,134 -1,0 +1,119 @@@
+import { Knex } from "knex";
+
+import { TDbClient } from "@app/db";
+import { ProjectType, TableName } from "@app/db/schemas";
+import { DatabaseError } from "@app/lib/errors";
+import {
+ ApprovalPolicyType,
+ ApprovalRequestApprovalDecision
+} from "@app/services/approval-policy/approval-policy-enums";
+
+export type TPamFolderAlertDALFactory = ReturnType<typeof pamFolderAlertDALFactory>;
+
+// Event-path reads go to the primary: the request commits with the event, and an empty read is terminal.
+export const pamFolderAlertDALFactory = (db: TDbClient) => {
+ const findFolderById = async (
+ folderId: string,
+ { readFromPrimary = false }: { readFromPrimary?: boolean } = {},
+ tx?: Knex
+ ) => {
+ try {
+ const folder = (await (tx || (readFromPrimary ? db : db.replicaNode()))(TableName.PamFolder)
+ .join(TableName.Project, `${TableName.PamFolder}.projectId`, `${TableName.Project}.id`)
+ .where(`${TableName.PamFolder}.id`, folderId)
+ .where(`${TableName.Project}.type`, ProjectType.PAM)
+ .whereNull(`${TableName.Project}.deleteAfter`)
+ .select(`${TableName.PamFolder}.name`, `${TableName.PamFolder}.projectId`, `${TableName.Project}.orgId`)
+ .first()) as { name: string; projectId: string; orgId: string } | undefined;
+
+ return folder;
+ } catch (error) {
+ throw new DatabaseError({ error, name: "FindPamAlertFolderById" });
+ }
+ };
+
- const findFolderNamesByIds = async ({ orgId, folderIds }: { orgId: string; folderIds: string[] }, tx?: Knex) => {
- try {
- const folders = (await (tx || db.replicaNode())(TableName.PamFolder)
- .join(TableName.Project, `${TableName.PamFolder}.projectId`, `${TableName.Project}.id`)
- .whereIn(`${TableName.PamFolder}.id`, folderIds)
- .where(`${TableName.Project}.orgId`, orgId)
- .select(`${TableName.PamFolder}.id`, `${TableName.PamFolder}.name`)) as { id: string; name: string }[];
-
- return folders;
- } catch (error) {
- throw new DatabaseError({ error, name: "FindPamAlertFolderNamesByIds" });
- }
- };
-
+ const findAccessRequestsByIds = async (
+ { orgId, projectId, requestIds }: { orgId: string; projectId: string; requestIds: string[] },
+ tx?: Knex
+ ) => {
+ try {
+ const requests = (await (tx || db)(TableName.ApprovalRequests)
+ .whereIn("id", requestIds)
+ .where({ organizationId: orgId, projectId, type: ApprovalPolicyType.PamAccess })
+ .select("id", "requesterName", "requesterEmail", "machineIdentityId", "requestData")
+ .orderBy("createdAt", "asc")) as {
+ id: string;
+ requesterName: string;
+ requesterEmail: string;
+ machineIdentityId: string | null;
+ requestData: unknown;
+ }[];
+
+ return requests;
+ } catch (error) {
+ throw new DatabaseError({ error, name: "FindPamAlertAccessRequestsByIds" });
+ }
+ };
+
+ const findAccountNamesByIds = async (
+ { projectId, accountIds }: { projectId: string; accountIds: string[] },
+ tx?: Knex
+ ) => {
+ if (accountIds.length === 0) return [];
+ try {
+ const accounts = (await (tx || db)(TableName.PamAccount)
+ .whereIn("id", accountIds)
+ .where({ projectId })
+ .select("id", "name")) as { id: string; name: string }[];
+
+ return accounts;
+ } catch (error) {
+ throw new DatabaseError({ error, name: "FindPamAlertAccountNamesByIds" });
+ }
+ };
+
+ const findDecisionCommentsByRequestIds = async (
+ { requestIds, decision }: { requestIds: string[]; decision: ApprovalRequestApprovalDecision },
+ tx?: Knex
+ ) => {
+ try {
+ const decisions = (await (tx || db)(TableName.ApprovalRequestApprovals)
+ .join(
+ TableName.ApprovalRequestSteps,
+ `${TableName.ApprovalRequestApprovals}.stepId`,
+ `${TableName.ApprovalRequestSteps}.id`
+ )
+ .whereIn(`${TableName.ApprovalRequestSteps}.requestId`, requestIds)
+ .where(`${TableName.ApprovalRequestApprovals}.decision`, decision)
+ .select(`${TableName.ApprovalRequestSteps}.requestId`, `${TableName.ApprovalRequestApprovals}.comment`)
+ .orderBy(`${TableName.ApprovalRequestApprovals}.createdAt`, "asc")) as {
+ requestId: string;
+ comment: string | null;
+ }[];
+
+ return decisions;
+ } catch (error) {
+ throw new DatabaseError({ error, name: "FindPamAlertDecisionCommentsByRequestIds" });
+ }
+ };
+
+ const findBypassReasonsByRequestIds = async (requestIds: string[], tx?: Knex) => {
+ try {
+ const grants = (await (tx || db)(TableName.ApprovalRequestGrants)
+ .whereIn("requestId", requestIds)
+ .select("requestId", "bypassReason")) as { requestId: string; bypassReason: string | null }[];
+
+ return grants;
+ } catch (error) {
+ throw new DatabaseError({ error, name: "FindPamAlertBypassReasonsByRequestIds" });
+ }
+ };
+
+ return {
+ findFolderById,
- findFolderNamesByIds,
+ findAccessRequestsByIds,
+ findAccountNamesByIds,
+ findDecisionCommentsByRequestIds,
+ findBypassReasonsByRequestIds
+ };
+};
diff --cc backend/src/services/alert/providers/pam-folder-alert-provider.ts
index 1ae87c257a,0000000000..30c8ba9b6e
mode 100644,000000..100644
--- a/backend/src/services/alert/providers/pam-folder-alert-provider.ts
+++ b/backend/src/services/alert/providers/pam-folder-alert-provider.ts
@@@ -1,329 -1,0 +1,284 @@@
++import { ForbiddenError } from "@casl/ability";
+import { z } from "zod";
+
- import { Event as TAuditEvent, EventType } from "@app/ee/services/audit-log/audit-log-types";
+import { TLicenseServiceFactory } from "@app/ee/services/license/license-service";
+import { PamAccessType } from "@app/ee/services/pam/pam-enums";
+import { checkFolderPermission, verifyProductMembership } from "@app/ee/services/pam/pam-permission";
+import {
+ PAM_FOLDER_RESOURCE_TYPE,
+ PamAccessRequestEvent
+} from "@app/ee/services/pam-access-request/pam-access-request-events";
+import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service-types";
+import {
+ ResourcePermissionPamResourceActions,
+ ResourcePermissionSub
+} from "@app/ee/services/permission/resource-permission";
+import { getConfig } from "@app/lib/config/env";
- import { BadRequestError, ForbiddenRequestError, NotFoundError } from "@app/lib/errors";
++import { BadRequestError, NotFoundError } from "@app/lib/errors";
+import { formatDuration } from "@app/lib/ms";
+import { ApprovalRequestApprovalDecision } from "@app/services/approval-policy/approval-policy-enums";
+
+import { AlertChannelType, TAlertPayload, TAlertSeverity } from "../alert-channel-types";
+import {
- AlertAuditAction,
+ AlertPermissionAction,
+ AlertTriggerType,
+ IEventAlertProvider,
- TAlertAuditInput,
+ TAlertContext,
+ TAlertPermissionInput,
+ TFindEventTargetsInput
+} from "../alert-types";
+import { TPamFolderAlertDALFactory } from "./pam-folder-alert-dal";
+
+const EventConditionSchema = z.object({}).strict().nullish();
+
+const RequestDataSchema = z.object({
+ requestData: z.object({
+ accountId: z.string().optional(),
+ folderId: z.string(),
+ reason: z.string().optional(),
+ duration: z.string().optional(),
+ accessType: z.nativeEnum(PamAccessType).optional()
+ })
+});
+
+const EVENT_LABELS: Record<PamAccessRequestEvent, string> = {
+ [PamAccessRequestEvent.Requested]: "Request",
+ [PamAccessRequestEvent.Approved]: "Approval",
+ [PamAccessRequestEvent.Denied]: "Denial",
+ [PamAccessRequestEvent.Bypassed]: "Break-Glass"
+};
+
+const EVENT_SEVERITY: Record<PamAccessRequestEvent, TAlertSeverity> = {
+ [PamAccessRequestEvent.Requested]: "info",
+ [PamAccessRequestEvent.Approved]: "info",
+ [PamAccessRequestEvent.Denied]: "warning",
+ [PamAccessRequestEvent.Bypassed]: "critical"
+};
+
+const DECISION_BY_EVENT: Partial<Record<PamAccessRequestEvent, ApprovalRequestApprovalDecision>> = {
+ [PamAccessRequestEvent.Approved]: ApprovalRequestApprovalDecision.Approved,
+ [PamAccessRequestEvent.Denied]: ApprovalRequestApprovalDecision.Rejected
+};
+
+type TPamAccessRequestTarget = {
+ requestId: string;
+ folderName: string;
+ accountName: string | null;
+ requesterName: string;
+ requesterLabel: string;
+ accessType: PamAccessType;
+ duration?: string;
+ reason?: string;
+ comment: string | null;
+ bypassReason: string | null;
+};
+
+const assertValidFolderId = (folderId: string) => {
+ if (!z.string().uuid().safeParse(folderId).success) {
+ throw new BadRequestError({ message: `Invalid folder ID '${folderId}': must be a UUID` });
+ }
+};
+
+const toRequesterLabel = ({
+ requesterName,
+ requesterEmail,
+ machineIdentityId
+}: {
+ requesterName: string;
+ requesterEmail: string;
+ machineIdentityId: string | null;
+}) => {
+ if (machineIdentityId) return `${requesterName} (machine identity)`;
+ return requesterEmail ? `${requesterName} (${requesterEmail})` : requesterName;
+};
+
+const describeTarget = (eventType: PamAccessRequestEvent, target: TPamAccessRequestTarget) => {
+ const account = target.accountName ? `account '${target.accountName}'` : "a deleted account";
+ const access = `${target.accessType === PamAccessType.Credential ? "credential access" : "access"} to ${account} in folder '${target.folderName}'`;
+ if (eventType === PamAccessRequestEvent.Requested) return `${target.requesterName} requested ${access}`;
+ if (eventType === PamAccessRequestEvent.Bypassed) {
+ return `${target.requesterName} used break-glass to get ${access} without approval`;
+ }
+ const decision = eventType === PamAccessRequestEvent.Approved ? "approved" : "denied";
+ return `${target.requesterName}'s request for ${access} was ${decision}`;
+};
+
+export type TPamFolderAlertProviderDep = {
+ pamFolderAlertDAL: TPamFolderAlertDALFactory;
+ permissionService: Pick<TPermissionServiceFactory, "getProjectPermission" | "getResourcePermission">;
+ licenseService: Pick<TLicenseServiceFactory, "getPlan">;
+};
+
+export const pamFolderAlertProviderFactory = ({
+ pamFolderAlertDAL,
+ permissionService,
+ licenseService
+}: TPamFolderAlertProviderDep): IEventAlertProvider<TPamAccessRequestTarget> => {
+ // The folder's Approvals tab lists every request, while the approval inbox only shows the visitor's own queue.
+ const buildViewUrl = async (alert: TAlertContext): Promise<string> =>
+ `${getConfig().SITE_URL}/organizations/${alert.orgId}/pam/accounts?folderId=${alert.resourceId}&tab=approvals`;
+
+ const findEventTargets = async (input: TFindEventTargetsInput): Promise<TPamAccessRequestTarget[]> => {
+ if (!input.projectId || !input.resourceId) return [];
+ EventConditionSchema.parse(input.condition);
+
+ const eventType = input.eventType as PamAccessRequestEvent;
+ const folderId = input.resourceId;
+ const requests = (
+ await pamFolderAlertDAL.findAccessRequestsByIds({
+ orgId: input.orgId,
+ projectId: input.projectId,
+ requestIds: input.targetIds
+ })
+ ).flatMap((request) => {
+ const parsed = RequestDataSchema.safeParse(request.requestData);
+ return parsed.success && parsed.data.requestData.folderId === folderId
+ ? [{ ...request, inputs: parsed.data.requestData }]
+ : [];
+ });
+ if (requests.length === 0) return [];
+
+ const requestIds = requests.map((request) => request.id);
+ const decision = DECISION_BY_EVENT[eventType];
+ const [folder, accounts, decisions, grants] = await Promise.all([
+ pamFolderAlertDAL.findFolderById(folderId, { readFromPrimary: true }),
+ pamFolderAlertDAL.findAccountNamesByIds({
+ projectId: input.projectId,
+ accountIds: requests.flatMap((request) => (request.inputs.accountId ? [request.inputs.accountId] : []))
+ }),
+ decision ? pamFolderAlertDAL.findDecisionCommentsByRequestIds({ requestIds, decision }) : [],
+ eventType === PamAccessRequestEvent.Bypassed ? pamFolderAlertDAL.findBypassReasonsByRequestIds(requestIds) : []
+ ]);
+ if (!folder) return [];
+
+ const accountNameById = new Map(accounts.map((account) => [account.id, account.name]));
+ // Rows come back oldest first, so the last decision per request wins.
+ const commentByRequestId = new Map(decisions.map((row) => [row.requestId, row.comment]));
+ const bypassReasonByRequestId = new Map(grants.map((row) => [row.requestId, row.bypassReason]));
+
+ return requests.map((request) => ({
+ requestId: request.id,
+ folderName: folder.name,
+ accountName: accountNameById.get(request.inputs.accountId ?? "") ?? null,
+ requesterName: request.requesterName,
+ requesterLabel: toRequesterLabel(request),
+ accessType: request.inputs.accessType ?? PamAccessType.Session,
+ duration: request.inputs.duration,
+ reason: request.inputs.reason,
+ comment: commentByRequestId.get(request.id) || null,
+ bypassReason: bypassReasonByRequestId.get(request.id) || null
+ }));
+ };
+
+ const buildPayload = (alert: TAlertContext, targets: TPamAccessRequestTarget[], viewUrl: string): TAlertPayload => {
+ const eventType = alert.eventType as PamAccessRequestEvent;
+
+ return {
+ alert: {
+ id: alert.id,
+ name: alert.name,
+ orgId: alert.orgId,
+ ...(alert.projectId ? { projectId: alert.projectId } : {}),
+ resourceType: alert.resourceType,
+ ...(alert.resourceId ? { resourceId: alert.resourceId } : {}),
+ viewUrl
+ },
+ eventKey: eventType,
+ eventLabel: EVENT_LABELS[eventType],
+ webhookType: `com.infisical.${eventType}`,
+ resourceKind: "PAM Access",
+ resourceOwnerKind: "Folder",
+ severity: EVENT_SEVERITY[eventType],
+ summary: describeTarget(eventType, targets[0]),
+ items: targets.map((target) => ({
+ id: target.requestId,
+ title: target.accountName ?? "Deleted account",
+ summary: describeTarget(eventType, target),
+ fields: [
+ { label: "Requester", value: target.requesterLabel },
+ { label: "Folder", value: target.folderName },
+ { label: "Access Type", value: target.accessType === PamAccessType.Credential ? "Credentials" : "Session" },
+ ...(target.duration ? [{ label: "Duration", value: formatDuration(target.duration) }] : []),
+ ...(target.reason ? [{ label: "Reason", value: target.reason }] : []),
+ ...(target.comment ? [{ label: "Reviewer Comment", value: target.comment }] : []),
+ ...(target.bypassReason && target.bypassReason !== target.reason
+ ? [{ label: "Break-Glass Reason", value: target.bypassReason }]
+ : [])
+ ]
+ }))
+ };
+ };
+
+ const assertResourceInScope = async ({
+ orgId,
+ projectId,
+ resourceId
+ }: {
+ orgId: string;
+ projectId?: string | null;
+ resourceId?: string | null;
+ }): Promise<void> => {
+ if (!resourceId) return;
+ assertValidFolderId(resourceId);
+
+ const folder = await pamFolderAlertDAL.findFolderById(resourceId);
+ if (!folder || folder.orgId !== orgId || folder.projectId !== projectId) {
+ throw new NotFoundError({ message: `PAM folder with ID '${resourceId}' not found` });
+ }
+ };
+
+ const assertPermission = async ({
+ action,
+ orgId,
+ projectId,
+ resourceId,
+ actor
+ }: TAlertPermissionInput): Promise<void> => {
+ if (!projectId || !resourceId) {
+ throw new BadRequestError({ message: "PAM folder alerts require the PAM project ID and a folder ID" });
+ }
+
+ await verifyProductMembership(permissionService, projectId, actor);
+ await assertResourceInScope({ orgId, projectId, resourceId });
+
+ const { permission } = await checkFolderPermission(permissionService, resourceId, projectId, actor);
- const isRead = action === AlertPermissionAction.Read;
+ if (
- permission.can(ResourcePermissionPamResourceActions.ManagePolicies, ResourcePermissionSub.PamResource) ||
- (isRead && permission.can(ResourcePermissionPamResourceActions.ViewAuditLogs, ResourcePermissionSub.PamResource))
++ action === AlertPermissionAction.Read &&
++ permission.can(ResourcePermissionPamResourceActions.ViewAuditLogs, ResourcePermissionSub.PamResource)
+ ) {
+ return;
+ }
-
- throw new ForbiddenRequestError({
- message: isRead
- ? "You need permission to manage approvals or view audit logs on this folder to see its alerts"
- : "You need permission to manage approvals on this folder to change its alerts"
- });
++ ForbiddenError.from(permission).throwUnlessCan(
++ ResourcePermissionPamResourceActions.ManagePolicies,
++ ResourcePermissionSub.PamResource
++ );
+ };
+
+ const assertChannelTypesAllowed = async ({ orgId, channelTypes }: { orgId: string; channelTypes: string[] }) => {
+ const gatedType = channelTypes.find((channelType) => channelType !== AlertChannelType.EMAIL);
+ if (!gatedType) return;
+
+ const plan = await licenseService.getPlan(orgId);
+ if (!plan.pamEnterpriseAlerting) {
+ throw new BadRequestError({
+ message: `Failed to add a ${gatedType} channel due to plan restriction. Upgrade plan to send PAM alerts to channels other than email.`
+ });
+ }
+ };
+
- const getAuditEvent = (input: TAlertAuditInput): TAuditEvent => {
- if (input.action === AlertAuditAction.TestChannel) {
- const { test } = input;
- return {
- type: EventType.PAM_FOLDER_ALERT_CHANNEL_TEST,
- metadata: {
- ...(test.resourceId ? { folderId: test.resourceId } : {}),
- folderName: test.resourceName ?? null,
- alertId: test.alertId,
- alertName: test.alertName ?? null,
- channelId: test.channelId,
- channelName: test.channelName ?? null,
- channelType: test.channelType,
- success: test.success,
- deliveredTo: test.deliveredTo,
- error: test.error
- }
- };
- }
-
- const metadata = {
- ...(input.alert.resourceId ? { folderId: input.alert.resourceId } : {}),
- folderName: input.alert.resourceName ?? null,
- alertId: input.alert.id,
- name: input.alert.name,
- eventType: input.alert.eventType
- };
- if (input.action === AlertAuditAction.Create) return { type: EventType.PAM_FOLDER_ALERT_CREATE, metadata };
- if (input.action === AlertAuditAction.Update) return { type: EventType.PAM_FOLDER_ALERT_UPDATE, metadata };
- return { type: EventType.PAM_FOLDER_ALERT_DELETE, metadata };
- };
-
+ return {
+ resourceType: PAM_FOLDER_RESOURCE_TYPE,
+ events: Object.values(PamAccessRequestEvent).map((key) => ({
+ key,
+ triggerType: AlertTriggerType.Event,
+ conditionSchema: EventConditionSchema
+ })),
+ findEventTargets,
+ buildViewUrl,
+ buildPayload,
+ targetId: (target) => target.requestId,
+ assertPermission,
+ assertResourceInScope,
- assertChannelTypesAllowed,
- getAuditEvent,
- getResourceNames: async ({ orgId, resourceIds }) =>
- new Map(
- (await pamFolderAlertDAL.findFolderNamesByIds({ orgId, folderIds: resourceIds })).map((folder) => [
- folder.id,
- folder.name
- ])
- )
++ assertChannelTypesAllowed
+ };
+};
diff --cc backend/src/services/approval-policy/approval-request-fns.ts
index e125bc3eb2,9d24944c58..f1c8b9f904
--- a/backend/src/services/approval-policy/approval-request-fns.ts
+++ b/backend/src/services/approval-policy/approval-request-fns.ts
@@@ -72,11 -119,8 +119,9 @@@ export const createApprovalRequestWithS
}: TCreateApprovalRequestWithStepsParams,
dependencies: {
approvalRequestDAL: Pick<TApprovalRequestDALFactory, "create" | "transaction">;
- approvalRequestStepsDAL: Pick<TApprovalRequestStepsDALFactory, "create">;
- approvalRequestStepEligibleApproversDAL: Pick<TApprovalRequestStepEligibleApproversDALFactory, "create">;
- },
+ } & TInsertApprovalRequestStepsDeps,
- externalTx?: Knex
+ externalTx?: Knex,
+ onCreated?: (request: TApprovalRequests, tx: Knex) => Promise<void>
): Promise<TApprovalRequestWithSteps> => {
const { approvalRequestDAL, approvalRequestStepsDAL, approvalRequestStepEligibleApproversDAL } = dependencies;
@@@ -102,44 -146,12 +147,13 @@@
tx
);
- const newSteps = await Promise.all(
- policySteps.map(async (step, i) => {
- const stepNum = i + 1;
- const newStep = await approvalRequestStepsDAL.create(
- {
- requestId: newRequest.id,
- stepNumber: stepNum,
- name: step.name ?? null,
- status: stepNum === 1 ? ApprovalRequestStepStatus.InProgress : ApprovalRequestStepStatus.Pending,
- requiredApprovals: step.requiredApprovals,
- notifyApprovers: step.notifyApprovers ?? false,
- startedAt: stepNum === 1 ? new Date() : null
- },
- tx
- );
-
- await Promise.all(
- step.approvers.map((approver) =>
- approvalRequestStepEligibleApproversDAL.create(
- {
- stepId: newStep.id,
- userId: approver.type === ApproverType.User ? approver.id : null,
- groupId: approver.type === ApproverType.Group ? approver.id : null
- },
- tx
- )
- )
- );
-
- return {
- ...newStep,
- approvers: step.approvers,
- approvals: []
- };
- })
+ const newSteps = await insertApprovalRequestSteps(
+ { requestId: newRequest.id, policySteps },
+ { approvalRequestStepsDAL, approvalRequestStepEligibleApproversDAL },
+ tx
);
+ await onCreated?.(newRequest, tx);
return { request: newRequest, steps: newSteps };
};
diff --cc frontend/src/hooks/api/alerts/types.ts
index d56ff5d2c6,a75883b7f6..144d08f47d
--- a/frontend/src/hooks/api/alerts/types.ts
+++ b/frontend/src/hooks/api/alerts/types.ts
@@@ -1,8 -1,9 +1,10 @@@
import { z } from "zod";
+ import { CertSource } from "@app/hooks/api/certificates/enums";
+
export enum AlertResourceType {
- IdentityAuthentication = "identity.authentication"
+ IdentityAuthentication = "identity.authentication",
+ PamFolder = "pam.folder"
}
export enum AlertEventType {
@@@ -60,10 -61,10 +79,11 @@@ export enum CertificateManagerAlertEven
export const MIN_ALERT_BEFORE_DAYS = 1;
export const MAX_ALERT_BEFORE_DAYS = 90;
export const MAX_CERTIFICATE_ALERT_BEFORE_DAYS = 365;
+ export const MAX_CERTIFICATE_ALERT_FILTER_IDS = 100;
export const ALERT_RESOURCE_TYPE_LABELS: Record<AlertResourceType, string> = {
- [AlertResourceType.IdentityAuthentication]: "Machine Identity Authentication"
+ [AlertResourceType.IdentityAuthentication]: "Machine Identity Authentication",
+ [AlertResourceType.PamFolder]: "PAM Folder"
};
export const ALERT_EVENT_TYPE_LABELS: Record<AlertEventType, string> = {