Skip to content

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

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

import { apiRequest } from "@app/config/request";
import {
  availableUsersUrl,
  groupMembershipsBase,
  userMembershipsBase
} from "@app/hooks/api/certManagerAccess";

import { CaStatus } from "../ca/enums";
import { TCertificateAuthority } from "../ca/types";
import { TCertificate } from "../certificates/types";
import { TCertificateTemplate } from "../certificateTemplates/types";
import { TGroupMembership } from "../groups/types";
import { TIntegration } from "../integrations/types";
import { TPkiAlert } from "../pkiAlerts/types";
import { pkiApplicationKeys } from "../pkiApplications/queries";
import { TPkiCollection } from "../pkiCollections/types";
import { TPkiSubscriber } from "../pkiSubscriber/types";
import { userKeys } from "../users/query-keys";
import { TAvailableProjectUser, TWorkspaceUser } from "../users/types";
import {
  ProjectWorkflowIntegrationConfig,
  WorkflowIntegrationPlatform
} from "../workflowIntegrations/types";
import { projectKeys } from "./query-keys";
import {
  CreateEnvironmentDTO,
  CreateWorkspaceDTO,
  DeletedProject,
  DeleteEnvironmentDTO,
  DeleteWorkspaceDTO,
  PermanentlyDeleteProjectDTO,
  Project,
  ProjectEnv,
  ProjectType,
  RestoreEnvironmentDTO,
  RestoreProjectDTO,
  TGetIdentityPermissionAuditResponse,
  TGetMembershipPermissionAuditResponse,
  TGetUpgradeProjectStatusDTO,
  TMyPendingProjectAccessRequestsResponse,
  TProjectNavigation,
  TSearchProjectsDTO,
  TUpdateWorkspaceUserRoleDTO,
  UpdateAuditLogsRetentionDTO,
  UpdateEnvironmentDTO,
  UpdateProjectDTO
} from "./types";

export const fetchProjectById = async (projectId: string) => {
  const { data } = await apiRequest.get<{ project: Project }>(`/api/v1/projects/${projectId}`);

  return data.project;
};

const fetchWorkspaceIndexStatus = async (projectId: string) => {
  const { data } = await apiRequest.get<boolean>(
    `/api/v3/projects/${projectId}/secrets/blind-index-status`
  );

  return data;
};

const fetchProjectUpgradeStatus = async (projectId: string) => {
  const { data } = await apiRequest.get<{ status: string }>(
    `/api/v1/projects/${projectId}/upgrade/status`
  );

  return data;
};

export const useUpgradeProject = () => {
  const queryClient = useQueryClient();

  return useMutation<object, object, { projectId: string; privateKey: string }>({
    mutationFn: ({ projectId, privateKey }) => {
      return apiRequest.post(`/api/v1/projects/${projectId}/upgrade`, {
        userPrivateKey: privateKey
      });
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: projectKeys.getAllUserProjects()
      });
    }
  });
};

export const useGetUpgradeProjectStatus = ({
  projectId,
  enabled,
  refetchInterval
}: TGetUpgradeProjectStatusDTO) => {
  return useQuery({
    queryKey: projectKeys.getProjectUpgradeStatus(projectId),
    queryFn: () => fetchProjectUpgradeStatus(projectId),
    enabled,
    refetchInterval
  });
};

export const fetchUserWorkspaces = async (includeRoles?: boolean, type?: ProjectType | "all") => {
  const { data } = await apiRequest.get<{ projects: Project[] }>("/api/v1/projects", {
    params: {
      includeRoles,
      type
    }
  });
  return data.projects;
};

export const useGetWorkspaceIndexStatus = (projectId: string) => {
  return useQuery({
    queryKey: projectKeys.getProjectIndexStatus(projectId),
    queryFn: () => fetchWorkspaceIndexStatus(projectId),
    enabled: true
  });
};

export const useGetWorkspaceById = (
  projectId: string,
  dto?: { refetchInterval?: number | false }
) => {
  return useQuery({
    queryKey: projectKeys.getProjectById(projectId),
    queryFn: () => fetchProjectById(projectId),
    enabled: Boolean(projectId),
    refetchInterval: dto?.refetchInterval
  });
};

export const useGetUserProjects = ({
  includeRoles,
  options = {}
}: {
  includeRoles?: boolean;
  options?: { enabled?: boolean };
} = {}) =>
  useQuery({
    queryKey: projectKeys.getAllUserProjects(),
    queryFn: () => fetchUserWorkspaces(includeRoles),
    ...options
  });

export const useGetUserProjectsByType = (type: ProjectType) =>
  useQuery({
    queryKey: [...projectKeys.getAllUserProjects(), type],
    queryFn: () => fetchUserWorkspaces(false, type),
    select: (projects) => projects.slice(0, 100)
  });

export const useGetAccessibleProjectsWithSubOrgs = (orgId: string) =>
  useQuery({
    queryKey: projectKeys.getAccessibleProjectsWithSubOrgs(orgId),
    queryFn: async ({ signal }) => {
      const { data } = await apiRequest.get<{ projects: TProjectNavigation[] }>(
        "/api/v1/projects/accessible-with-sub-orgs",
        { signal }
      );
      return data.projects;
    },
    enabled: Boolean(orgId)
  });

export const useSearchProjects = ({ options, ...dto }: TSearchProjectsDTO) =>
  useQuery({
    queryKey: projectKeys.searchProject(dto),
    queryFn: async () => {
      const { data } = await apiRequest.post<{
        projects: (Project & { isMember: boolean; isDirectMember: boolean })[];
        totalCount: number;
      }>("/api/v1/projects/search", dto);

      return data;
    },
    ...options
  });

export const useGetMyPendingProjectAccessRequests = (options?: { enabled?: boolean }) =>
  useQuery({
    queryKey: projectKeys.getMyPendingProjectAccessRequests(),
    queryFn: async () => {
      const { data } = await apiRequest.get<TMyPendingProjectAccessRequestsResponse>(
        "/api/v1/projects/me/project-access-requests"
      );
      return new Map(data.requests.map((r) => [r.projectId, new Date(r.createdAt)]));
    },
    ...options
  });

const fetchUserWorkspaceMemberships = async (orgId: string) => {
  const { data } = await apiRequest.get<Record<string, Project[]>>(
    `/api/v1/organization/${orgId}/project-memberships`
  );

  return data;
};

// to get all userids in an org with the project they are part of
export const useGetUserWorkspaceMemberships = (orgId: string) =>
  useQuery({
    queryKey: projectKeys.getProjectMemberships(orgId),
    queryFn: () => fetchUserWorkspaceMemberships(orgId),
    enabled: Boolean(orgId)
  });

export const fetchWorkspaceIntegrations = async (projectId: string) => {
  const { data } = await apiRequest.get<{ integrations: TIntegration[] }>(
    `/api/v1/projects/${projectId}/integrations`
  );
  return data.integrations;
};

export const useGetWorkspaceIntegrations = (
  projectId: string,
  options?: { enabled?: boolean; refetchInterval?: number | false }
) =>
  useQuery({
    queryKey: projectKeys.getProjectIntegrations(projectId),
    queryFn: () => fetchWorkspaceIntegrations(projectId),
    enabled: Boolean(projectId) && (options?.enabled ?? true),
    refetchInterval: options?.refetchInterval ?? 30_000
  });

export const createWorkspace = (
  dto: CreateWorkspaceDTO
): Promise<{ data: { project: Project } }> => {
  return apiRequest.post("/api/v1/projects", dto);
};

export const useCreateWorkspace = () => {
  const queryClient = useQueryClient();

  return useMutation<{ data: { project: Project } }, object, CreateWorkspaceDTO>({
    mutationFn: async ({ projectName, projectDescription, kmsKeyId, template, type }) =>
      createWorkspace({
        projectName,
        projectDescription,
        kmsKeyId,
        template,
        type
      }),
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: projectKeys.getAllUserProjects()
      });
    }
  });
};

export const useUpdateProject = () => {
  const queryClient = useQueryClient();

  return useMutation<Project, object, UpdateProjectDTO>({
    mutationFn: async ({
      projectId: projectID,
      newProjectName,
      hasDeleteProtection,
      enforceEncryptedSecretManagerSecretMetadata,
      newProjectDescription,
      newSlug,
      secretSharing,
      showSnapshotsLegacy,
      secretDetectionIgnoreValues,
      autoCapitalization,
      pitVersionLimit
    }) => {
      const { data } = await apiRequest.patch<{ project: Project }>(
        `/api/v1/projects/${projectID}`,
        {
          name: newProjectName,
          description: newProjectDescription,
          slug: newSlug,
          secretSharing,
          showSnapshotsLegacy,
          secretDetectionIgnoreValues,
          autoCapitalization,
          pitVersionLimit,
          hasDeleteProtection,
          enforceEncryptedSecretManagerSecretMetadata
        }
      );
      return data.project;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: projectKeys.getAllUserProjects() });
    }
  });
};

export const useUpdateWorkspaceAuditLogsRetention = () => {
  const queryClient = useQueryClient();

  return useMutation<Project, object, UpdateAuditLogsRetentionDTO>({
    mutationFn: async ({ projectId, auditLogsRetentionDays }) => {
      const { data } = await apiRequest.put(`/api/v1/projects/${projectId}/audit-logs-retention`, {
        auditLogsRetentionDays
      });
      return data.project;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: projectKeys.getAllUserProjects() });
    }
  });
};

export const useDeleteWorkspace = () => {
  const queryClient = useQueryClient();

  return useMutation<Project, object, DeleteWorkspaceDTO>({
    mutationFn: async ({ projectID, hardDelete }) => {
      const { data } = await apiRequest.delete(`/api/v1/projects/${projectID}`, {
        params: hardDelete ? { hardDelete: true } : undefined
      });
      return data.project;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: projectKeys.getAllUserProjects() });
      queryClient.invalidateQueries({
        queryKey: ["org-admin-projects"]
      });
    }
  });
};

export const useGetDeletedProjects = (type?: ProjectType, options?: { enabled?: boolean }) =>
  useQuery({
    queryKey: projectKeys.getDeletedProjects(type),
    queryFn: async () => {
      const { data } = await apiRequest.get<{ projects: DeletedProject[] }>(
        "/api/v1/projects/deleted",
        { params: { type } }
      );
      return data.projects;
    },
    ...options
  });

export const usePermanentlyDeleteProject = () => {
  const queryClient = useQueryClient();

  return useMutation<Project, object, PermanentlyDeleteProjectDTO>({
    mutationFn: async ({ projectId }) => {
      const { data } = await apiRequest.delete(`/api/v1/projects/deleted/${projectId}`);
      return data.project;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: projectKeys.getAllUserProjects() });
    }
  });
};

export const useRestoreProject = () => {
  const queryClient = useQueryClient();

  return useMutation<Project, object, RestoreProjectDTO>({
    mutationFn: async ({ projectId }) => {
      const { data } = await apiRequest.post(`/api/v1/projects/${projectId}/restore`);
      return data.project;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: projectKeys.getAllUserProjects() });
      queryClient.invalidateQueries({
        queryKey: ["org-admin-projects"]
      });
    }
  });
};

export const useCreateWsEnvironment = () => {
  const queryClient = useQueryClient();

  return useMutation<ProjectEnv, ProjectEnv, CreateEnvironmentDTO>({
    mutationFn: async ({ projectId, name, slug }) => {
      const { data } = await apiRequest.post<{ environment: ProjectEnv }>(
        `/api/v1/projects/${projectId}/environments`,
        {
          name,
          slug
        }
      );
      return data.environment;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: projectKeys.getAllUserProjects()
      });
    }
  });
};

export const useUpdateWsEnvironment = () => {
  const queryClient = useQueryClient();

  return useMutation<object, object, UpdateEnvironmentDTO>({
    mutationFn: ({ projectId, id, name, slug, position }) => {
      return apiRequest.patch(`/api/v1/projects/${projectId}/environments/${id}`, {
        name,
        slug,
        position
      });
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: projectKeys.getAllUserProjects()
      });
    }
  });
};

export const useDeleteWsEnvironment = () => {
  const queryClient = useQueryClient();

  return useMutation<object, object, DeleteEnvironmentDTO>({
    mutationFn: ({ id, projectId, hardDelete }) => {
      return apiRequest.delete(`/api/v1/projects/${projectId}/environments/${id}`, {
        params: hardDelete ? { hardDelete: true } : undefined
      });
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: projectKeys.getAllUserProjects()
      });
    }
  });
};

export const useRestoreEnvironment = () => {
  const queryClient = useQueryClient();

  return useMutation<object, object, RestoreEnvironmentDTO>({
    mutationFn: ({ id, projectId }) => {
      return apiRequest.post(`/api/v1/projects/${projectId}/environments/${id}/restore`);
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: projectKeys.getAllUserProjects()
      });
    }
  });
};

export const useGetAvailableProjectUsers = (projectId: string, projectType?: string) =>
  useQuery({
    queryKey: projectKeys.getAvailableProjectUsers(projectId),
    queryFn: async () => {
      const { data } = await apiRequest.get<{ users: TAvailableProjectUser[] }>(
        availableUsersUrl(projectType, projectId)
      );
      return data.users;
    },
    enabled: Boolean(projectId)
  });

export const useGetWorkspaceUsers = (
  projectId: string,
  includeGroupMembers?: boolean,
  roles?: string[],
  options?: { enabled?: boolean }
) => {
  return useQuery({
    queryKey: projectKeys.getProjectUsers(projectId, includeGroupMembers, roles),
    queryFn: async () => {
      const {
        data: { users }
      } = await apiRequest.get<{ users: TWorkspaceUser[] }>(`/api/v1/projects/${projectId}/users`, {
        params: {
          includeGroupMembers,
          roles:
            roles && roles.length > 0
              ? roles.map((role) => encodeURIComponent(role)).join(",")
              : undefined
        }
      });
      return users;
    },
    enabled: options?.enabled ?? true
  });
};

export const useGetWorkspaceUserDetails = (
  projectId: string,
  membershipId: string,
  projectType?: string
) => {
  return useQuery({
    queryKey: projectKeys.getProjectUserDetails(projectId, membershipId),
    queryFn: async () => {
      const {
        data: { membership }
      } = await apiRequest.get<{ membership: TWorkspaceUser }>(
        `${userMembershipsBase(projectType, projectId)}/${membershipId}`
      );
      return membership;
    },
    enabled: Boolean(projectId) && Boolean(membershipId)
  });
};

export const useGetMembershipPermissionAudit = (
  projectId: string,
  membershipId: string,
  options?: { enabled?: boolean; retry?: number | boolean; includeFolderPermissions?: boolean }
) =>
  useQuery({
    queryKey: projectKeys.getMembershipPermissionAudit(
      projectId,
      membershipId,
      options?.includeFolderPermissions
    ),
    queryFn: async () => {
      const { data } = await apiRequest.get<TGetMembershipPermissionAuditResponse>(
        `/api/v1/projects/${projectId}/memberships/${membershipId}/permissions/audit`,
        { params: { includeFolderPermissions: options?.includeFolderPermissions } }
      );
      return data;
    },
    enabled: Boolean(projectId && membershipId) && (options?.enabled ?? true),
    retry: options?.retry
  });

export const useGetIdentityPermissionAudit = (
  projectId: string,
  identityId: string,
  options?: { enabled?: boolean; retry?: number | boolean; includeFolderPermissions?: boolean }
) =>
  useQuery({
    queryKey: projectKeys.getIdentityPermissionAudit(
      projectId,
      identityId,
      options?.includeFolderPermissions
    ),
    queryFn: async () => {
      const { data } = await apiRequest.get<TGetIdentityPermissionAuditResponse>(
        `/api/v1/projects/${projectId}/memberships/identities/${identityId}/permissions/audit`,
        { params: { includeFolderPermissions: options?.includeFolderPermissions } }
      );
      return data;
    },
    enabled: Boolean(projectId && identityId) && (options?.enabled ?? true),
    retry: options?.retry
  });

export const useDeleteUserFromWorkspace = () => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async ({
      usernames,
      projectId,
      projectType
    }: {
      projectId: string;
      projectType?: string;
      usernames: string[];
      orgId: string;
    }) => {
      const {
        data: { deletedMembership }
      } = await apiRequest.delete(userMembershipsBase(projectType, projectId), {
        data: { usernames }
      });
      return deletedMembership;
    },
    onSuccess: (_, { orgId, projectId }) => {
      queryClient.invalidateQueries({ queryKey: projectKeys.getProjectUsers(projectId) });
      queryClient.invalidateQueries({ queryKey: projectKeys.getAvailableProjectUsers(projectId) });
      queryClient.invalidateQueries({
        queryKey: userKeys.allOrgMembershipProjectMemberships(orgId)
      });
      queryClient.invalidateQueries({ queryKey: pkiApplicationKeys.all });
    }
  });
};

export const useUpdateUserWorkspaceRole = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async ({
      membershipId,
      roles,
      projectId,
      projectType
    }: TUpdateWorkspaceUserRoleDTO) => {
      const {
        data: { membership }
      } = await apiRequest.patch<{ membership: { projectId: string } }>(
        `${userMembershipsBase(projectType, projectId)}/${membershipId}`,
        {
          roles
        }
      );
      return membership;
    },
    onSuccess: (_, { projectId, membershipId }) => {
      queryClient.invalidateQueries({ queryKey: projectKeys.getProjectUsers(projectId) });
      queryClient.invalidateQueries({
        queryKey: projectKeys.getProjectUserDetails(projectId, membershipId)
      });
      queryClient.invalidateQueries({
        queryKey: projectKeys.getMembershipPermissionAudit(projectId, membershipId)
      });
    }
  });
};

export const useGetWorkspaceGroupMembershipDetails = (
  projectId: string,
  groupId: string,
  projectType?: string
) => {
  return useQuery({
    enabled: Boolean(projectId && groupId),
    queryKey: projectKeys.getProjectGroupMembershipDetails(projectId, groupId),
    queryFn: async () => {
      const {
        data: { groupMembership }
      } = await apiRequest.get<{ groupMembership: TGroupMembership }>(
        `${groupMembershipsBase(projectType, projectId)}/${groupId}`
      );
      return groupMembership;
    }
  });
};

export const useListWorkspaceGroups = (
  projectId: string,
  projectType?: string,
  options?: { enabled?: boolean }
) => {
  return useQuery({
    queryKey: projectKeys.getProjectGroupMemberships(projectId),
    queryFn: async () => {
      const {
        data: { groupMemberships }
      } = await apiRequest.get<{ groupMemberships: TGroupMembership[] }>(
        groupMembershipsBase(projectType, projectId)
      );
      return groupMemberships;
    },
    enabled: options?.enabled ?? true
  });
};

export const useListWorkspaceCas = ({
  projectId,
  status
}: {
  projectId: string;
  status?: CaStatus;
}) => {
  return useQuery({
    queryKey: projectKeys.specificProjectCas({
      projectId,
      status
    }),
    queryFn: async () => {
      const params = new URLSearchParams({
        ...(status && { status })
      });

      const {
        data: { cas }
      } = await apiRequest.get<{ cas: TCertificateAuthority[] }>(
        `/api/v1/projects/${projectId}/cas`,
        {
          params
        }
      );
      return cas;
    },
    enabled: Boolean(projectId)
  });
};

export const useListWorkspaceCertificates = ({
  projectId,
  offset,
  limit,
  friendlyName,
  commonName,
  forPkiSync,
  search,
  status,
  includeDeleted,
  profileIds,
  fromDate,
  toDate,
  metadataFilter,
  extendedKeyUsage,
  keyAlgorithm,
  signatureAlgorithm,
  keySizes,
  caIds,
  enrollmentTypes,
  source,
  notAfterFrom,
  notAfterTo,
  notBeforeFrom,
  notBeforeTo,
  applicationId,
  applicationIds,
  sortBy,
  sortOrder
}: {
  projectId: string;
  offset: number;
  limit: number;
  friendlyName?: string;
  commonName?: string;
  forPkiSync?: boolean;
  search?: string;
  status?: string | string[];
  includeDeleted?: boolean;
  profileIds?: string[];
  fromDate?: Date;
  toDate?: Date;
  metadataFilter?: Array<{ key: string; value?: string }>;
  extendedKeyUsage?: string;
  keyAlgorithm?: string | string[];
  signatureAlgorithm?: string;
  keySizes?: number[];
  caIds?: string[];
  enrollmentTypes?: string[];
  source?: string | string[];
  notAfterFrom?: Date;
  notAfterTo?: Date;
  notBeforeFrom?: Date;
  notBeforeTo?: Date;
  applicationId?: string;
  applicationIds?: string[];
  sortBy?: string;
  sortOrder?: "asc" | "desc";
}) => {
  return useQuery({
    queryKey: projectKeys.specificProjectCertificates({
      projectId,
      offset,
      limit,
      friendlyName,
      commonName,
      forPkiSync,
      search,
      status,
      includeDeleted,
      profileIds,
      fromDate,
      toDate,
      metadataFilter,
      extendedKeyUsage,
      keyAlgorithm,
      signatureAlgorithm,
      keySizes,
      caIds,
      enrollmentTypes,
      source,
      notAfterFrom,
      notAfterTo,
      notBeforeFrom,
      notBeforeTo,
      applicationId,
      applicationIds,
      sortBy,
      sortOrder
    }),
    queryFn: async () => {
      const {
        data: { certificates, totalCount }
      } = await apiRequest.post<{ certificates: TCertificate[]; totalCount: number }>(
        `/api/v1/projects/${projectId}/certificates/search`,
        {
          offset,
          limit,
          ...(friendlyName && { friendlyName }),
          ...(commonName && { commonName }),
          ...(forPkiSync && { forPkiSync }),
          ...(search && { search }),
          ...(status && { status: Array.isArray(status) ? status.join(",") : status }),
          ...(includeDeleted && { includeDeleted }),
          ...(profileIds && profileIds.length > 0 && { profileIds }),
          ...(fromDate && { fromDate: fromDate.toISOString() }),
          ...(toDate && { toDate: toDate.toISOString() }),
          ...(metadataFilter && metadataFilter.length > 0 && { metadata: metadataFilter }),
          ...(extendedKeyUsage && { extendedKeyUsage }),
          ...(keyAlgorithm && { keyAlgorithm }),
          ...(signatureAlgorithm && { signatureAlgorithm }),
          ...(keySizes && keySizes.length > 0 && { keySizes }),
          ...(caIds && caIds.length > 0 && { caIds }),
          ...(enrollmentTypes && enrollmentTypes.length > 0 && { enrollmentTypes }),
          ...(source && { source }),
          ...(notAfterFrom && { notAfterFrom: notAfterFrom.toISOString() }),
          ...(notAfterTo && { notAfterTo: notAfterTo.toISOString() }),
          ...(notBeforeFrom && { notBeforeFrom: notBeforeFrom.toISOString() }),
          ...(notBeforeTo && { notBeforeTo: notBeforeTo.toISOString() }),
          ...(applicationId && { applicationId }),
          ...(applicationIds && applicationIds.length > 0 && { applicationIds }),
          ...(sortBy && { sortBy }),
          ...(sortOrder && { sortOrder })
        }
      );

      return { certificates, totalCount };
    },
    enabled: Boolean(projectId),
    placeholderData: (previousData) => previousData
  });
};

export const useListWorkspacePkiAlerts = ({ projectId }: { projectId: string }) => {
  return useQuery({
    queryKey: projectKeys.getProjectPkiAlerts(projectId),
    queryFn: async () => {
      const {
        data: { alerts }
      } = await apiRequest.get<{ alerts: TPkiAlert[] }>(`/api/v1/projects/${projectId}/pki-alerts`);

      return { alerts };
    },
    enabled: Boolean(projectId)
  });
};

export const useListWorkspacePkiCollections = ({ projectId }: { projectId: string }) => {
  return useQuery({
    queryKey: projectKeys.getProjectPkiCollections(projectId),
    queryFn: async () => {
      const {
        data: { collections }
      } = await apiRequest.get<{ collections: TPkiCollection[] }>(
        `/api/v1/projects/${projectId}/pki-collections`
      );

      return { collections };
    },
    enabled: Boolean(projectId)
  });
};

export const useListWorkspaceCertificateTemplates = ({ projectId }: { projectId: string }) => {
  return useQuery({
    queryKey: projectKeys.getProjectCertificateTemplates(projectId),
    queryFn: async () => {
      const {
        data: { certificateTemplates }
      } = await apiRequest.get<{ certificateTemplates: TCertificateTemplate[] }>(
        `/api/v1/projects/${projectId}/certificate-templates`
      );

      return { certificateTemplates };
    },
    enabled: Boolean(projectId)
  });
};

export const useListWorkspacePkiSubscribers = (projectId: string) => {
  return useQuery({
    queryKey: projectKeys.getProjectPkiSubscribers(projectId),
    queryFn: async () => {
      const {
        data: { subscribers }
      } = await apiRequest.get<{ subscribers: TPkiSubscriber[] }>(
        `/api/v1/projects/${projectId}/pki-subscribers`
      );
      return subscribers;
    },
    enabled: Boolean(projectId)
  });
};

export const useGetWorkspaceWorkflowIntegrationConfig = ({
  projectId,
  integration
}: {
  projectId: string;
  integration: WorkflowIntegrationPlatform;
}) => {
  return useQuery({
    queryKey: projectKeys.getProjectWorkflowIntegrationConfig(projectId, integration),
    queryFn: async () => {
      const { data } = await apiRequest
        .get<ProjectWorkflowIntegrationConfig>(
          `/api/v1/projects/${projectId}/workflow-integration-config/${integration}`
        )
        .catch((err) => {
          if (err.response.status === 404) {
            return { data: null };
          }

          throw err;
        });

      return data;
    },
    enabled: Boolean(projectId)
  });
};