Finish docs for pki alerting + expose endpoints

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

@@ -1,13 +1,72 @@
 import { TDbClient } from "@app/db";
-import { TableName } from "@app/db/schemas";
+import { TableName, TPkiCollectionItems } from "@app/db/schemas";
 import { DatabaseError } from "@app/lib/errors";
 import { ormify } from "@app/lib/knex";
 
+import { PkiItemType } from "./pki-collection-types";
+
 export type TPkiCollectionItemDALFactory = ReturnType<typeof pkiCollectionItemDALFactory>;
 
 export const pkiCollectionItemDALFactory = (db: TDbClient) => {
   const pkiCollectionItemOrm = ormify(db, TableName.PkiCollectionItem);
 
+  const findPkiCollectionItems = async ({
+    collectionId,
+    type,
+    offset,
+    limit
+  }: {
+    collectionId: string;
+    type?: PkiItemType;
+    offset?: number;
+    limit?: number;
+  }) => {
+    try {
+      const query = db
+        .replicaNode()(TableName.PkiCollectionItem)
+        .select(
+          "pki_collection_items.*",
+          db.raw(
+            `COALESCE("${TableName.CertificateAuthority}"."notBefore", "${TableName.Certificate}"."notBefore") as "notBefore"`
+          ),
+          db.raw(
+            `COALESCE("${TableName.CertificateAuthority}"."notAfter", "${TableName.Certificate}"."notAfter") as "notAfter"`
+          ),
+          db.raw(
+            `COALESCE("${TableName.CertificateAuthority}"."friendlyName", "${TableName.Certificate}"."friendlyName") as "friendlyName"`
+          )
+        )
+        .leftJoin(
+          TableName.CertificateAuthority,
+          `${TableName.PkiCollectionItem}.caId`,
+          `${TableName.CertificateAuthority}.id`
+        )
+        .leftJoin(TableName.Certificate, `${TableName.PkiCollectionItem}.certId`, `${TableName.Certificate}.id`)
+        .where((builder) => {
+          void builder.where(`${TableName.PkiCollectionItem}.pkiCollectionId`, collectionId);
+          if (type === PkiItemType.CA) {
+            void builder.whereNull(`${TableName.PkiCollectionItem}.certId`);
+          } else if (type === PkiItemType.CERTIFICATE) {
+            void builder.whereNull(`${TableName.PkiCollectionItem}.caId`);
+          }
+        });
+
+      if (offset) {
+        void query.offset(offset);
+      }
+      if (limit) {
+        void query.limit(limit);
+      }
+
+      void query.orderBy(`${TableName.PkiCollectionItem}.createdAt`, "desc");
+
+      const result = await query;
+      return result as (TPkiCollectionItems & { notAfter: Date; notBefore: Date; friendlyName: string })[];
+    } catch (error) {
+      throw new DatabaseError({ error, name: "Find all PKI collection items" });
+    }
+  };
+
   const countItemsInPkiCollection = async (collectionId: string) => {
     try {
       interface CountResult {
@@ -28,6 +87,7 @@ export const pkiCollectionItemDALFactory = (db: TDbClient) => {
 
   return {
     ...pkiCollectionItemOrm,
+    findPkiCollectionItems,
     countItemsInPkiCollection
   };
 };

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

@@ -144,6 +144,7 @@ export const pkiCollectionServiceFactory = ({
 
   const getPkiCollectionItems = async ({
     collectionId,
+    type,
     offset = 0,
     limit = 25,
     actorId,
@@ -164,16 +165,23 @@ export const pkiCollectionServiceFactory = ({
 
     ForbiddenError.from(permission).throwUnlessCan(ProjectPermissionActions.Read, ProjectPermissionSub.PkiCollections);
 
-    const pkiCollectionItems = await pkiCollectionItemDAL.find(
-      { pkiCollectionId: collectionId },
-      { offset, limit, sort: [["createdAt", "desc"]] }
-    );
+    const pkiCollectionItems = await pkiCollectionItemDAL.findPkiCollectionItems({
+      collectionId,
+      type,
+      offset,
+      limit
+    });
 
     const count = await pkiCollectionItemDAL.countItemsInPkiCollection(collectionId);
 
     return {
       pkiCollection,
-      pkiCollectionItems: pkiCollectionItems.map(transformPkiCollectionItem),
+      pkiCollectionItems: pkiCollectionItems.map((p) => ({
+        ...transformPkiCollectionItem(p),
+        notBefore: p.notBefore,
+        notAfter: p.notAfter,
+        friendlyName: p.friendlyName
+      })),
       totalCount: count
     };
   };

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

@@ -22,8 +22,14 @@ export enum PkiItemType {
   CA = "ca"
 }
 
+export const pkiItemTypeToNameMap: { [K in PkiItemType]: string } = {
+  [PkiItemType.CA]: "CA",
+  [PkiItemType.CERTIFICATE]: "Certificate"
+};
+
 export type TGetPkiCollectionItems = {
   collectionId: string;
+  type?: PkiItemType;
   offset: number;
   limit: number;
 } & Omit<TProjectPermission, "projectId">;