Your favorite shift management application!
import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
import { useTranslations } from "next-intl";
import { ShiftPreset } from "@/lib/db/schema";
import { toast } from "sonner";
import { queryKeys } from "@/lib/query-keys";
import { ApiError } from "@/lib/api-error";
import { generateTempId } from "@/lib/utils";
import { useIsCalendarAccessible } from "@/hooks/useCalendars";
import type { TimeRange } from "@/lib/time-ranges";
import type { CustomFieldInputValue } from "@/lib/custom-fields";
// Form data interface
export interface PresetFormData {
title: string;
startTime: string;
endTime: string;
color: string;
notes: string;
groupName: string;
isSecondary: boolean;
isAllDay: boolean;
hideFromStats: boolean;
defaultSignupCapacity?: number | null;
segments: TimeRange[];
customFields?: Record<string, CustomFieldInputValue>;
}
/**
* A preset row as the API actually returns it: segments and custom field
* values are attached at read time and aren't real ShiftPreset columns.
*/
export type ShiftPresetWithValues = ShiftPreset & {
segments?: TimeRange[];
customFields?: Record<string, CustomFieldInputValue>;
};
// API functions
async function fetchPresetsApi(calendarId: string): Promise<ShiftPresetWithValues[]> {
const params = new URLSearchParams({ calendarId });
const response = await fetch(`/api/presets?${params}`);
if (!response.ok) {
throw new ApiError(`Failed to fetch presets: ${response.statusText}`, response.status);
}
return await response.json();
}
async function createPresetApi(
calendarId: string,
formData: PresetFormData
): Promise<ShiftPresetWithValues> {
const response = await fetch("/api/presets", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ ...formData, calendarId }),
});
if (!response.ok) {
const errorData = await response.json();
throw new Error(errorData.error || "Failed to create preset");
}
return await response.json();
}
async function updatePresetApi(
presetId: string,
formData: PresetFormData
): Promise<ShiftPresetWithValues> {
const response = await fetch(`/api/presets/${presetId}`, {
method: "PATCH",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(formData),
});
if (!response.ok) {
const errorData = await response.json();
throw new Error(errorData.error || "Failed to update preset");
}
return await response.json();
}
async function deletePresetApi(presetId: string): Promise<void> {
const response = await fetch(`/api/presets/${presetId}`, {
method: "DELETE",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({}),
});
if (!response.ok) {
const errorData = await response.json();
throw new Error(errorData.error || "Failed to delete preset");
}
}
async function archivePresetApi(
presetId: string,
archived: boolean
): Promise<ShiftPresetWithValues> {
const response = await fetch(`/api/presets/${presetId}`, {
method: "PATCH",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ archived }),
});
if (!response.ok) {
const errorData = await response.json();
throw new Error(errorData.error || "Failed to archive preset");
}
return await response.json();
}
async function reorderPresetsApi(
calendarId: string,
presetOrders: Array<{ id: string; order: number }>
): Promise<void> {
const response = await fetch("/api/presets/reorder", {
method: "PATCH",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ calendarId, presetOrders }),
});
if (!response.ok) {
const errorData = await response.json();
throw new Error(errorData.error || "Failed to reorder presets");
}
}
// Helper to create optimistic preset
function createOptimisticPreset(
calendarId: string,
formData: PresetFormData
): ShiftPresetWithValues {
return {
id: `temp-${generateTempId()}`,
calendarId,
title: formData.title,
startTime: formData.startTime,
endTime: formData.endTime,
color: formData.color,
notes: formData.notes,
groupName: formData.groupName || null,
isSecondary: formData.isSecondary,
isAllDay: formData.isAllDay,
hideFromStats: formData.hideFromStats,
defaultSignupCapacity: formData.defaultSignupCapacity ?? null,
segments: formData.segments,
customFields: formData.customFields ?? {},
order: 999, // Will be corrected by server
archivedAt: null,
createdBy: null,
createdAt: new Date(),
updatedAt: new Date(),
};
}
// Main hook
export function usePresets(calendarId: string | undefined) {
const queryClient = useQueryClient();
const t = useTranslations();
const accessible = useIsCalendarAccessible(calendarId);
// Query for fetching presets
const {
data: presets = [],
isLoading,
isFetched,
} = useQuery({
queryKey: queryKeys.presets.byCalendar(calendarId!),
queryFn: () => fetchPresetsApi(calendarId!),
enabled: accessible,
});
// Create preset mutation
const createMutation = useMutation({
mutationFn: (formData: PresetFormData) =>
createPresetApi(calendarId!, formData),
onMutate: async (formData) => {
await queryClient.cancelQueries({
queryKey: queryKeys.presets.byCalendar(calendarId!),
});
const previous = queryClient.getQueryData(
queryKeys.presets.byCalendar(calendarId!)
);
const optimisticPreset = createOptimisticPreset(calendarId!, formData);
queryClient.setQueryData(
queryKeys.presets.byCalendar(calendarId!),
(old: ShiftPresetWithValues[] = []) => [...old, optimisticPreset]
);
return { previous };
},
onError: (error, formData, context) => {
queryClient.setQueryData(
queryKeys.presets.byCalendar(calendarId!),
context?.previous
);
toast.error(
error instanceof Error
? error.message
: t("common.createError", { item: t("preset.preset") })
);
},
onSuccess: () => {
toast.success(t("common.created", { item: t("preset.preset") }));
},
onSettled: () => {
queryClient.invalidateQueries({
queryKey: queryKeys.presets.byCalendar(calendarId!),
});
},
});
// Update preset mutation
const updateMutation = useMutation({
mutationFn: ({
presetId,
formData,
}: {
presetId: string;
formData: PresetFormData;
}) => updatePresetApi(presetId, formData),
onMutate: async ({ presetId, formData }) => {
await queryClient.cancelQueries({
queryKey: queryKeys.presets.byCalendar(calendarId!),
});
const previous = queryClient.getQueryData(
queryKeys.presets.byCalendar(calendarId!)
);
queryClient.setQueryData(
queryKeys.presets.byCalendar(calendarId!),
(old: ShiftPresetWithValues[] = []) =>
old.map((p) =>
p.id === presetId
? {
...p,
...formData,
updatedAt: new Date(),
}
: p
)
);
return { previous };
},
onError: (error, variables, context) => {
queryClient.setQueryData(
queryKeys.presets.byCalendar(calendarId!),
context?.previous
);
toast.error(
error instanceof Error
? error.message
: t("common.updateError", { item: t("preset.preset") })
);
},
onSuccess: () => {
toast.success(t("common.updated", { item: t("preset.preset") }));
},
onSettled: () => {
queryClient.invalidateQueries({
queryKey: queryKeys.presets.byCalendar(calendarId!),
});
},
});
// Delete preset mutation
const deleteMutation = useMutation({
mutationFn: (presetId: string) => deletePresetApi(presetId),
onMutate: async (presetId) => {
await queryClient.cancelQueries({
queryKey: queryKeys.presets.byCalendar(calendarId!),
});
const previous = queryClient.getQueryData(
queryKeys.presets.byCalendar(calendarId!)
);
queryClient.setQueryData(
queryKeys.presets.byCalendar(calendarId!),
(old: ShiftPresetWithValues[] = []) => old.filter((p) => p.id !== presetId)
);
return { previous };
},
onError: (error, presetId, context) => {
queryClient.setQueryData(
queryKeys.presets.byCalendar(calendarId!),
context?.previous
);
toast.error(
error instanceof Error
? error.message
: t("common.deleteError", { item: t("preset.preset") })
);
},
onSuccess: () => {
toast.success(t("common.deleted", { item: t("preset.preset") }));
},
onSettled: () => {
queryClient.invalidateQueries({
queryKey: queryKeys.presets.byCalendar(calendarId!),
});
},
});
// Archive / restore preset mutation
const archiveMutation = useMutation({
mutationFn: ({ presetId, archived }: { presetId: string; archived: boolean }) =>
archivePresetApi(presetId, archived),
onMutate: async ({ presetId, archived }) => {
await queryClient.cancelQueries({
queryKey: queryKeys.presets.byCalendar(calendarId!),
});
const previous = queryClient.getQueryData(
queryKeys.presets.byCalendar(calendarId!)
);
queryClient.setQueryData(
queryKeys.presets.byCalendar(calendarId!),
(old: ShiftPresetWithValues[] = []) =>
old.map((p) =>
p.id === presetId
? { ...p, archivedAt: archived ? new Date() : null, updatedAt: new Date() }
: p
)
);
return { previous };
},
onError: (error, variables, context) => {
queryClient.setQueryData(
queryKeys.presets.byCalendar(calendarId!),
context?.previous
);
toast.error(
error instanceof Error
? error.message
: t("common.updateError", { item: t("preset.preset") })
);
},
onSuccess: (_data, { archived }) => {
toast.success(archived ? t("preset.archivedToast") : t("preset.restoredToast"));
},
onSettled: () => {
queryClient.invalidateQueries({
queryKey: queryKeys.presets.byCalendar(calendarId!),
});
},
});
// Reorder presets mutation
const reorderMutation = useMutation({
mutationFn: (presetOrders: Array<{ id: string; order: number }>) =>
reorderPresetsApi(calendarId!, presetOrders),
onMutate: async (presetOrders) => {
await queryClient.cancelQueries({
queryKey: queryKeys.presets.byCalendar(calendarId!),
});
const previous = queryClient.getQueryData(
queryKeys.presets.byCalendar(calendarId!)
);
// Optimistically reorder
queryClient.setQueryData(
queryKeys.presets.byCalendar(calendarId!),
(old: ShiftPresetWithValues[] = []) => {
const orderMap = new Map(presetOrders.map((po) => [po.id, po.order]));
return [...old].sort((a, b) => {
const orderA = orderMap.get(a.id) ?? a.order;
const orderB = orderMap.get(b.id) ?? b.order;
return orderA - orderB;
});
}
);
return { previous };
},
onError: (error, variables, context) => {
queryClient.setQueryData(
queryKeys.presets.byCalendar(calendarId!),
context?.previous
);
toast.error(
error instanceof Error
? error.message
: t("common.updateError", { item: t("preset.preset") })
);
},
onSettled: () => {
queryClient.invalidateQueries({
queryKey: queryKeys.presets.byCalendar(calendarId!),
});
},
});
// Return interface
return {
// Data
presets,
loading: isLoading,
hasLoadedOnce: isFetched,
// Mutations
createPreset: async (formData: PresetFormData) => {
try {
await createMutation.mutateAsync(formData);
return true;
} catch {
return false;
}
},
updatePreset: async (presetId: string, formData: PresetFormData) => {
try {
await updateMutation.mutateAsync({ presetId, formData });
return true;
} catch {
return false;
}
},
deletePreset: async (presetId: string) => {
try {
await deleteMutation.mutateAsync(presetId);
return true;
} catch {
return false;
}
},
archivePreset: async (presetId: string, archived: boolean) => {
try {
await archiveMutation.mutateAsync({ presetId, archived });
return true;
} catch {
return false;
}
},
reorderPresets: async (
presetOrders: Array<{ id: string; order: number }>
) => {
try {
await reorderMutation.mutateAsync(presetOrders);
return true;
} catch {
return false;
}
},
};
}