Added pki collection table, pki alert modal

backend/src/services/alert/alert-service.ts

@@ -2,22 +2,25 @@ import { ForbiddenError } from "@casl/ability";
 
 import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service";
 import { ProjectPermissionActions, ProjectPermissionSub } from "@app/ee/services/permission/project-permission";
-import { NotFoundError } from "@app/lib/errors";
+import { NotFoundError, UnauthorizedError } from "@app/lib/errors";
+import { TPkiCollectionDALFactory } from "@app/services/pki-collection/pki-collection-dal";
 
 import { TAlertDALFactory } from "./alert-dal";
 import { TCreateAlertDTO, TDeleteAlertDTO, TGetAlertByIdDTO, TUpdateAlertDTO } from "./alert-types";
 
 type TAlertServiceFactoryDep = {
   alertDAL: TAlertDALFactory;
+  pkiCollectionDAL: TPkiCollectionDALFactory;
   permissionService: Pick<TPermissionServiceFactory, "getProjectPermission">;
 };
 
 export type TAlertServiceFactory = ReturnType<typeof alertServiceFactory>;
 
-export const alertServiceFactory = ({ alertDAL, permissionService }: TAlertServiceFactoryDep) => {
-  const createAlert = async ({
+export const alertServiceFactory = ({ alertDAL, pkiCollectionDAL, permissionService }: TAlertServiceFactoryDep) => {
+  const createPkiAlert = async ({
     projectId,
     name,
+    pkiCollectionId,
     alertBeforeDays,
     emails,
     actorId,
@@ -33,10 +36,16 @@ export const alertServiceFactory = ({ alertDAL, permissionService }: TAlertServi
       actorOrgId
     );
 
-    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Create, ProjectPermissionSub.Alerts);
+    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Create, ProjectPermissionSub.PkiAlerts);
+
+    const pkiCollection = await pkiCollectionDAL.findById(pkiCollectionId);
+    if (!pkiCollection) throw new NotFoundError({ message: "PKI collection not found" });
+    if (pkiCollection.projectId !== projectId)
+      throw new UnauthorizedError({ message: "PKI collection not found in project" });
 
     const alert = await alertDAL.create({
       projectId,
+      pkiCollectionId,
       name,
       alertBeforeDays,
       recipientEmails: emails.join(",")
@@ -44,7 +53,7 @@ export const alertServiceFactory = ({ alertDAL, permissionService }: TAlertServi
     return alert;
   };
 
-  const getAlertById = async ({ alertId, actorId, actorAuthMethod, actor, actorOrgId }: TGetAlertByIdDTO) => {
+  const getPkiAlertById = async ({ alertId, actorId, actorAuthMethod, actor, actorOrgId }: TGetAlertByIdDTO) => {
     const alert = await alertDAL.findById(alertId);
     if (!alert) throw new NotFoundError({ message: "Alert not found" });
 
@@ -56,13 +65,14 @@ export const alertServiceFactory = ({ alertDAL, permissionService }: TAlertServi
       actorOrgId
     );
 
-    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Read, ProjectPermissionSub.Alerts);
+    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Read, ProjectPermissionSub.PkiAlerts);
     return alert;
   };
 
-  const updateAlert = async ({
+  const updatePkiAlert = async ({
     alertId,
     name,
+    pkiCollectionId,
     alertBeforeDays,
     emails,
     actorId,
@@ -81,17 +91,26 @@ export const alertServiceFactory = ({ alertDAL, permissionService }: TAlertServi
       actorOrgId
     );
 
-    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Create, ProjectPermissionSub.Alerts);
+    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Edit, ProjectPermissionSub.PkiAlerts);
+
+    if (pkiCollectionId) {
+      const pkiCollection = await pkiCollectionDAL.findById(pkiCollectionId);
+      if (!pkiCollection) throw new NotFoundError({ message: "PKI collection not found" });
+      if (pkiCollection.projectId !== alert.projectId)
+        throw new UnauthorizedError({ message: "PKI collection not found in project" });
+    }
+
     alert = await alertDAL.updateById(alertId, {
       name,
       alertBeforeDays,
-      recipientEmails: emails ? emails.join(",") : undefined
+      ...(pkiCollectionId && { pkiCollectionId }),
+      ...(emails && { recipientEmails: emails.join(",") }) // TODO: standardize recipient emails
     });
 
     return alert;
   };
 
-  const deleteAlert = async ({ alertId, actorId, actorAuthMethod, actor, actorOrgId }: TDeleteAlertDTO) => {
+  const deletePkiAlert = async ({ alertId, actorId, actorAuthMethod, actor, actorOrgId }: TDeleteAlertDTO) => {
     let alert = await alertDAL.findById(alertId);
     if (!alert) throw new NotFoundError({ message: "Alert not found" });
 
@@ -103,15 +122,15 @@ export const alertServiceFactory = ({ alertDAL, permissionService }: TAlertServi
       actorOrgId
     );
 
-    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Create, ProjectPermissionSub.Alerts);
+    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Delete, ProjectPermissionSub.PkiAlerts);
     alert = await alertDAL.deleteById(alertId);
     return alert;
   };
 
   return {
-    createAlert,
-    getAlertById,
-    updateAlert,
-    deleteAlert
+    createPkiAlert,
+    getPkiAlertById,
+    updatePkiAlert,
+    deletePkiAlert
   };
 };

backend/src/services/alert/alert-types.ts

@@ -2,6 +2,7 @@ import { TProjectPermission } from "@app/lib/types";
 
 export type TCreateAlertDTO = {
   name: string;
+  pkiCollectionId: string;
   alertBeforeDays: number;
   emails: string[];
 } & TProjectPermission;
@@ -13,6 +14,7 @@ export type TGetAlertByIdDTO = {
 export type TUpdateAlertDTO = {
   alertId: string;
   name?: string;
+  pkiCollectionId?: string;
   alertBeforeDays?: number;
   emails?: string[];
 } & Omit<TProjectPermission, "projectId">;

backend/src/services/pki-collection/pki-collection-dal.ts

@@ -0,0 +1,13 @@
+import { TDbClient } from "@app/db";
+import { TableName } from "@app/db/schemas";
+import { ormify } from "@app/lib/knex";
+
+export type TPkiCollectionDALFactory = ReturnType<typeof pkiCollectionDALFactory>;
+
+export const pkiCollectionDALFactory = (db: TDbClient) => {
+  const pkiCollectionOrm = ormify(db, TableName.PkiCollection);
+
+  return {
+    ...pkiCollectionOrm
+  };
+};

backend/src/services/pki-collection/pki-collection-service.ts

@@ -0,0 +1,138 @@
+import { ForbiddenError } from "@casl/ability";
+
+import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service";
+import { ProjectPermissionActions, ProjectPermissionSub } from "@app/ee/services/permission/project-permission";
+import { NotFoundError } from "@app/lib/errors";
+
+import { TPkiCollectionDALFactory } from "./pki-collection-dal";
+import {
+  TCreatePkiCollectionDTO,
+  TDeletePkiCollectionDTO,
+  TGetPkiCollectionByIdDTO,
+  TUpdatePkiCollectionDTO
+} from "./pki-collection-types";
+
+type TPkiCollectionServiceFactoryDep = {
+  pkiCollectionDAL: TPkiCollectionDALFactory;
+  permissionService: Pick<TPermissionServiceFactory, "getProjectPermission">;
+};
+
+export type TPkiCollectionServiceFactory = ReturnType<typeof pkiCollectionServiceFactory>;
+
+export const pkiCollectionServiceFactory = ({
+  pkiCollectionDAL,
+  permissionService
+}: TPkiCollectionServiceFactoryDep) => {
+  const createPkiCollection = async ({
+    name,
+    projectId,
+    actorId,
+    actorAuthMethod,
+    actor,
+    actorOrgId
+  }: TCreatePkiCollectionDTO) => {
+    const { permission } = await permissionService.getProjectPermission(
+      actor,
+      actorId,
+      projectId,
+      actorAuthMethod,
+      actorOrgId
+    );
+
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Create,
+      ProjectPermissionSub.PkiCollections
+    );
+
+    const pkiCollection = await pkiCollectionDAL.create({
+      projectId,
+      name
+    });
+
+    return pkiCollection;
+  };
+
+  const getPkiCollectionById = async ({
+    collectionId,
+    actorId,
+    actorAuthMethod,
+    actor,
+    actorOrgId
+  }: TGetPkiCollectionByIdDTO) => {
+    const pkiCollection = await pkiCollectionDAL.findById(collectionId);
+    if (!pkiCollection) throw new NotFoundError({ message: "PKI collection not found" });
+
+    const { permission } = await permissionService.getProjectPermission(
+      actor,
+      actorId,
+      pkiCollection.projectId,
+      actorAuthMethod,
+      actorOrgId
+    );
+
+    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Read, ProjectPermissionSub.PkiCollections);
+    return pkiCollection;
+  };
+
+  const updatePkiCollection = async ({
+    collectionId,
+    name,
+    actorId,
+    actorAuthMethod,
+    actor,
+    actorOrgId
+  }: TUpdatePkiCollectionDTO) => {
+    let pkiCollection = await pkiCollectionDAL.findById(collectionId);
+    if (!pkiCollection) throw new NotFoundError({ message: "PKI collection not found" });
+
+    const { permission } = await permissionService.getProjectPermission(
+      actor,
+      actorId,
+      pkiCollection.projectId,
+      actorAuthMethod,
+      actorOrgId
+    );
+
+    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Edit, ProjectPermissionSub.PkiCollections);
+    pkiCollection = await pkiCollectionDAL.updateById(collectionId, {
+      name
+    });
+
+    return pkiCollection;
+  };
+
+  const deletePkiCollection = async ({
+    collectionId,
+    actorId,
+    actorAuthMethod,
+    actor,
+    actorOrgId
+  }: TDeletePkiCollectionDTO) => {
+    let pkiCollection = await pkiCollectionDAL.findById(collectionId);
+    if (!pkiCollection) throw new NotFoundError({ message: "PKI collection not found" });
+
+    const { permission } = await permissionService.getProjectPermission(
+      actor,
+      actorId,
+      pkiCollection.projectId,
+      actorAuthMethod,
+      actorOrgId
+    );
+
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Create,
+      ProjectPermissionSub.PkiCollections
+    );
+    pkiCollection = await pkiCollectionDAL.deleteById(collectionId);
+    return pkiCollection;
+  };
+
+  // TODO: add/remove pki collection items
+
+  return {
+    createPkiCollection,
+    getPkiCollectionById,
+    updatePkiCollection,
+    deletePkiCollection
+  };
+};

backend/src/services/pki-collection/pki-collection-types.ts

@@ -0,0 +1,18 @@
+import { TProjectPermission } from "@app/lib/types";
+
+export type TCreatePkiCollectionDTO = {
+  name: string;
+} & TProjectPermission;
+
+export type TGetPkiCollectionByIdDTO = {
+  collectionId: string;
+} & Omit<TProjectPermission, "projectId">;
+
+export type TUpdatePkiCollectionDTO = {
+  collectionId: string;
+  name?: string;
+} & Omit<TProjectPermission, "projectId">;
+
+export type TDeletePkiCollectionDTO = {
+  collectionId: string;
+} & Omit<TProjectPermission, "projectId">;

backend/src/services/project/project-service.ts

@@ -23,6 +23,7 @@ import { TIdentityProjectMembershipRoleDALFactory } from "../identity-project/id
 import { TKmsServiceFactory } from "../kms/kms-service";
 import { TOrgDALFactory } from "../org/org-dal";
 import { TOrgServiceFactory } from "../org/org-service";
+import { TPkiCollectionDALFactory } from "../pki-collection/pki-collection-dal";
 import { TProjectBotDALFactory } from "../project-bot/project-bot-dal";
 import { TProjectEnvDALFactory } from "../project-env/project-env-dal";
 import { TProjectKeyDALFactory } from "../project-key/project-key-dal";
@@ -73,6 +74,7 @@ type TProjectServiceFactoryDep = {
   certificateAuthorityDAL: Pick<TCertificateAuthorityDALFactory, "find">;
   certificateDAL: Pick<TCertificateDALFactory, "find" | "countCertificatesInProject">;
   alertDAL: Pick<TAlertDALFactory, "find">;
+  pkiCollectionDAL: Pick<TPkiCollectionDALFactory, "find">;
   permissionService: TPermissionServiceFactory;
   orgService: Pick<TOrgServiceFactory, "addGhostUser">;
   licenseService: Pick<TLicenseServiceFactory, "getPlan">;
@@ -110,6 +112,7 @@ export const projectServiceFactory = ({
   identityProjectMembershipRoleDAL,
   certificateAuthorityDAL,
   certificateDAL,
+  pkiCollectionDAL,
   alertDAL,
   keyStore,
   kmsService,
@@ -698,7 +701,7 @@ export const projectServiceFactory = ({
       actorOrgId
     );
 
-    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Read, ProjectPermissionSub.Alerts);
+    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Read, ProjectPermissionSub.PkiAlerts);
 
     const alerts = await alertDAL.find({ projectId });
 
@@ -707,6 +710,33 @@ export const projectServiceFactory = ({
     };
   };
 
+  /**
+   * Return list of PKI collections for project
+   */
+  const listProjectPkiCollections = async ({
+    projectId,
+    actor,
+    actorId,
+    actorAuthMethod,
+    actorOrgId
+  }: TListProjectAlertsDTO) => {
+    const { permission } = await permissionService.getProjectPermission(
+      actor,
+      actorId,
+      projectId,
+      actorAuthMethod,
+      actorOrgId
+    );
+
+    ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Read, ProjectPermissionSub.PkiCollections);
+
+    const pkiCollections = await pkiCollectionDAL.find({ projectId });
+
+    return {
+      pkiCollections
+    };
+  };
+
   const updateProjectKmsKey = async ({
     projectId,
     kms,
@@ -826,6 +856,7 @@ export const projectServiceFactory = ({
     listProjectCas,
     listProjectCertificates,
     listProjectAlerts,
+    listProjectPkiCollections,
     updateVersionLimit,
     updateAuditLogsRetention,
     updateProjectKmsKey,