@calcom/atoms 2.8.0 → 2.8.1

package/src/hooks/__tests__/use-is-platform.test.tsx

@@ -1,58 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { describe, expect, it } from "vitest";
-import { AtomsContext } from "../use-atoms-context";
-import { useIsPlatform } from "../use-is-platform";
-import { useIsPlatformBookerEmbed } from "../use-is-platform-booker-embed";
-
-function wrap(contextValue: Record<string, unknown> = {}) {
-  return ({ children }: { children: ReactNode }) => (
-    <AtomsContext.Provider value={contextValue as never}>{children}</AtomsContext.Provider>
-  );
-}
-
-describe("useIsPlatform", () => {
-  it("is true when clientId is set", () => {
-    const { result } = renderHook(() => useIsPlatform(), {
-      wrapper: wrap({ clientId: "client-123" }),
-    });
-    expect(result.current).toBe(true);
-  });
-
-  it("is false when clientId is empty", () => {
-    const { result } = renderHook(() => useIsPlatform(), {
-      wrapper: wrap({ clientId: "" }),
-    });
-    expect(result.current).toBe(false);
-  });
-
-  it("is false when context is empty", () => {
-    const { result } = renderHook(() => useIsPlatform(), {
-      wrapper: wrap({}),
-    });
-    expect(result.current).toBe(false);
-  });
-});
-
-describe("useIsPlatformBookerEmbed", () => {
-  it("is true when both clientId and isEmbed are set", () => {
-    const { result } = renderHook(() => useIsPlatformBookerEmbed(), {
-      wrapper: wrap({ clientId: "client-123", isEmbed: true }),
-    });
-    expect(result.current).toBe(true);
-  });
-
-  it("is false when isEmbed is false", () => {
-    const { result } = renderHook(() => useIsPlatformBookerEmbed(), {
-      wrapper: wrap({ clientId: "client-123", isEmbed: false }),
-    });
-    expect(result.current).toBe(false);
-  });
-
-  it("is false when clientId is missing", () => {
-    const { result } = renderHook(() => useIsPlatformBookerEmbed(), {
-      wrapper: wrap({ isEmbed: true }),
-    });
-    expect(result.current).toBe(false);
-  });
-});

package/src/hooks/__tests__/use-slot-mutations.test.tsx

@@ -1,113 +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 { useDeleteSelectedSlot } from "../use-delete-selected-slot";
-import { useReserveSlot } from "../use-reserve-slot";
-
-function makeWrapper() {
-  const client = new QueryClient({
-    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
-  });
-  return ({ children }: { children: ReactNode }) => (
-    <QueryClientProvider client={client}>{children}</QueryClientProvider>
-  );
-}
-
-describe("useReserveSlot", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("works without any options (no-op defaults)", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(() => useReserveSlot(), { wrapper });
-    expect(typeof result.current.mutate).toBe("function");
-  });
-
-  it("calls onSuccess when the server responds with success", async () => {
-    const wrapper = makeWrapper();
-    vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "success", data: "uid-1" },
-    } as never);
-    const onSuccess = vi.fn();
-    const onError = vi.fn();
-    const { result } = renderHook(() => useReserveSlot({ onSuccess, onError }), { wrapper });
-    act(() => {
-      result.current.mutate({
-        eventTypeId: 1,
-        slotUtcStartDate: "2030-01-01T00:00:00Z",
-        slotUtcEndDate: "2030-01-01T00:30:00Z",
-      } as never);
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalled());
-    expect(onError).not.toHaveBeenCalled();
-  });
-
-  it("calls onError when mutationFn throws", async () => {
-    const wrapper = makeWrapper();
-    vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "error", error: { message: "bad" } },
-    } as never);
-    const onSuccess = vi.fn();
-    const onError = vi.fn();
-    const { result } = renderHook(() => useReserveSlot({ onSuccess, onError }), { wrapper });
-    act(() => {
-      result.current.mutate({
-        eventTypeId: 1,
-        slotUtcStartDate: "2030-01-01T00:00:00Z",
-        slotUtcEndDate: "2030-01-01T00:30:00Z",
-      } as never);
-    });
-    await waitFor(() => expect(onError).toHaveBeenCalled());
-    expect(onSuccess).not.toHaveBeenCalled();
-  });
-});
-
-describe("useDeleteSelectedSlot", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("works without any options", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(() => useDeleteSelectedSlot(), { wrapper });
-    expect(typeof result.current.mutate).toBe("function");
-  });
-
-  it("calls onSuccess when delete succeeds", async () => {
-    const wrapper = makeWrapper();
-    vi.spyOn(http, "delete").mockResolvedValue({
-      data: { status: "success" },
-    } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useDeleteSelectedSlot({ onSuccess }), { wrapper });
-    act(() => {
-      result.current.mutate({ uid: "abc" } as never);
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalled());
-  });
-
-  it("calls onError when delete fails with error status", async () => {
-    const wrapper = makeWrapper();
-    vi.spyOn(http, "delete").mockResolvedValue({
-      data: { status: "error", error: { message: "bad" } },
-    } as never);
-    const onError = vi.fn();
-    const { result } = renderHook(() => useDeleteSelectedSlot({ onError }), { wrapper });
-    act(() => {
-      result.current.mutate({ uid: "abc" } as never);
-    });
-    await waitFor(() => expect(onError).toHaveBeenCalled());
-  });
-
-  it("passes through the uid as query params", async () => {
-    const wrapper = makeWrapper();
-    const deleteSpy = vi.spyOn(http, "delete").mockResolvedValue({
-      data: { status: "success" },
-    } as never);
-    const { result } = renderHook(() => useDeleteSelectedSlot(), { wrapper });
-    act(() => {
-      result.current.mutate({ uid: "xyz" } as never);
-    });
-    await waitFor(() => expect(deleteSpy).toHaveBeenCalled());
-    expect(deleteSpy.mock.calls[0]?.[1]).toEqual(expect.objectContaining({ params: { uid: "xyz" } }));
-  });
-});

package/src/hooks/__tests__/use-timezone-hooks.test.tsx

@@ -1,67 +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 useGetCityTimezones from "../use-get-city-timezones";
-import { useUpdateUserTimezone } from "../use-update-user-timezone";
-
-function makeWrapper() {
-  const client = new QueryClient({
-    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
-  });
-  return ({ children }: { children: ReactNode }) => (
-    <QueryClientProvider client={client}>{children}</QueryClientProvider>
-  );
-}
-
-describe("useGetCityTimezones", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("returns data after a successful fetch", async () => {
-    const wrapper = makeWrapper();
-    vi.spyOn(http, "get").mockResolvedValue({
-      data: {
-        status: "success",
-        data: [
-          { city: "Lisbon", timezone: "Europe/Lisbon" },
-          { city: "Tokyo", timezone: "Asia/Tokyo" },
-        ],
-      },
-    } as never);
-    const { result } = renderHook(() => useGetCityTimezones(), { wrapper });
-    await waitFor(() => expect(result.current.data).toBeDefined());
-    expect(result.current.data).toHaveLength(2);
-    expect(result.current.isLoading).toBe(false);
-  });
-});
-
-describe("useUpdateUserTimezone", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("patches the /me endpoint with the new timezone", async () => {
-    const wrapper = makeWrapper();
-    const patchSpy = vi.spyOn(http, "patch").mockResolvedValue({
-      data: { status: "success", data: {} },
-    } as never);
-    const { result } = renderHook(() => useUpdateUserTimezone(), { wrapper });
-    act(() => {
-      result.current.mutate({ timeZone: "Europe/Madrid" });
-    });
-    await waitFor(() => expect(patchSpy).toHaveBeenCalled());
-    expect(patchSpy.mock.calls[0]?.[1]).toEqual({ timeZone: "Europe/Madrid" });
-  });
-
-  it("surfaces errors when the server returns a non-success status", async () => {
-    const wrapper = makeWrapper();
-    vi.spyOn(http, "patch").mockResolvedValue({
-      data: { status: "error", error: { message: "bad tz" } },
-    } as never);
-    const { result } = renderHook(() => useUpdateUserTimezone(), { wrapper });
-    act(() => {
-      result.current.mutate({ timeZone: "Nowhere/Nope" });
-    });
-    await waitFor(() => expect(result.current.isError).toBe(true));
-    expect((result.current.error as Error).message).toBe("bad tz");
-  });
-});

package/src/hooks/__tests__/use-verify-code.test.tsx

@@ -1,120 +0,0 @@
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { act, renderHook, waitFor } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import http from "../../lib/http";
-import { useVerifyCode } from "../use-verify-code";
-
-function makeWrapper() {
-  const queryClient = new QueryClient({
-    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
-  });
-  return ({ children }: { children: ReactNode }) => (
-    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-  );
-}
-
-describe("useVerifyCode", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("initialises with default state", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(() => useVerifyCode({ onSuccess: vi.fn() }), { wrapper });
-    expect(result.current.isPending).toBe(false);
-    expect(result.current.error).toBe("");
-    expect(result.current.value).toBe("");
-    expect(result.current.hasVerified).toBe(false);
-  });
-
-  it("setValue updates the value state", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(() => useVerifyCode({ onSuccess: vi.fn() }), { wrapper });
-    act(() => {
-      result.current.setValue("123456");
-    });
-    expect(result.current.value).toBe("123456");
-  });
-
-  it("setHasVerified updates the verified flag", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(() => useVerifyCode({ onSuccess: vi.fn() }), { wrapper });
-    act(() => {
-      result.current.setHasVerified(true);
-    });
-    expect(result.current.hasVerified).toBe(true);
-  });
-
-  it("setIsPending updates the pending flag", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(() => useVerifyCode({ onSuccess: vi.fn() }), { wrapper });
-    act(() => {
-      result.current.setIsPending(true);
-    });
-    expect(result.current.isPending).toBe(true);
-  });
-
-  it("resetErrors clears the error state", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(() => useVerifyCode({ onSuccess: vi.fn() }), { wrapper });
-    act(() => {
-      result.current.resetErrors();
-    });
-    expect(result.current.error).toBe("");
-  });
-
-  it("verifyCodeWithSessionRequired triggers the authenticated endpoint and onSuccess", async () => {
-    const wrapper = makeWrapper();
-    const postSpy = vi
-      .spyOn(http, "post")
-      .mockResolvedValue({ data: { status: "success", data: { verified: true } } } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useVerifyCode({ onSuccess }), { wrapper });
-    act(() => {
-      result.current.verifyCodeWithSessionRequired("code-1", "a@b.test");
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalledWith(true));
-    expect(postSpy).toHaveBeenCalledWith(
-      "/atoms/verification/email/verify-code-authenticated",
-      expect.objectContaining({ code: "code-1", email: "a@b.test" })
-    );
-    expect(result.current.hasVerified).toBe(true);
-  });
-
-  it("verifyCodeWithSessionNotRequired triggers the public endpoint and onSuccess", async () => {
-    const wrapper = makeWrapper();
-    const postSpy = vi
-      .spyOn(http, "post")
-      .mockResolvedValue({ data: { status: "success", data: { verified: true } } } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useVerifyCode({ onSuccess }), { wrapper });
-    act(() => {
-      result.current.verifyCodeWithSessionNotRequired("code-2", "a@b.test");
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalledWith(true));
-    expect(postSpy).toHaveBeenCalledWith(
-      "/atoms/verification/email/verify-code",
-      expect.objectContaining({ code: "code-2" })
-    );
-  });
-
-  it("sets a generic error when the API returns an error object", async () => {
-    const wrapper = makeWrapper();
-    vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "error", error: { message: "Something went wrong" } },
-    } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useVerifyCode({ onSuccess }), { wrapper });
-    act(() => {
-      result.current.verifyCodeWithSessionRequired("code-3", "a@b.test");
-    });
-    await waitFor(() => expect(result.current.error).toBe("Verification failed"));
-    expect(result.current.hasVerified).toBe(false);
-    expect(onSuccess).not.toHaveBeenCalled();
-  });
-});

package/src/hooks/bookings/__tests__/use-booking-mutations.test.tsx

@@ -1,123 +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 { useCancelBooking } from "../use-cancel-booking";
-import { useCreateBooking } from "../use-create-booking";
-import { useCreateInstantBooking } from "../use-create-instant-booking";
-import { useCreateRecurringBooking } from "../use-create-recurring-booking";
-
-function makeWrapper() {
-  const client = new QueryClient({
-    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
-  });
-  return ({ children }: { children: ReactNode }) => (
-    <QueryClientProvider client={client}>{children}</QueryClientProvider>
-  );
-}
-
-describe("useCreateBooking", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("calls onSuccess on a success response", async () => {
-    const wrapper = makeWrapper();
-    vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "success", data: { uid: "abc" } },
-    } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useCreateBooking({ onSuccess }), { wrapper });
-    act(() => {
-      result.current.mutate({ eventTypeId: 1 } as never);
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalled());
-  });
-
-  it("calls onError on a non-success response", async () => {
-    const wrapper = makeWrapper();
-    vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "error", error: { message: "nope" } },
-    } as never);
-    const onError = vi.fn();
-    const { result } = renderHook(() => useCreateBooking({ onError }), { wrapper });
-    act(() => {
-      result.current.mutate({ eventTypeId: 1 } as never);
-    });
-    await waitFor(() => expect(onError).toHaveBeenCalled());
-  });
-
-  it("works with no options passed (no-op defaults)", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(() => useCreateBooking(), { wrapper });
-    expect(typeof result.current.mutate).toBe("function");
-  });
-});
-
-describe("useCreateInstantBooking", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("fires a post to /bookings/instant and returns mutate", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(() => useCreateInstantBooking(), { wrapper });
-    expect(typeof result.current.mutate).toBe("function");
-  });
-});
-
-describe("useCreateRecurringBooking", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("fires a post to /bookings (recurring) and returns mutate", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(() => useCreateRecurringBooking(), { wrapper });
-    expect(typeof result.current.mutate).toBe("function");
-  });
-});
-
-describe("useCancelBooking", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("calls onSuccess when the cancel endpoint succeeds", async () => {
-    const wrapper = makeWrapper();
-    vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "success" },
-    } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useCancelBooking({ onSuccess }), { wrapper });
-    act(() => {
-      result.current.mutate({ uid: "abc" } as never);
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalled());
-  });
-
-  it("calls onError when the cancel endpoint returns an error status", async () => {
-    const wrapper = makeWrapper();
-    vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "error", error: { message: "bad" } },
-    } as never);
-    const onError = vi.fn();
-    const { result } = renderHook(() => useCancelBooking({ onError }), { wrapper });
-    act(() => {
-      result.current.mutate({ uid: "abc" } as never);
-    });
-    await waitFor(() => expect(onError).toHaveBeenCalled());
-  });
-
-  it("works with no options", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(() => useCancelBooking(), { wrapper });
-    expect(typeof result.current.mutate).toBe("function");
-  });
-
-  it("uses the booking uid in the URL", async () => {
-    const wrapper = makeWrapper();
-    const postSpy = vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "success" },
-    } as never);
-    const { result } = renderHook(() => useCancelBooking(), { wrapper });
-    act(() => {
-      result.current.mutate({ uid: "my-uid" } as never);
-    });
-    await waitFor(() => expect(postSpy).toHaveBeenCalled());
-    expect(postSpy.mock.calls[0]?.[0]).toBe("/bookings/my-uid/cancel");
-  });
-});

package/src/hooks/bookings/__tests__/use-booking-queries.test.tsx

@@ -1,108 +0,0 @@
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { 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 { AtomsContext } from "../../use-atoms-context";
-import { useBooking } from "../use-booking";
-import { extractBookingsQueryKeys, useBookings } from "../use-bookings";
-import { useGetBookingForReschedule } from "../use-get-booking-for-reschedule";
-
-function wrap(contextValue: Record<string, unknown> = { isInit: true }) {
-  const client = new QueryClient({
-    defaultOptions: { queries: { retry: false } },
-  });
-  return ({ children }: { children: ReactNode }) => (
-    <QueryClientProvider client={client}>
-      <AtomsContext.Provider value={contextValue as never}>{children}</AtomsContext.Provider>
-    </QueryClientProvider>
-  );
-}
-
-describe("useBooking", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("is disabled when no uid is provided", () => {
-    const { result } = renderHook(() => useBooking(""), { wrapper: wrap() });
-    expect(result.current.isFetching).toBe(false);
-    expect(result.current.data).toBeUndefined();
-  });
-
-  it("fetches a booking by uid", async () => {
-    const getSpy = vi.spyOn(http, "get").mockResolvedValue({
-      data: { status: "success", data: { uid: "abc" } },
-    } as never);
-    const { result } = renderHook(() => useBooking("abc"), { wrapper: wrap() });
-    await waitFor(() => expect(result.current.data).toBeDefined());
-    expect(getSpy.mock.calls[0]?.[0]).toContain("/bookings/abc");
-  });
-});
-
-describe("useBookings", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("fetches bookings using the provided input as params", async () => {
-    const getSpy = vi.spyOn(http, "get").mockResolvedValue({
-      data: { status: "success", data: [] },
-    } as never);
-    renderHook(() => useBookings({ status: ["upcoming"], take: 10 } as never), {
-      wrapper: wrap(),
-    });
-    await waitFor(() => expect(getSpy).toHaveBeenCalled());
-    expect(getSpy.mock.calls[0]?.[0]).toBe("/bookings");
-  });
-});
-
-describe("extractBookingsQueryKeys", () => {
-  it("extracts the full list of query-key contributors", () => {
-    const keys = extractBookingsQueryKeys({
-      status: ["upcoming"],
-      attendeeEmail: "a@b.test",
-      take: 10,
-      skip: 0,
-    } as never);
-    expect(keys).toContain("a@b.test");
-    expect(keys).toContain(10);
-  });
-
-  it("returns undefined entries for missing input keys", () => {
-    const keys = extractBookingsQueryKeys({} as never);
-    expect(keys).toContain(undefined);
-  });
-});
-
-describe("useGetBookingForReschedule", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("is disabled when isInit is false", () => {
-    const { result } = renderHook(() => useGetBookingForReschedule({ uid: "abc" }), {
-      wrapper: wrap({ isInit: false }),
-    });
-    expect(result.current.isFetching).toBe(false);
-  });
-
-  it("fetches the reschedule booking when uid is provided", async () => {
-    const getSpy = vi.spyOn(http, "get").mockResolvedValue({
-      data: { status: "success", data: { uid: "abc" } },
-    } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useGetBookingForReschedule({ uid: "abc", onSuccess }), {
-      wrapper: wrap({ isInit: true }),
-    });
-    await waitFor(() => expect(getSpy).toHaveBeenCalled());
-    expect(getSpy.mock.calls[0]?.[0]).toContain("/bookings/abc/reschedule");
-    await waitFor(() => expect(onSuccess).toHaveBeenCalled());
-    expect(result.current.data).toBeDefined();
-  });
-
-  it("calls onError when the server returns a non-success status", async () => {
-    vi.spyOn(http, "get").mockResolvedValue({
-      data: { status: "error", error: { message: "not found" } },
-    } as never);
-    const onError = vi.fn();
-    renderHook(() => useGetBookingForReschedule({ uid: "abc", onError }), {
-      wrapper: wrap({ isInit: true }),
-    });
-    await waitFor(() => expect(onError).toHaveBeenCalled());
-  });
-});

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

@@ -1,28 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-
-import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, V2_ENDPOINTS, VERSION_2024_08_13 } from "../../constants";
-import type { GetBookingOutput_2024_08_13 } from "../../contracts";
-
-import http from "../../lib/http";
-
-export const useBooking = (uid: string) => {
-  const pathname = `/${V2_ENDPOINTS.bookings}/${uid}`;
-  const headers = {
-    [CAL_API_VERSION_HEADER]: VERSION_2024_08_13,
-  };
-
-  const bookingQuery = useQuery({
-    queryKey: ["use-booking", uid],
-    queryFn: async () => {
-      return http.get<GetBookingOutput_2024_08_13>(pathname, { headers }).then((res) => {
-        if (res.data.status === SUCCESS_STATUS) {
-          return res.data.data;
-        }
-        throw new Error(res.data?.error?.message);
-      });
-    },
-    enabled: !!uid,
-  });
-
-  return bookingQuery;
-};

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

@@ -1,61 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-
-import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, V2_ENDPOINTS, VERSION_2024_08_13 } from "../../constants";
-import type { GetBookingsInput_2024_08_13, GetBookingsOutput_2024_08_13 } from "../../contracts";
-
-import http from "../../lib/http";
-
-const QUERY_KEY = "use-bookings";
-
-export const useBookings = (input: GetBookingsInput_2024_08_13 & { enabled?: boolean }) => {
-  const pathname = `/${V2_ENDPOINTS.bookings}`;
-  const headers = {
-    [CAL_API_VERSION_HEADER]: VERSION_2024_08_13,
-  };
-
-  const { enabled = true, ...queryInput } = input;
-
-  const bookingsQuery = useQuery({
-    queryKey: [QUERY_KEY, ...extractBookingsQueryKeys(queryInput)],
-    enabled,
-    queryFn: async () => {
-      return http
-        .get<GetBookingsOutput_2024_08_13>(pathname, {
-          params: queryInput,
-          headers,
-        })
-        .then((res) => {
-          if (res.data.status === SUCCESS_STATUS) {
-            return res.data.data;
-          }
-          throw new Error(res.data?.error?.message);
-        });
-    },
-  });
-
-  return bookingsQuery;
-};
-
-export function extractBookingsQueryKeys(query: GetBookingsInput_2024_08_13) {
-  return [
-    query.status,
-    query.attendeeEmail,
-    query.attendeeName,
-    query.eventTypeIds,
-    query.eventTypeId,
-    query.teamsIds,
-    query.teamId,
-    query.afterStart,
-    query.beforeEnd,
-    query.afterCreatedAt,
-    query.beforeCreatedAt,
-    query.afterUpdatedAt,
-    query.beforeUpdatedAt,
-    query.sortStart,
-    query.sortEnd,
-    query.sortCreated,
-    query.sortUpdatedAt,
-    query.take,
-    query.skip,
-  ];
-}