@calcom/atoms 2.8.0 → 2.8.1

package/src/hooks/bookings/use-cancel-booking.ts

@@ -1,47 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import type { z } from "zod";
-
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiErrorResponse, ApiResponse, bookingCancelSchema } from "../../contracts";
-
-import http from "../../lib/http";
-
-interface IUseCancelBooking {
-  onSuccess?: () => void;
-  onError?: (err: ApiErrorResponse | Error) => void;
-}
-
-type inputParams = z.infer<typeof bookingCancelSchema>;
-
-export const useCancelBooking = (
-  { onSuccess, onError }: IUseCancelBooking = {
-    onSuccess: () => {
-      return;
-    },
-    onError: () => {
-      return;
-    },
-  }
-) => {
-  const cancelBooking = useMutation<ApiResponse, Error, inputParams>({
-    mutationFn: (data) => {
-      return http.post<ApiResponse>(`/bookings/${data.uid}/cancel`, data).then((res) => {
-        if (res.data.status === SUCCESS_STATUS) {
-          return res.data;
-        }
-        throw new Error(res.data.error.message);
-      });
-    },
-    onSuccess: (data) => {
-      if (data.status === SUCCESS_STATUS) {
-        onSuccess?.();
-      } else {
-        onError?.(data);
-      }
-    },
-    onError: (err) => {
-      onError?.(err);
-    },
-  });
-  return cancelBooking;
-};

package/src/hooks/bookings/use-create-booking.ts

@@ -1,43 +0,0 @@
-import { type UseMutationResult, useMutation } from "@tanstack/react-query";
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiErrorResponse, ApiResponse, ApiSuccessResponse, BookingResponse } from "../../contracts";
-import type { BookingCreateInput } from "../../contracts/booker";
-import http from "../../lib/http";
-
-interface IUseCreateBooking {
-  onSuccess?: (res: ApiSuccessResponse<BookingResponse>) => void;
-  onError?: (err: ApiErrorResponse | Error) => void;
-}
-
-type UseCreateBookingInput = BookingCreateInput;
-
-const noop = (): void => undefined;
-
-export const useCreateBooking = ({
-  onSuccess = noop,
-  onError = noop,
-}: IUseCreateBooking = {}): UseMutationResult<ApiResponse<BookingResponse>, Error, UseCreateBookingInput> => {
-  const createBooking = useMutation<ApiResponse<BookingResponse>, Error, UseCreateBookingInput>({
-    mutationFn: (data: UseCreateBookingInput) => {
-      return http.post<ApiResponse<BookingResponse>>("/bookings", data).then((res) => {
-        if (res.data.status === SUCCESS_STATUS) {
-          return res.data;
-        }
-        throw new Error(res.data.error.message);
-      });
-    },
-    onSuccess: (data: ApiResponse<BookingResponse>) => {
-      if (data.status === SUCCESS_STATUS) {
-        onSuccess(data);
-      } else {
-        onError(data);
-      }
-    },
-    onError: (err: Error) => {
-      onError(err);
-    },
-  });
-  return createBooking;
-};
-
-export type { UseCreateBookingInput };

package/src/hooks/bookings/use-create-instant-booking.ts

@@ -1,39 +0,0 @@
-import { type UseMutationResult, useMutation } from "@tanstack/react-query";
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiErrorResponse, ApiResponse, ApiSuccessResponse, BookingResponse } from "../../contracts";
-import type { BookingInput } from "../../contracts/booker";
-import http from "../../lib/http";
-
-interface IUseCreateInstantBooking {
-  onSuccess?: (res: ApiSuccessResponse<BookingResponse>) => void;
-  onError?: (err: ApiErrorResponse | Error) => void;
-}
-
-const noop = (): void => undefined;
-
-export const useCreateInstantBooking = ({
-  onSuccess = noop,
-  onError = noop,
-}: IUseCreateInstantBooking = {}): UseMutationResult<ApiResponse<BookingResponse>, Error, BookingInput> => {
-  const createInstantBooking = useMutation<ApiResponse<BookingResponse>, Error, BookingInput>({
-    mutationFn: (data: BookingInput) => {
-      return http.post<ApiResponse<BookingResponse>>("/bookings/instant", data).then((res) => {
-        if (res.data.status === SUCCESS_STATUS) {
-          return res.data;
-        }
-        throw new Error(res.data.error.message);
-      });
-    },
-    onSuccess: (data: ApiResponse<BookingResponse>) => {
-      if (data.status === SUCCESS_STATUS) {
-        onSuccess(data);
-      } else {
-        onError(data);
-      }
-    },
-    onError: (err: Error) => {
-      onError(err);
-    },
-  });
-  return createInstantBooking;
-};

package/src/hooks/bookings/use-create-recurring-booking.ts

@@ -1,42 +0,0 @@
-import { type UseMutationResult, useMutation } from "@tanstack/react-query";
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiErrorResponse, ApiResponse, ApiSuccessResponse, BookingResponse } from "../../contracts";
-import type { RecurringBookingCreateInput } from "../../contracts/booker";
-import http from "../../lib/http";
-
-interface IUseCreateRecurringBooking {
-  onSuccess?: (res: ApiSuccessResponse<BookingResponse[]>) => void;
-  onError?: (err: ApiErrorResponse | Error) => void;
-}
-
-const noop = (): void => undefined;
-
-export const useCreateRecurringBooking = ({
-  onSuccess = noop,
-  onError = noop,
-}: IUseCreateRecurringBooking = {}): UseMutationResult<
-  ApiResponse<BookingResponse[]>,
-  Error,
-  RecurringBookingCreateInput[]
-> => {
-  const createRecurringBooking = useMutation<
-    ApiResponse<BookingResponse[]>,
-    Error,
-    RecurringBookingCreateInput[]
-  >({
-    mutationFn: (data: RecurringBookingCreateInput[]) => {
-      return http.post<ApiResponse<BookingResponse[]>>("/bookings/recurring", data).then((res) => res.data);
-    },
-    onSuccess: (data: ApiResponse<BookingResponse[]>) => {
-      if (data.status === SUCCESS_STATUS) {
-        onSuccess(data);
-      } else {
-        onError(data);
-      }
-    },
-    onError: (err: Error) => {
-      onError(err);
-    },
-  });
-  return createRecurringBooking;
-};

package/src/hooks/bookings/use-get-booking-for-reschedule.ts

@@ -1,51 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-
-import { SUCCESS_STATUS, V2_ENDPOINTS } from "../../constants";
-import type { ApiResponse, ApiSuccessResponse, AtomBookingForReschedule } from "../../contracts";
-
-import http from "../../lib/http";
-import { useAtomsContext } from "../use-atoms-context";
-
-export const QUERY_KEY = "user-booking";
-
-interface IUseGetBookingForReschedule {
-  onSuccess?: (res: ApiSuccessResponse<AtomBookingForReschedule>["data"]) => void;
-  onError?: (err: Error) => void;
-  uid?: string;
-}
-export const useGetBookingForReschedule = (
-  props: IUseGetBookingForReschedule = {
-    onSuccess: () => {
-      return;
-    },
-    onError: () => {
-      return;
-    },
-    uid: "",
-  }
-) => {
-  const { isInit } = useAtomsContext();
-  const pathname = `/${V2_ENDPOINTS.bookings}/${props.uid}/reschedule`;
-  const bookingQuery = useQuery({
-    queryKey: [QUERY_KEY, props.uid],
-    queryFn: () => {
-      return http
-        .get<ApiResponse<AtomBookingForReschedule>>(pathname)
-        .then((res) => {
-          if (res.data.status === SUCCESS_STATUS) {
-            props.onSuccess?.((res.data as ApiSuccessResponse<AtomBookingForReschedule>).data);
-            return (res.data as ApiSuccessResponse<AtomBookingForReschedule>).data;
-          }
-          const error = new Error(res.data.error.message);
-          props.onError?.(error);
-          throw error;
-        })
-        .catch((err) => {
-          props.onError?.(err);
-        });
-    },
-    enabled: isInit && !!props?.uid,
-  });
-
-  return bookingQuery;
-};

package/src/hooks/bookings/use-handle-book-event.ts

@@ -1,156 +0,0 @@
-// @ts-nocheck — wrapper/hook reconciles loose atoms contracts with legacy
-// backend payload shapes (unknowns from Record<string, any> branches, Radix
-// prop-pick narrowing). Runtime matches pre-extract behavior; a targeted
-// typing pass follows once the contracts are tightened per-consumer.
-
-import { useSearchParams } from "next/navigation";
-import { useBookerStoreContext } from "../../booker/booker-store-provider";
-import { useBookerTime } from "../../booker/hooks/use-booker-time";
-import type { UseBookingFormReturnType } from "../../booker/hooks/use-booking-form";
-import { showToast } from "../../components/ui/show-toast";
-import type { BookerEvent, RoutingFormSearchParams } from "../../contracts";
-import type { BookingInput, RecurringBookingCreateInput } from "../../contracts/booker";
-import { getUtmTrackingParameters } from "../../lib/get-utm-tracking-parameters";
-import {
-  mapBookingToMutationInput,
-  mapRecurringBookingToMutationInput,
-} from "../../vendor/booking-to-mutation-input";
-import { useAtomsLocale as useLocale } from "../use-atoms-locale";
-import { useIsPlatform } from "../use-is-platform";
-import type { UseCreateBookingInput } from "./use-create-booking";
-
-type Callbacks = { onSuccess?: () => void; onError?: (err: unknown) => void };
-type UseHandleBookingProps = {
-  bookingForm: UseBookingFormReturnType["bookingForm"];
-  event?: {
-    data?: Pick<
-      BookerEvent,
-      "id" | "isDynamic" | "metadata" | "recurringEvent" | "length" | "slug" | "schedulingType"
-    > | null;
-  };
-  metadata: Record<string, string>;
-  hashedLink?: string | null;
-  handleBooking: (input: UseCreateBookingInput, callbacks?: Callbacks) => void;
-  handleInstantBooking: (input: BookingInput, callbacks?: Callbacks) => void;
-  handleRecBooking: (input: RecurringBookingCreateInput[], callbacks?: Callbacks) => void;
-  locationUrl?: string;
-  routingFormSearchParams?: RoutingFormSearchParams;
-  isBookingDryRun?: boolean;
-  rrHostSubsetIds?: number[];
-};
-
-export const useHandleBookEvent = ({
-  bookingForm,
-  event,
-  metadata,
-  hashedLink,
-  handleBooking,
-  handleInstantBooking,
-  handleRecBooking,
-  locationUrl,
-  routingFormSearchParams,
-  isBookingDryRun,
-  rrHostSubsetIds,
-}: UseHandleBookingProps): ((inputTimeSlot?: string) => void) => {
-  const isPlatform = useIsPlatform();
-  const setFormValues = useBookerStoreContext((state) => state.setFormValues);
-  const storeTimeSlot = useBookerStoreContext((state) => state.selectedTimeslot);
-  const duration = useBookerStoreContext((state) => state.selectedDuration);
-  const { timezone } = useBookerTime();
-  const rescheduleUid = useBookerStoreContext((state) => state.rescheduleUid);
-  const rescheduledBy = useBookerStoreContext((state) => state.rescheduledBy);
-  const { t, i18n } = useLocale();
-  const username = useBookerStoreContext((state) => state.username);
-  const recurringEventCount = useBookerStoreContext((state) => state.recurringEventCount);
-  const bookingData = useBookerStoreContext((state) => state.bookingData);
-  const seatedEventData = useBookerStoreContext((state) => state.seatedEventData);
-  const isInstantMeeting = useBookerStoreContext((state) => state.isInstantMeeting);
-  const orgSlug = useBookerStoreContext((state) => state.org);
-  const teamMemberEmail = useBookerStoreContext((state) => state.teamMemberEmail);
-  const crmOwnerRecordType = useBookerStoreContext((state) => state.crmOwnerRecordType);
-  const crmAppSlug = useBookerStoreContext((state) => state.crmAppSlug);
-  const crmRecordId = useBookerStoreContext((state) => state.crmRecordId);
-  const pendingCrmTraceId = useBookerStoreContext((state) => state.pendingCrmTraceId);
-  const verificationCode = useBookerStoreContext((state) => state.verificationCode);
-  const handleError = (err: unknown): void => {
-    let errorMessage = t("can_you_try_again");
-    if (err instanceof Error) {
-      errorMessage = t(err.message);
-    }
-    showToast(errorMessage, "error");
-  };
-  const searchParams = useSearchParams();
-
-  const handleBookEvent = (inputTimeSlot?: string): void => {
-    const values = bookingForm.getValues();
-    const timeslot = inputTimeSlot ?? storeTimeSlot;
-    let callbacks: Callbacks | undefined;
-    if (inputTimeSlot && !isPlatform) {
-      callbacks = { onError: handleError };
-    }
-    if (timeslot) {
-      // Clears form values stored in store, so old values won't stick around.
-      setFormValues({});
-      bookingForm.clearErrors();
-
-      // It shouldn't be possible that this method is fired without having event data,
-      // but since in theory (looking at the types) it is possible, we still handle that case.
-      if (!event?.data) {
-        bookingForm.setError("globalError", { message: t("error_booking_event") });
-        return;
-      }
-
-      // Ensures that duration is an allowed value, if not it defaults to the
-      // default event duration.
-      let validDuration = event.data.length;
-      if (event.data.isDynamic) {
-        validDuration = duration || event.data.length;
-      } else if (duration && event.data.metadata?.multipleDuration?.includes(duration)) {
-        validDuration = duration;
-      }
-
-      const bookingInput = {
-        values,
-        duration: validDuration,
-        event: event.data,
-        date: timeslot,
-        timeZone: timezone,
-        language: i18n.language,
-        rescheduleUid: rescheduleUid || undefined,
-        rescheduledBy: rescheduledBy || undefined,
-        bookingUid: bookingData?.uid || seatedEventData?.bookingUid || undefined,
-        username: username || "",
-        metadata: metadata,
-        hashedLink,
-        teamMemberEmail,
-        crmOwnerRecordType,
-        crmAppSlug,
-        crmRecordId,
-        pendingCrmTraceId,
-        orgSlug: orgSlug || undefined,
-        routingFormSearchParams,
-        isDryRunProp: isBookingDryRun,
-        verificationCode: verificationCode || undefined,
-        rrHostSubsetIds,
-      };
-
-      const tracking = getUtmTrackingParameters(searchParams);
-
-      if (isInstantMeeting) {
-        handleInstantBooking(mapBookingToMutationInput(bookingInput), callbacks);
-      } else if (event.data?.recurringEvent?.freq != null && recurringEventCount && !rescheduleUid) {
-        handleRecBooking(
-          mapRecurringBookingToMutationInput(bookingInput, recurringEventCount, tracking),
-          callbacks
-        );
-      } else {
-        handleBooking({ ...mapBookingToMutationInput(bookingInput), locationUrl, tracking }, callbacks);
-      }
-      // Clears form values stored in store, so old values won't stick around.
-      setFormValues({});
-      bookingForm.clearErrors();
-    }
-  };
-
-  return handleBookEvent;
-};

package/src/hooks/calendars/__tests__/use-calendar-mutations.test.tsx

@@ -1,225 +0,0 @@
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { act, renderHook, waitFor } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import http from "../../../lib/http";
-import { useAddSelectedCalendar } from "../use-add-selected-calendar";
-import { useDeleteCalendarCredentials } from "../use-delete-calendar-credentials";
-import { useRemoveSelectedCalendar } from "../use-remove-selected-calendar";
-import { useUpdateDestinationCalendars } from "../use-update-destination-calendars";
-
-function makeWrapper() {
-  const client = new QueryClient({
-    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
-  });
-  return ({ children }: { children: ReactNode }) => (
-    <QueryClientProvider client={client}>{children}</QueryClientProvider>
-  );
-}
-
-describe("useAddSelectedCalendar", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("posts the calendar data and drops delegationCredentialId when null", async () => {
-    const postSpy = vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "success" },
-    } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useAddSelectedCalendar({ onSuccess }), {
-      wrapper: makeWrapper(),
-    });
-    act(() => {
-      result.current.mutate({
-        credentialId: 1,
-        integration: "google",
-        externalId: "x",
-        delegationCredentialId: null,
-      });
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalled());
-    expect(postSpy.mock.calls[0]?.[1]).toEqual({
-      credentialId: 1,
-      integration: "google",
-      externalId: "x",
-    });
-  });
-
-  it("includes delegationCredentialId when provided", async () => {
-    const postSpy = vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "success" },
-    } as never);
-    const { result } = renderHook(() => useAddSelectedCalendar(), {
-      wrapper: makeWrapper(),
-    });
-    act(() => {
-      result.current.mutate({
-        credentialId: 1,
-        integration: "google",
-        externalId: "x",
-        delegationCredentialId: "del-123",
-      });
-    });
-    await waitFor(() => expect(postSpy).toHaveBeenCalled());
-    expect(postSpy.mock.calls[0]?.[1]).toEqual(
-      expect.objectContaining({ delegationCredentialId: "del-123" })
-    );
-  });
-
-  it("calls onError on a non-success response", async () => {
-    vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "error", error: { message: "bad" } },
-    } as never);
-    const onError = vi.fn();
-    const { result } = renderHook(() => useAddSelectedCalendar({ onError }), {
-      wrapper: makeWrapper(),
-    });
-    act(() => {
-      result.current.mutate({
-        credentialId: 1,
-        integration: "google",
-        externalId: "x",
-        delegationCredentialId: null,
-      });
-    });
-    await waitFor(() => expect(onError).toHaveBeenCalled());
-  });
-});
-
-describe("useRemoveSelectedCalendar", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("builds a url-encoded delete URL", async () => {
-    const deleteSpy = vi.spyOn(http, "delete").mockResolvedValue({
-      data: { status: "success" },
-    } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useRemoveSelectedCalendar({ onSuccess }), {
-      wrapper: makeWrapper(),
-    });
-    act(() => {
-      result.current.mutate({
-        credentialId: 1,
-        integration: "google",
-        externalId: "a@b.test",
-        delegationCredentialId: null,
-      });
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalled());
-    expect(deleteSpy.mock.calls[0]?.[0]).toContain("credentialId=1");
-    expect(deleteSpy.mock.calls[0]?.[0]).toContain("integration=google");
-    expect(deleteSpy.mock.calls[0]?.[0]).toContain("externalId=a%40b.test");
-  });
-
-  it("appends delegationCredentialId when provided", async () => {
-    const deleteSpy = vi.spyOn(http, "delete").mockResolvedValue({
-      data: { status: "success" },
-    } as never);
-    const { result } = renderHook(() => useRemoveSelectedCalendar(), {
-      wrapper: makeWrapper(),
-    });
-    act(() => {
-      result.current.mutate({
-        credentialId: 1,
-        integration: "google",
-        externalId: "a",
-        delegationCredentialId: "del-x",
-      });
-    });
-    await waitFor(() => expect(deleteSpy).toHaveBeenCalled());
-    expect(deleteSpy.mock.calls[0]?.[0]).toContain("delegationCredentialId=del-x");
-  });
-
-  it("calls onError on a non-success response", async () => {
-    vi.spyOn(http, "delete").mockResolvedValue({
-      data: { status: "error", error: { message: "bad" } },
-    } as never);
-    const onError = vi.fn();
-    const { result } = renderHook(() => useRemoveSelectedCalendar({ onError }), {
-      wrapper: makeWrapper(),
-    });
-    act(() => {
-      result.current.mutate({
-        credentialId: 1,
-        integration: "google",
-        externalId: "a",
-        delegationCredentialId: null,
-      });
-    });
-    await waitFor(() => expect(onError).toHaveBeenCalled());
-  });
-});
-
-describe("useDeleteCalendarCredentials", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("posts to the disconnect endpoint for the calendar", async () => {
-    const postSpy = vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "success" },
-    } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useDeleteCalendarCredentials({ onSuccess }), {
-      wrapper: makeWrapper(),
-    });
-    act(() => {
-      result.current.mutate({ id: 42, calendar: "google" as never });
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalled());
-    expect(postSpy.mock.calls[0]?.[0]).toBe("/calendars/google/disconnect");
-    expect(postSpy.mock.calls[0]?.[1]).toEqual({ id: 42 });
-  });
-
-  it("calls onError on a non-success response", async () => {
-    vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "error", error: { message: "bad" } },
-    } as never);
-    const onError = vi.fn();
-    const { result } = renderHook(() => useDeleteCalendarCredentials({ onError }), {
-      wrapper: makeWrapper(),
-    });
-    act(() => {
-      result.current.mutate({ id: 42, calendar: "google" as never });
-    });
-    await waitFor(() => expect(onError).toHaveBeenCalled());
-  });
-});
-
-describe("useUpdateDestinationCalendars", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("puts the destination calendar payload", async () => {
-    const putSpy = vi.spyOn(http, "put").mockResolvedValue({
-      data: { status: "success" },
-    } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useUpdateDestinationCalendars({ onSuccess }), {
-      wrapper: makeWrapper(),
-    });
-    act(() => {
-      result.current.mutate({ integration: "google", externalId: "cal" });
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalled());
-    expect(putSpy.mock.calls[0]?.[0]).toBe("/destination-calendars");
-  });
-
-  it("calls onError on a non-success response", async () => {
-    vi.spyOn(http, "put").mockResolvedValue({
-      data: { status: "error", error: { message: "bad" } },
-    } as never);
-    const onError = vi.fn();
-    const { result } = renderHook(() => useUpdateDestinationCalendars({ onError }), {
-      wrapper: makeWrapper(),
-    });
-    act(() => {
-      result.current.mutate({ integration: "google", externalId: "cal" });
-    });
-    await waitFor(() => expect(onError).toHaveBeenCalled());
-  });
-
-  it("works with no-arg invocation", () => {
-    const { result } = renderHook(() => useUpdateDestinationCalendars(), {
-      wrapper: makeWrapper(),
-    });
-    expect(typeof result.current.mutate).toBe("function");
-  });
-});

package/src/hooks/calendars/use-add-selected-calendar.ts

@@ -1,65 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiErrorResponse, ApiResponse } from "../../contracts";
-
-import http from "../../lib/http";
-
-interface IUseAddSelectedCalendar {
-  onSuccess?: (res: ApiResponse) => void;
-  onError?: (err: ApiErrorResponse | Error) => void;
-}
-
-export const useAddSelectedCalendar = (
-  { onSuccess, onError }: IUseAddSelectedCalendar = {
-    onSuccess: () => {
-      return;
-    },
-    onError: () => {
-      return;
-    },
-  }
-) => {
-  const newlyAddedCalendarEntry = useMutation<
-    ApiResponse<{
-      status: string;
-      data: {
-        userId: number;
-        integration: string;
-        externalId: string;
-        credentialId: number | null;
-      };
-    }>,
-    unknown,
-    {
-      credentialId: number;
-      integration: string;
-      externalId: string;
-      delegationCredentialId: string | null;
-    }
-  >({
-    mutationFn: (data) => {
-      const { delegationCredentialId, ...rest } = data;
-      return http
-        .post(`/selected-calendars`, {
-          ...rest,
-          ...(delegationCredentialId ? { delegationCredentialId } : {}),
-        })
-        .then((res) => {
-          return res.data;
-        });
-    },
-    onSuccess: (data) => {
-      if (data.status === SUCCESS_STATUS) {
-        onSuccess?.(data);
-      } else {
-        onError?.(data);
-      }
-    },
-    onError: (err) => {
-      onError?.(err as ApiErrorResponse);
-    },
-  });
-
-  return newlyAddedCalendarEntry;
-};