Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
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)
});
};