adminFront/src/api/promocode/swr.ts

import { useCallback, useRef } from "react";
import useSwr, { mutate } from "swr";
import { enqueueSnackbar } from "notistack";
import { promocodeApi } from "./requests";

import type { CreatePromocodeBody, PromocodeList } from "@root/model/promocodes";

export function usePromocodes(page: number, pageSize: number, promocodeId: string, to: number, from: number) {
	const promocodesCountRef = useRef<number>(0);
	const swrResponse = useSwr(
		["promocodes", page, pageSize],
		async (key) => {
			const result = await promocodeApi.getPromocodeList({
				limit: key[2],
				filter: {
					active: true,
				},
				page: key[1],
			});

			promocodesCountRef.current = result.count;
			return result;
		},
		{
			onError(err) {
				console.error("Error fetching promocodes", err);
				enqueueSnackbar(err.message, { variant: "error" });
			},
			focusThrottleInterval: 60e3,
			keepPreviousData: true,
		}
	);

	const createPromocode = useCallback(
		async function (body: CreatePromocodeBody) {
			try {
				await promocodeApi.createPromocode(body);
				mutate(["promocodes", page, pageSize]);
			} catch (error) {
				console.error("Error creating promocode", error);
				if (error instanceof Error) enqueueSnackbar(error.message, { variant: "error" });
			}
		},
		[page, pageSize]
	);

	const deletePromocode = useCallback(
		async function (id: string) {
			try {
				await mutate<PromocodeList | undefined, void>(
					["promocodes", page, pageSize],
					promocodeApi.deletePromocode(id),
					{
						optimisticData(currentData, displayedData) {
							if (!displayedData) return;

							return {
								count: displayedData.count - 1,
								items: displayedData.items.filter((item) => item.id !== id),
							};
						},
						rollbackOnError: true,
						populateCache(result, currentData) {
							if (!currentData) return;

							return {
								count: currentData.count - 1,
								items: currentData.items.filter((item) => item.id !== id),
							};
						},
					}
				);
			} catch (error) {
				console.error("Error deleting promocode", error);
				if (error instanceof Error) enqueueSnackbar(error.message, { variant: "error" });
			}
		},
		[page, pageSize]
	);

	const promocodeStatistics = useSwr(
		["promocodeStatistics", promocodeId, from, to],
		async ([_, id, from, to]) => {
			if (!id) {
				return null;
			}

			const promocodeStatisticsResponse = await promocodeApi.getPromocodeStatistics(id, from, to);

			return promocodeStatisticsResponse;
		},
		{
			onError(err) {
				console.error("Error fetching promocode statistics", err);
				enqueueSnackbar(err.message, { variant: "error" });
			},
			focusThrottleInterval: 60e3,
			keepPreviousData: true,
		}
	);

	const createFastLink = useCallback(
		async function (id: string) {
			try {
				await promocodeApi.createFastlink(id);
				mutate(["promocodes", page, pageSize]);
			} catch (error) {
				console.error("Error creating fast link", error);
				if (error instanceof Error) enqueueSnackbar(error.message, { variant: "error" });
			}
		},
		[page, pageSize]
	);

	return {
		...swrResponse,
		createPromocode,
		deletePromocode,
		createFastLink,
		promocodeStatistics: promocodeStatistics.data,
		promocodesCount: promocodesCountRef.current,
	};
}

export function useAllPromocodes() {
	const { data } = useSwr("allPromocodes", promocodeApi.getAllPromocodes, {
		keepPreviousData: true,
		suspense: true,
		onError(err) {
			console.error("Error fetching all promocodes", err);
			enqueueSnackbar(err.message, { variant: "error" });
		},
	});

	return data;
}