Skip to content

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

12.2 KB
Raw Blame
import { useMutation, useQueryClient } from "@tanstack/react-query";

import { apiRequest } from "@app/config/request";

import { certificateProfileKeys } from "../certificateProfiles/queries";
import { projectKeys } from "../projects";
import { CaRenewalStatus, CaType } from "./enums";
import { caKeys } from "./queries";
import {
  TCreateCertificateAuthorityDTO,
  TCreateCertificateDTO,
  TCreateCertificateResponse,
  TCreateCertificateV3DTO,
  TCreateCertificateV3Response,
  TDeleteCertificateAuthorityDTO,
  TImportCaCertificateDTO,
  TImportCaCertificateResponse,
  TOrderCertificateDTO,
  TOrderCertificateResponse,
  TRenewCaDTO,
  TRenewCaResponse,
  TSignIntermediateDTO,
  TSignIntermediateResponse,
  TUnifiedCertificateAuthority,
  TUpdateCertificateAuthorityDTO
} from "./types";

export const useUpdateCa = () => {
  const queryClient = useQueryClient();
  return useMutation<TUnifiedCertificateAuthority, object, TUpdateCertificateAuthorityDTO>({
    mutationFn: async ({ id, ...body }) => {
      const { data } = await apiRequest.patch<TUnifiedCertificateAuthority>(
        `/api/v1/cert-manager/ca/${body.type}/${id}`,
        body
      );

      return data;
    },
    onSuccess: ({ type }, { id }) => {
      queryClient.invalidateQueries({
        queryKey: caKeys.listCasByTypeAndProjectId(type)
      });
      queryClient.invalidateQueries({
        queryKey: caKeys.getCaById(id)
      });
      queryClient.invalidateQueries({
        queryKey: caKeys.listCasByProjectId()
      });
      queryClient.invalidateQueries({
        queryKey: caKeys.listExternalCasByProjectId()
      });
    }
  });
};

export const useCreateCa = () => {
  const queryClient = useQueryClient();
  return useMutation<TUnifiedCertificateAuthority, object, TCreateCertificateAuthorityDTO>({
    mutationFn: async (body) => {
      const { data } = await apiRequest.post<TUnifiedCertificateAuthority>(
        `/api/v1/cert-manager/ca/${body.type}`,
        body
      );
      return data;
    },
    onSuccess: (_, { type }) => {
      queryClient.invalidateQueries({
        queryKey: caKeys.listCasByTypeAndProjectId(type)
      });
      queryClient.invalidateQueries({
        queryKey: caKeys.listCasByProjectId()
      });
      queryClient.invalidateQueries({
        queryKey: caKeys.listExternalCasByProjectId()
      });
      // Both caps count every CA type, so creating or deleting either kind moves the quota.
      queryClient.invalidateQueries({
        queryKey: caKeys.getCaQuota()
      });
    }
  });
};

export const useDeleteCa = () => {
  const queryClient = useQueryClient();
  return useMutation<TUnifiedCertificateAuthority, object, TDeleteCertificateAuthorityDTO>({
    mutationFn: async ({ id, type }) => {
      const { data } = await apiRequest.delete<TUnifiedCertificateAuthority>(
        `/api/v1/cert-manager/ca/${type}/${id}`
      );
      return data;
    },
    onSuccess: (_, { type }) => {
      queryClient.invalidateQueries({
        queryKey: caKeys.listCasByTypeAndProjectId(type)
      });
      queryClient.invalidateQueries({
        queryKey: caKeys.listCasByProjectId()
      });
      queryClient.invalidateQueries({
        queryKey: caKeys.listExternalCasByProjectId()
      });
      queryClient.invalidateQueries({
        queryKey: caKeys.getCaQuota()
      });
    }
  });
};

export const useSignIntermediate = () => {
  // TODO: consider renaming
  return useMutation<TSignIntermediateResponse, object, TSignIntermediateDTO>({
    mutationFn: async (body) => {
      const { data } = await apiRequest.post<TSignIntermediateResponse>(
        `/api/v1/cert-manager/ca/internal/${body.caId}/sign-intermediate`,
        body
      );
      return data;
    }
  });
};

export const useImportCaCertificate = () => {
  const queryClient = useQueryClient();
  return useMutation<TImportCaCertificateResponse, object, TImportCaCertificateDTO>({
    mutationFn: async ({ caId, ...body }) => {
      const { data } = await apiRequest.post<TImportCaCertificateResponse>(
        `/api/v1/cert-manager/ca/internal/${caId}/import-certificate`,
        body
      );
      return data;
    },
    onSuccess: (_, { caId }) => {
      queryClient.invalidateQueries({ queryKey: caKeys.getCaById(caId) });
      queryClient.invalidateQueries({ queryKey: caKeys.getCaCerts(caId) });
      queryClient.invalidateQueries({ queryKey: caKeys.getCaCert(caId) });
      queryClient.invalidateQueries({
        queryKey: caKeys.listCasByTypeAndProjectId(CaType.INTERNAL)
      });
      queryClient.invalidateQueries({
        queryKey: caKeys.listCasByProjectId()
      });
      queryClient.invalidateQueries({
        predicate: (query) => query.queryKey.includes("project-cas")
      });
    }
  });
};

// TODO: DEPRECATE
export const useCreateCertificate = () => {
  const queryClient = useQueryClient();
  return useMutation<TCreateCertificateResponse, object, TCreateCertificateDTO>({
    mutationFn: async (body) => {
      const { data } = await apiRequest.post<TCreateCertificateResponse>(
        "/api/v1/pki/certificates/issue-certificate",
        body
      );
      return data;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: projectKeys.allProjectCertificates()
      });
    }
  });
};

export const useCreateCertificateV3 = () => {
  const queryClient = useQueryClient();
  return useMutation<TCreateCertificateV3Response, object, TCreateCertificateV3DTO>({
    mutationFn: async (body) => {
      const { data } = await apiRequest.post<TCreateCertificateV3Response>(
        "/api/v1/cert-manager/certificates/issue-certificate",
        body
      );
      return data;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: projectKeys.allProjectCertificates()
      });

      queryClient.invalidateQueries({
        queryKey: certificateProfileKeys.all
      });
    }
  });
};

export const useOrderCertificateWithProfile = () => {
  const queryClient = useQueryClient();
  return useMutation<TOrderCertificateResponse, object, TOrderCertificateDTO>({
    mutationFn: async (body) => {
      const { data } = await apiRequest.post<TOrderCertificateResponse>(
        "/api/v1/cert-manager/certificates/order-certificate",
        body
      );
      return data;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: projectKeys.allProjectCertificates()
      });
      queryClient.invalidateQueries({ queryKey: ["approval-requests"] });
    }
  });
};

export const useRenewCa = () => {
  const queryClient = useQueryClient();
  return useMutation<TRenewCaResponse, object, TRenewCaDTO>({
    mutationFn: async (body) => {
      const { data } = await apiRequest.post<TRenewCaResponse>(
        `/api/v1/cert-manager/ca/internal/${body.caId}/renew`,
        body
      );
      return data;
    },
    onSuccess: (_, { caId }) => {
      queryClient.invalidateQueries({ queryKey: caKeys.getCaById(caId) });
      queryClient.invalidateQueries({ queryKey: caKeys.getCaCert(caId) });
      queryClient.invalidateQueries({ queryKey: caKeys.getCaCerts(caId) });
      queryClient.invalidateQueries({ queryKey: caKeys.getCaCsr(caId) });
      queryClient.invalidateQueries({ queryKey: caKeys.getCaCrl(caId) });
    }
  });
};

const invalidateCaInstallQueries = (
  queryClient: ReturnType<typeof useQueryClient>,
  caId: string
) => {
  queryClient.invalidateQueries({ queryKey: caKeys.getCaAutoRenewal(caId) });
  queryClient.invalidateQueries({ queryKey: caKeys.getCaSigningConfig(caId) });
  queryClient.invalidateQueries({ queryKey: caKeys.getCaById(caId) });
  queryClient.invalidateQueries({ queryKey: caKeys.getCaCert(caId) });
  queryClient.invalidateQueries({ queryKey: caKeys.getCaCerts(caId) });
  queryClient.invalidateQueries({ queryKey: caKeys.listCasByTypeAndProjectId(CaType.INTERNAL) });
  queryClient.invalidateQueries({ queryKey: caKeys.listCasByProjectId() });
  queryClient.invalidateQueries({ predicate: (query) => query.queryKey.includes("project-cas") });
};

const useInstallCaCertificate = (endpoint: string) => {
  const queryClient = useQueryClient();
  return useMutation<
    { message: string; caId: string },
    object,
    { caId: string; maxPathLength?: number }
  >({
    mutationFn: async ({ caId, ...body }) => {
      const { data } = await apiRequest.post<{ message: string; caId: string }>(
        `/api/v1/cert-manager/ca/internal/${caId}/${endpoint}`,
        body
      );
      return data;
    },
    onSuccess: (_, { caId }) => invalidateCaInstallQueries(queryClient, caId)
  });
};

export const useInstallCaCertificateVenafi = () =>
  useInstallCaCertificate("install-certificate-venafi");
export const useInstallCaCertificateAdcs = () =>
  useInstallCaCertificate("install-certificate-adcs");
export const useInstallCaCertificateAdcsNative = () =>
  useInstallCaCertificate("install-certificate-microsoft-adcs");

export const useCreateCaSigningConfig = () => {
  const queryClient = useQueryClient();
  return useMutation<
    unknown,
    object,
    {
      caId: string;
      type: string;
      parentCaId?: string;
      appConnectionId?: string;
      destinationConfig?: Record<string, unknown>;
    }
  >({
    mutationFn: async ({ caId, ...body }) => {
      const { data } = await apiRequest.post(
        `/api/v1/cert-manager/ca/internal/${caId}/signing-config`,
        body
      );
      return data;
    },
    onSuccess: (_, { caId }) => {
      queryClient.invalidateQueries({ queryKey: caKeys.getCaSigningConfig(caId) });
    }
  });
};

export const useUpdateCaSigningConfig = () => {
  const queryClient = useQueryClient();
  return useMutation<
    unknown,
    object,
    {
      caId: string;
      parentCaId?: string;
      appConnectionId?: string;
      destinationConfig?: Record<string, unknown>;
    }
  >({
    mutationFn: async ({ caId, ...body }) => {
      const { data } = await apiRequest.patch(
        `/api/v1/cert-manager/ca/internal/${caId}/signing-config`,
        body
      );
      return data;
    },
    onSuccess: (_, { caId }) => {
      queryClient.invalidateQueries({ queryKey: caKeys.getCaSigningConfig(caId) });
    }
  });
};

export const useUpdateCaAutoRenewal = () => {
  const queryClient = useQueryClient();
  return useMutation<
    {
      autoRenewalEnabled: boolean;
      autoRenewalDaysBeforeExpiry: number | null;
      lastRenewalStatus: CaRenewalStatus | null;
      lastRenewalMessage: string | null;
      lastRenewalAt: string | null;
    },
    object,
    {
      caId: string;
      autoRenewalEnabled?: boolean;
      autoRenewalDaysBeforeExpiry?: number;
    }
  >({
    mutationFn: async ({ caId, ...body }) => {
      const { data } = await apiRequest.patch(
        `/api/v1/cert-manager/ca/internal/${caId}/auto-renewal`,
        body
      );
      return data;
    },
    onSuccess: (_, { caId }) => {
      queryClient.invalidateQueries({ queryKey: caKeys.getCaAutoRenewal(caId) });
      queryClient.invalidateQueries({ queryKey: caKeys.getCaById(caId) });
    }
  });
};

export const useGenerateCaCertificate = () => {
  const queryClient = useQueryClient();
  return useMutation<
    { certificate: string; certificateChain: string; serialNumber: string },
    object,
    {
      caId: string;
      parentCaId?: string;
      notBefore: string;
      notAfter: string;
      maxPathLength?: number;
    }
  >({
    mutationFn: async ({ caId, ...body }) => {
      const { data } = await apiRequest.post<{
        certificate: string;
        certificateChain: string;
        serialNumber: string;
      }>(`/api/v1/cert-manager/ca/internal/${caId}/certificate`, body);
      return data;
    },
    onSuccess: (_, { caId }) => {
      queryClient.invalidateQueries({ queryKey: caKeys.getCaById(caId) });
      queryClient.invalidateQueries({ queryKey: caKeys.getCaCert(caId) });
      queryClient.invalidateQueries({ queryKey: caKeys.getCaCerts(caId) });
      queryClient.invalidateQueries({ queryKey: caKeys.getCaCsr(caId) });
      queryClient.invalidateQueries({ queryKey: caKeys.getCaCrl(caId) });
      queryClient.invalidateQueries({
        queryKey: caKeys.listCasByTypeAndProjectId(CaType.INTERNAL)
      });
      queryClient.invalidateQueries({
        queryKey: caKeys.listCasByProjectId()
      });
      queryClient.invalidateQueries({
        predicate: (query) => query.queryKey.includes("project-cas")
      });
    }
  });
};