Skip to content

Your favorite shift management application!

10.3 KB
Raw Blame
"use client";

import { useState, useCallback } from "react";
import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
import { toast } from "sonner";
import { useTranslations } from "next-intl";
import { queryKeys } from "@/lib/query-keys";
import {
  handleRateLimitError,
  isRateLimitError,
} from "@/lib/rate-limit-client";
import { ApiError } from "@/lib/api-error";
import { generateTempId } from "@/lib/utils";
import { useIsCalendarAccessible } from "@/hooks/useCalendars";
import type { BundleRef } from "@/lib/permission-bundles";

export interface CalendarShare {
  id: string;
  calendarId: string;
  userId: string;
  bundleId: string;
  bundle: BundleRef;
  sharedBy: string;
  createdAt: Date;
  user: {
    id: string;
    name: string | null;
    email: string;
    image: string | null;
  };
  sharedByUser: {
    id: string;
    name: string | null;
    email: string;
  };
}

export interface SearchUser {
  id: string;
  name: string | null;
  email: string;
  image: string | null;
}

/** Optimistic placeholder for a bundle reference — settles once the real response/refetch lands. */
function placeholderBundle(bundleId: string): BundleRef {
  return { id: bundleId, name: "…", seedKey: null };
}

/**
 * Fetch calendar shares from API
 */
async function fetchSharesApi(calendarId: string): Promise<CalendarShare[]> {
  const response = await fetch(`/api/calendars/${calendarId}/shares`);

  if (!response.ok) {
    throw new ApiError("Failed to fetch shares", response.status);
  }

  const data = await response.json();

  // Parse date strings to Date objects
  return data.map((share: Record<string, unknown>) => ({
    ...share,
    createdAt: new Date(share.createdAt as string),
  }));
}

/**
 * Add a new share via API
 */
async function addShareApi(
  calendarId: string,
  userId: string,
  bundleId: string
): Promise<CalendarShare> {
  const response = await fetch(`/api/calendars/${calendarId}/shares`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ userId, bundleId }),
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(error.error || "Failed to add share");
  }

  const data = await response.json();

  return {
    ...data,
    createdAt: new Date(data.createdAt),
  };
}

/**
 * Update a share's bundle via API
 */
async function updateShareApi(
  calendarId: string,
  shareId: string,
  bundleId: string
): Promise<CalendarShare> {
  const response = await fetch(
    `/api/calendars/${calendarId}/shares/${shareId}`,
    {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ bundleId }),
    }
  );

  if (!response.ok) {
    throw new Error("Failed to update share");
  }

  const data = await response.json();

  return {
    ...data,
    createdAt: new Date(data.createdAt),
  };
}

/**
 * Remove a share via API
 */
async function removeShareApi(
  calendarId: string,
  shareId: string
): Promise<void> {
  const response = await fetch(
    `/api/calendars/${calendarId}/shares/${shareId}`,
    {
      method: "DELETE",
    }
  );

  if (!response.ok) {
    throw new Error("Failed to remove share");
  }
}

/**
 * Calendar Shares Hook
 *
 * Provides calendar share management with automatic polling.
 * Uses React Query for automatic cache management and live updates.
 *
 * Features:
 * - Fetch shares for a calendar
 * - Add, update, and remove shares
 * - Optimistic updates for instant UI feedback
 * - User search functionality (local state)
 * - Automatic polling every 5 seconds
 *
 * @param calendarId - Calendar ID to manage shares for
 * @returns Object with shares data and management functions
 */
export function useCalendarShares(calendarId: string) {
  const t = useTranslations();
  const queryClient = useQueryClient();

  // User search state (not server data)
  const [searchResults, setSearchResults] = useState<SearchUser[]>([]);
  const [searchLoading, setSearchLoading] = useState(false);

  const accessible = useIsCalendarAccessible(calendarId);

  // Fetch shares
  const { data: shares = [], isLoading: loading } = useQuery({
    queryKey: queryKeys.shares.byCalendar(calendarId),
    queryFn: () => fetchSharesApi(calendarId),
    enabled: accessible,
  });

  // Add share mutation
  const addShareMutation = useMutation({
    mutationFn: ({
      userId,
      bundleId,
    }: {
      userId: string;
      bundleId: string;
    }) => addShareApi(calendarId, userId, bundleId),
    onMutate: async ({ userId, bundleId }) => {
      await queryClient.cancelQueries({
        queryKey: queryKeys.shares.byCalendar(calendarId),
      });
      const previous = queryClient.getQueryData(
        queryKeys.shares.byCalendar(calendarId)
      );

      // Optimistic update — the bundle's name/seedKey are filled in once the
      // real response/refetch lands, a brief "…" is an acceptable approximation.
      const optimisticShare: CalendarShare = {
        id: `temp-${generateTempId()}`,
        calendarId,
        userId,
        bundleId,
        bundle: placeholderBundle(bundleId),
        sharedBy: "current-user",
        createdAt: new Date(),
        user: {
          id: userId,
          name: null,
          email: "",
          image: null,
        },
        sharedByUser: {
          id: "current-user",
          name: null,
          email: "",
        },
      };

      queryClient.setQueryData(
        queryKeys.shares.byCalendar(calendarId),
        (old: CalendarShare[] = []) => [optimisticShare, ...old]
      );

      return { previous };
    },
    onError: (err, variables, context) => {
      queryClient.setQueryData(
        queryKeys.shares.byCalendar(calendarId),
        context?.previous
      );
      toast.error(
        err instanceof Error
          ? err.message
          : t("common.createError", { item: t("share.share") })
      );
    },
    onSuccess: () => {
      toast.success(t("share.shareAdded"));
    },
    onSettled: () => {
      queryClient.invalidateQueries({
        queryKey: queryKeys.shares.byCalendar(calendarId),
      });
    },
  });

  // Update share mutation
  const updateShareMutation = useMutation({
    mutationFn: ({
      shareId,
      bundleId,
    }: {
      shareId: string;
      bundleId: string;
    }) => updateShareApi(calendarId, shareId, bundleId),
    onMutate: async ({ shareId, bundleId }) => {
      await queryClient.cancelQueries({
        queryKey: queryKeys.shares.byCalendar(calendarId),
      });
      const previous = queryClient.getQueryData(
        queryKeys.shares.byCalendar(calendarId)
      );

      // Optimistic update — bundle name/seedKey settle once the refetch lands.
      queryClient.setQueryData(
        queryKeys.shares.byCalendar(calendarId),
        (old: CalendarShare[] = []) =>
          old.map((s) =>
            s.id === shareId
              ? { ...s, bundleId, bundle: placeholderBundle(bundleId) }
              : s
          )
      );

      return { previous };
    },
    onError: (err, variables, context) => {
      queryClient.setQueryData(
        queryKeys.shares.byCalendar(calendarId),
        context?.previous
      );
      toast.error(t("common.updateError", { item: t("share.share") }));
    },
    onSuccess: () => {
      toast.success(t("share.shareUpdated"));
    },
    onSettled: () => {
      queryClient.invalidateQueries({
        queryKey: queryKeys.shares.byCalendar(calendarId),
      });
    },
  });

  // Remove share mutation
  const removeShareMutation = useMutation({
    mutationFn: (shareId: string) => removeShareApi(calendarId, shareId),
    onMutate: async (shareId) => {
      await queryClient.cancelQueries({
        queryKey: queryKeys.shares.byCalendar(calendarId),
      });
      const previous = queryClient.getQueryData(
        queryKeys.shares.byCalendar(calendarId)
      );

      // Optimistic update
      queryClient.setQueryData(
        queryKeys.shares.byCalendar(calendarId),
        (old: CalendarShare[] = []) => old.filter((s) => s.id !== shareId)
      );

      return { previous };
    },
    onError: (err, shareId, context) => {
      queryClient.setQueryData(
        queryKeys.shares.byCalendar(calendarId),
        context?.previous
      );
      toast.error(t("common.deleteError", { item: t("share.share") }));
    },
    onSuccess: () => {
      toast.success(t("share.shareRemoved"));
    },
    onSettled: () => {
      queryClient.invalidateQueries({
        queryKey: queryKeys.shares.byCalendar(calendarId),
      });
    },
  });

  // User search (local state, not server state)
  const searchUsers = useCallback(
    async (query: string) => {
      if (!query || query.length < 2) {
        setSearchResults([]);
        return;
      }

      setSearchLoading(true);
      try {
        const response = await fetch(
          `/api/users/search?q=${encodeURIComponent(
            query
          )}&calendarId=${calendarId}`
        );

        if (isRateLimitError(response)) {
          await handleRateLimitError(response, t);
          setSearchResults([]);
          return;
        }

        if (!response.ok) {
          throw new Error("Failed to search users");
        }

        const data = await response.json();
        setSearchResults(data);
      } catch (error) {
        console.error("Failed to search users:", error);
        toast.error(t("common.fetchError", { item: t("common.labels.users") }));
      } finally {
        setSearchLoading(false);
      }
    },
    [calendarId, t]
  );

  return {
    shares,
    loading,
    searchResults,
    searchLoading,
    addShare: async (
      userId: string,
      bundleId: string
    ): Promise<{ success: boolean }> => {
      try {
        await addShareMutation.mutateAsync({ userId, bundleId });
        return { success: true };
      } catch {
        return { success: false };
      }
    },
    updateShare: async (
      shareId: string,
      bundleId: string
    ): Promise<{ success: boolean }> => {
      try {
        await updateShareMutation.mutateAsync({ shareId, bundleId });
        return { success: true };
      } catch {
        return { success: false };
      }
    },
    removeShare: async (shareId: string): Promise<{ success: boolean }> => {
      try {
        await removeShareMutation.mutateAsync(shareId);
        return { success: true };
      } catch {
        return { success: false };
      }
    },
    searchUsers,
  };
}