Continue cert mgmt mvp

frontend/src/hooks/api/ca/constants.tsx

@@ -1,6 +1,12 @@
-import { CertificateAuthorityType } from "./enums";
+import { CaStatus,CaType } from "./enums";
 
-export const caTypeToNameMap: { [K in CertificateAuthorityType]: string } = {
-  [CertificateAuthorityType.ROOT]: "Root",
-  [CertificateAuthorityType.INTERMEDIATE]: "Intermediate"
+export const caTypeToNameMap: { [K in CaType]: string } = {
+  [CaType.ROOT]: "Root",
+  [CaType.INTERMEDIATE]: "Intermediate"
+};
+
+export const caStatusToNameMap: { [K in CaStatus]: string } = {
+  [CaStatus.ACTIVE]: "Active",
+  [CaStatus.DISABLED]: "Disabled",
+  [CaStatus.PENDING_CERTIFICATE]: "Pending Certificate"
 };

frontend/src/hooks/api/ca/enums.tsx

@@ -1,4 +1,10 @@
-export enum CertificateAuthorityType {
+export enum CaType {
   ROOT = "root",
   INTERMEDIATE = "intermediate"
 }
+
+export enum CaStatus {
+  ACTIVE = "active",
+  DISABLED = "disabled",
+  PENDING_CERTIFICATE = "pending-certificate"
+}

frontend/src/hooks/api/ca/index.tsx

@@ -1,2 +1,9 @@
-export { CertificateAuthorityType } from "./enums";
-export { useCreateCa } from "./mutations";
+export { CaStatus,CaType } from "./enums";
+export {
+  useCreateCa,
+  useCreateCertificate,
+  useDeleteCa,
+  useImportCaCertificate,
+  useSignIntermediate,
+  useUpdateCa} from "./mutations";
+export { useGetCaById, useGetCaCert, useGetCaCsr } from "./queries";

frontend/src/hooks/api/ca/mutations.tsx

@@ -1,23 +1,107 @@
-import {
-  useMutation
-  // useQueryClient
-} from "@tanstack/react-query";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
 
 import { apiRequest } from "@app/config/request";
 
-import { TCertificateAuthority, TCreateCaDTO } from "./types";
+import { workspaceKeys } from "../workspace/queries";
+import {
+  TCertificateAuthority,
+  TCreateCaDTO,
+  TCreateCertificateDTO,
+  TCreateCertificateResponse,
+  TDeleteCaDTO,
+  TImportCaCertificateDTO,
+  TImportCaCertificateResponse,
+  TSignIntermediateDTO,
+  TSignIntermediateResponse,
+  TUpdateCaDTO} from "./types";
 
 export const useCreateCa = () => {
-  // const queryClient = useQueryClient();
+  const queryClient = useQueryClient();
   return useMutation<TCertificateAuthority, {}, TCreateCaDTO>({
     mutationFn: async (body) => {
       const {
-        data: { identity }
-      } = await apiRequest.post("/api/v1/ca/", body);
-      return identity;
+        data: { ca }
+      } = await apiRequest.post<{ ca: TCertificateAuthority }>("/api/v1/ca/", body);
+      return ca;
     },
-    onSuccess: () => {
-      //   queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+    onSuccess: (_, { projectSlug }) => {
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceCas({ projectSlug }));
+    }
+  });
+};
+
+export const useUpdateCa = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TCertificateAuthority, {}, TUpdateCaDTO>({
+    mutationFn: async ({ caId, projectSlug, ...body }) => {
+      const {
+        data: { ca }
+      } = await apiRequest.patch<{ ca: TCertificateAuthority }>(`/api/v1/ca/${caId}`, body);
+      return ca;
+    },
+    onSuccess: (_, { projectSlug }) => {
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceCas({ projectSlug }));
+    }
+  });
+};
+
+export const useDeleteCa = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TCertificateAuthority, {}, TDeleteCaDTO>({
+    mutationFn: async ({ caId }) => {
+      const {
+        data: { ca }
+      } = await apiRequest.delete<{ ca: TCertificateAuthority }>(`/api/v1/ca/${caId}`);
+      return ca;
+    },
+    onSuccess: (_, { projectSlug }) => {
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceCas({ projectSlug }));
+    }
+  });
+};
+
+export const useSignIntermediate = () => {
+  // TODO: consider renaming
+  return useMutation<TSignIntermediateResponse, {}, TSignIntermediateDTO>({
+    mutationFn: async (body) => {
+      const { data } = await apiRequest.post<TSignIntermediateResponse>(
+        `/api/v1/ca/${body.caId}/sign-intermediate`,
+        body
+      );
+      return data;
+    }
+  });
+};
+
+export const useImportCaCertificate = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TImportCaCertificateResponse, {}, TImportCaCertificateDTO>({
+    mutationFn: async ({ caId, ...body }) => {
+      const { data } = await apiRequest.post<TImportCaCertificateResponse>(
+        `/api/v1/ca/${caId}/import-certificate`,
+        body
+      );
+      return data;
+    },
+    onSuccess: (_, { projectSlug }) => {
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceCas({ projectSlug }));
+    }
+  });
+};
+
+// consider rename to issue certificate
+export const useCreateCertificate = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TCreateCertificateResponse, {}, TCreateCertificateDTO>({
+    mutationFn: async ({ caId, ...body }) => {
+      const { data } = await apiRequest.post<TCreateCertificateResponse>(
+        `/api/v1/ca/${caId}/issue-certificate`,
+        body
+      );
+      return data;
+    },
+    onSuccess: (_, { projectSlug }) => {
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceCertificates(projectSlug));
     }
   });
 };

frontend/src/hooks/api/ca/queries.tsx

@@ -0,0 +1,54 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { TCertificateAuthority } from "./types";
+
+export const caKeys = {
+  getCaById: (caId: string) => [{ caId }, "ca"],
+  getCaCert: (caId: string) => [{ caId }, "ca-cert"],
+  getCaCsr: (caId: string) => [{ caId }, "ca-csr"]
+};
+
+export const useGetCaById = (caId: string) => {
+  return useQuery({
+    queryKey: caKeys.getCaById(caId),
+    queryFn: async () => {
+      const {
+        data: { ca }
+      } = await apiRequest.get<{ ca: TCertificateAuthority }>(`/api/v1/ca/${caId}`);
+      return ca;
+    },
+    enabled: Boolean(caId)
+  });
+};
+
+export const useGetCaCert = (caId: string) => {
+  return useQuery({
+    queryKey: caKeys.getCaCert(caId),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<{
+        certificate: string;
+        certificateChain: string;
+        serialNumber: string;
+      }>(`/api/v1/ca/${caId}/certificate`);
+      return data;
+    },
+    enabled: Boolean(caId)
+  });
+};
+
+export const useGetCaCsr = (caId: string) => {
+  return useQuery({
+    queryKey: caKeys.getCaCsr(caId),
+    queryFn: async () => {
+      const {
+        data: { csr }
+      } = await apiRequest.get<{
+        csr: string;
+      }>(`/api/v1/ca/${caId}/csr`);
+      return csr;
+    },
+    enabled: Boolean(caId)
+  });
+};

frontend/src/hooks/api/ca/types.ts

@@ -1,12 +1,21 @@
-import { CertificateAuthorityType } from "./enums";
+import { CaStatus,CaType } from "./enums";
 
 export type TCertificateAuthority = {
   id: string;
   parentCaId?: string;
   projectId: string;
-  type: CertificateAuthorityType;
-  dn: string;
+  type: CaType;
+  status: CaStatus;
+  organization: string;
+  ou: string;
+  country: string;
+  province: string;
+  locality: string;
   commonName: string;
+  dn: string;
+  maxPathLength?: number;
+  notAfter?: string;
+  notBefore?: string;
   createdAt: string;
   updatedAt: string;
 };
@@ -20,4 +29,62 @@ export type TCreateCaDTO = {
   province: string;
   locality: string;
   commonName: string;
+  notAfter?: string;
+  maxPathLength: number;
+};
+
+export type TUpdateCaDTO = {
+  projectSlug: string;
+  caId: string;
+  status?: CaStatus;
+};
+
+export type TDeleteCaDTO = {
+  projectSlug: string;
+  caId: string;
+};
+
+export type TSignIntermediateDTO = {
+  caId: string;
+  csr: string;
+  maxPathLength: number;
+  notBefore?: string;
+  notAfter?: string;
+};
+
+export type TSignIntermediateResponse = {
+  certificate: string;
+  certificateChain: string;
+  issuingCaCertificate: string;
+  serialNumber: string;
+};
+
+export type TImportCaCertificateDTO = {
+  caId: string;
+  projectSlug: string;
+  certificate: string;
+  certificateChain: string;
+};
+
+export type TImportCaCertificateResponse = {
+  message: string;
+  caId: string;
+};
+
+// TODO: add TTL
+export type TCreateCertificateDTO = {
+  projectSlug: string;
+  caId: string;
+  commonName: string;
+  ttl?: number;
+  notBefore?: string;
+  notAfter?: string;
+};
+
+export type TCreateCertificateResponse = {
+  certificate: string;
+  issuingCertificate: string;
+  certificateChain: string;
+  sk: string;
+  serialNumber: string;
 };

frontend/src/hooks/api/certificates/index.tsx

@@ -0,0 +1,2 @@
+export { useDeleteCert } from "./mutations";
+export { useGetCertById, useGetCertCert } from "./queries";

frontend/src/hooks/api/certificates/mutations.tsx

@@ -0,0 +1,26 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { workspaceKeys } from "../workspace/queries";
+import { TCertificate } from "./types";
+
+export type TDeleteCaDTO = {
+  projectSlug: string;
+  certId: string;
+};
+
+export const useDeleteCert = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TCertificate, {}, TDeleteCaDTO>({
+    mutationFn: async ({ certId }) => {
+      const {
+        data: { certificate }
+      } = await apiRequest.delete<{ certificate: TCertificate }>(`/api/v1/certificates/${certId}`);
+      return certificate;
+    },
+    onSuccess: (_, { projectSlug }) => {
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceCertificates(projectSlug));
+    }
+  });
+};

frontend/src/hooks/api/certificates/queries.tsx

@@ -0,0 +1,40 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { TCertificate } from "./types";
+
+export const certKeys = {
+  getCertById: (certId: string) => [{ certId }, "cert"],
+  getCertCert: (certId: string) => [{ certId }, "certCert"]
+};
+
+export const useGetCertById = (certId: string) => {
+  return useQuery({
+    queryKey: certKeys.getCertById(certId),
+    queryFn: async () => {
+      const {
+        data: { certificate }
+      } = await apiRequest.get<{ certificate: TCertificate }>(`/api/v1/certificates/${certId}`);
+      return certificate;
+    },
+    enabled: Boolean(certId)
+  });
+};
+
+export const useGetCertCert = (certId: string) => {
+  return useQuery({
+    queryKey: certKeys.getCertCert(certId),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<{
+        certificate: string;
+        certificateChain: string;
+        issuingCaCertificate: string;
+        privateKey: string;
+        serialNumber: string;
+      }>(`/api/v1/certificates/${certId}/certificate`);
+      return data;
+    },
+    enabled: Boolean(certId)
+  });
+};

frontend/src/hooks/api/certificates/types.ts

@@ -0,0 +1,7 @@
+export type TCertificate = {
+  id: string;
+  caId: string;
+  commonName: string;
+  notBefore: string;
+  notAfter: string;
+};

frontend/src/hooks/api/index.tsx

@@ -6,6 +6,7 @@ export * from "./auditLogStreams";
 export * from "./auth";
 export * from "./bots";
 export * from "./ca";
+export * from "./certificates";
 export * from "./dynamicSecret";
 export * from "./dynamicSecretLease";
 export * from "./groups";

frontend/src/hooks/api/workspace/index.tsx

@@ -22,6 +22,7 @@ export {
   useGetWorkspaceSecrets,
   useGetWorkspaceUsers,
   useListWorkspaceCas,
+  useListWorkspaceCertificates,
   useListWorkspaceGroups,
   useNameWorkspaceSecrets,
   useRenameWorkspace,

frontend/src/hooks/api/workspace/queries.tsx

@@ -2,7 +2,9 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 
 import { apiRequest } from "@app/config/request";
 
+import { CaStatus } from "../ca/enums";
 import { TCertificateAuthority } from "../ca/types";
+import { TCertificate } from "../certificates/types";
 import { TGroupMembership } from "../groups/types";
 import { IdentityMembership } from "../identities/types";
 import { IntegrationAuth } from "../integrationAuth/types";
@@ -41,7 +43,12 @@ export const workspaceKeys = {
     [{ workspaceId }, "workspace-identity-memberships"] as const,
   getWorkspaceGroupMemberships: (workspaceId: string) =>
     [{ workspaceId }, "workspace-groups"] as const,
-  getWorkspaceCas: (workspaceId: string) => [{ workspaceId }, "workspace-cas"] as const
+  getWorkspaceCas: ({ projectSlug }: { projectSlug: string }) =>
+    [{ projectSlug }, "workspace-cas"] as const,
+  specificWorkspaceCas: ({ projectSlug, status }: { projectSlug: string; status?: CaStatus }) =>
+    [...workspaceKeys.getWorkspaceCas({ projectSlug }), { status }] as const,
+  getWorkspaceCertificates: (projectSlug: string) =>
+    [{ projectSlug }, "workspace-certificates"] as const
 };
 
 const fetchWorkspaceById = async (workspaceId: string) => {
@@ -472,17 +479,48 @@ export const useListWorkspaceGroups = (projectSlug: string) => {
   });
 };
 
-export const useListWorkspaceCas = (projectSlug: string) => {
+export const useListWorkspaceCas = ({
+  projectSlug,
+  status
+}: {
+  projectSlug: string;
+  status?: CaStatus;
+}) => {
   return useQuery({
-    queryKey: workspaceKeys.getWorkspaceCas(projectSlug),
+    queryKey: workspaceKeys.specificWorkspaceCas({
+      projectSlug,
+      status
+    }),
     queryFn: async () => {
+      const params = new URLSearchParams({
+        ...(status && { status })
+      });
+
       const {
         data: { cas }
       } = await apiRequest.get<{ cas: TCertificateAuthority[] }>(
-        `/api/v2/workspace/${projectSlug}/cas`
+        `/api/v2/workspace/${projectSlug}/cas`,
+        {
+          params
+        }
       );
       return cas;
     },
     enabled: Boolean(projectSlug)
   });
 };
+
+export const useListWorkspaceCertificates = (projectSlug: string) => {
+  return useQuery({
+    queryKey: workspaceKeys.getWorkspaceCertificates(projectSlug),
+    queryFn: async () => {
+      const {
+        data: { certificates }
+      } = await apiRequest.get<{ certificates: TCertificate[] }>(
+        `/api/v2/workspace/${projectSlug}/certificates`
+      );
+      return certificates;
+    },
+    enabled: Boolean(projectSlug)
+  });
+};