⭐️⭐️⭐️ Open-source, self-hosted alternative to Linear and Plane. Project management and issue tracking where teams and AI agents work side by side to plan and ship products.
TypeScript agenticagileai-agentsbug-reportingbug-trackerganttissue-trackerjirajira-alternativekanbanlinearlinear-alternativeopen-sourceproduct-managementproject-managementroadmapself-hostedsprint-planningteam-collaborationtrello-alternative
import { keepPreviousData, useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import {
deleteProjectTemplate,
getTeamProjectTemplate,
getTemplatePublisher,
getWorkspaceProjectTemplate,
importProjectTemplate,
linkTemplatePublisher,
listTeamProjectTemplates,
listWorkspaceProjectTemplates,
previewImportedTemplate,
previewProjectTemplate,
publishTemplate,
requestPublisherCode,
saveProjectTemplate,
setTemplatePublisherAuthor,
unlinkTemplatePublisher,
unpublishTemplate,
updateProjectTemplate,
type ProjectTemplateDetail,
type SharedProjectTemplate,
} from '@/lib/api/endpoints/project-templates';
import { qk } from '@/services/queryKeys';
function useTemplateMutation<TInput, TResult>(mutationFn: (input: TInput) => Promise<TResult>) {
const qc = useQueryClient();
return useMutation({
mutationFn,
onSuccess: () => qc.invalidateQueries({ queryKey: qk.projectTemplates }),
});
}
// The templates a team sees, for creating its projects. Pass null where the caller has
// no use for them, to skip the request.
export function useTeamProjectTemplatesQuery(teamId: number | null) {
return useQuery({
queryKey: qk.teamProjectTemplates(teamId ?? 0),
queryFn: () => listTeamProjectTemplates(teamId!),
enabled: teamId != null,
});
}
export function useWorkspaceProjectTemplatesQuery(workspaceId: number) {
return useQuery({
queryKey: qk.workspaceProjectTemplates(workspaceId),
queryFn: () => listWorkspaceProjectTemplates(workspaceId),
});
}
// Where a template is read from: the team that creates a project from it, or the workspace
// that holds it.
export type TemplateScope = { teamId: number } | { workspaceId: number };
// What one template holds, read when it is opened.
export function useProjectTemplateQuery(scope: TemplateScope, templateId: number) {
return useQuery<ProjectTemplateDetail, Error, ProjectTemplateDetail, readonly unknown[]>({
queryKey:
'teamId' in scope
? qk.teamProjectTemplate(scope.teamId, templateId)
: qk.workspaceProjectTemplate(scope.workspaceId, templateId),
queryFn: () =>
'teamId' in scope
? getTeamProjectTemplate(scope.teamId, templateId)
: getWorkspaceProjectTemplate(scope.workspaceId, templateId),
});
}
// What a template of the project would hold with this selection. The previous answer
// stays on screen while the next one loads, so a toggled section does not blank it.
export function useProjectTemplatePreviewQuery(
workspaceId: number,
projectId: number | null,
include: Record<string, boolean>,
) {
return useQuery({
queryKey: qk.projectTemplatePreview(workspaceId, projectId ?? 0, include),
queryFn: () => previewProjectTemplate(workspaceId, { projectId: projectId!, include }),
enabled: projectId != null,
placeholderData: keepPreviousData,
});
}
// What a pasted template would hold once imported. The server refuses one that is not a
// template or is damaged, which is an answer, not a failure to retry.
export function useImportedTemplatePreviewQuery(
workspaceId: number,
template: SharedProjectTemplate | null,
) {
return useQuery({
queryKey: qk.importedTemplatePreview(workspaceId, template),
queryFn: () => previewImportedTemplate(workspaceId, template!),
enabled: template !== null,
retry: false,
});
}
export function useImportProjectTemplate(workspaceId: number) {
return useTemplateMutation((input: Parameters<typeof importProjectTemplate>[1]) =>
importProjectTemplate(workspaceId, input),
);
}
export function useSaveProjectTemplate(workspaceId: number) {
return useTemplateMutation((input: Parameters<typeof saveProjectTemplate>[1]) =>
saveProjectTemplate(workspaceId, input),
);
}
export function useUpdateProjectTemplate(workspaceId: number) {
return useTemplateMutation(
({
templateId,
patch,
}: {
templateId: number;
patch: Parameters<typeof updateProjectTemplate>[2];
}) => updateProjectTemplate(workspaceId, templateId, patch),
);
}
export function useTemplatePublisherQuery(workspaceId: number) {
return useQuery({
queryKey: qk.templatePublisher(workspaceId),
queryFn: () => getTemplatePublisher(workspaceId),
});
}
export function useRequestPublisherCode(workspaceId: number) {
return useMutation({ mutationFn: (email: string) => requestPublisherCode(workspaceId, email) });
}
// Each of these changes the publisher, the templates, or both.
function usePublisherMutation<TInput, TResult>(
workspaceId: number,
mutationFn: (input: TInput) => Promise<TResult>,
meta?: { suppressErrorToast: true },
) {
const qc = useQueryClient();
return useMutation({
mutationFn,
meta,
onSuccess: () =>
Promise.all([
qc.invalidateQueries({ queryKey: qk.projectTemplates }),
qc.invalidateQueries({ queryKey: qk.templatePublisher(workspaceId) }),
]),
});
}
// A refused code shows under the code cells.
export function useLinkTemplatePublisher(workspaceId: number) {
return usePublisherMutation(
workspaceId,
(input: { email: string; code: string }) => linkTemplatePublisher(workspaceId, input),
{ suppressErrorToast: true },
);
}
export function useUnlinkTemplatePublisher(workspaceId: number) {
return usePublisherMutation(workspaceId, () => unlinkTemplatePublisher(workspaceId));
}
export function useSetPublisherAuthor(workspaceId: number) {
return usePublisherMutation(
workspaceId,
(author: Parameters<typeof setTemplatePublisherAuthor>[1]) =>
setTemplatePublisherAuthor(workspaceId, author),
);
}
export function usePublishTemplate(workspaceId: number) {
return usePublisherMutation(workspaceId, (templateId: number) =>
publishTemplate(workspaceId, templateId),
);
}
export function useUnpublishTemplate(workspaceId: number) {
return useTemplateMutation((templateId: number) => unpublishTemplate(workspaceId, templateId));
}
export function useDeleteProjectTemplate(workspaceId: number) {
return useTemplateMutation((templateId: number) =>
deleteProjectTemplate(workspaceId, templateId),
);
}