@calcom/atoms 2.8.0 → 2.8.2

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

@@ -1,168 +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 { AtomsContext } from "../../use-atoms-context";
-import { useAtomCreateSchedule } from "../use-atom-create-schedule";
-import { useAtomGetAllSchedules } from "../use-atom-get-all-schedules";
-import { useAtomSchedule } from "../use-atom-schedule";
-import { useAtomUpdateSchedule } from "../use-atom-update-schedule";
-import useDeleteSchedule from "../use-delete-schedule";
-import { useSchedule } from "../use-schedule";
-import { useSchedules } from "../use-schedules";
-
-function wrap(contextValue: Record<string, unknown> = { isInit: true, accessToken: "tok" }) {
-  const client = new QueryClient({
-    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
-  });
-  return ({ children }: { children: ReactNode }) => (
-    <QueryClientProvider client={client}>
-      <AtomsContext.Provider value={contextValue as never}>{children}</AtomsContext.Provider>
-    </QueryClientProvider>
-  );
-}
-
-describe("useAtomGetAllSchedules", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("is disabled when not initialised", () => {
-    const { result } = renderHook(() => useAtomGetAllSchedules(), {
-      wrapper: wrap({ isInit: false, accessToken: "" }),
-    });
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.data).toBeUndefined();
-  });
-
-  it("fetches the schedule list when initialised", async () => {
-    const getSpy = vi.spyOn(http, "get").mockResolvedValue({
-      data: { status: "success", data: { schedules: [] } },
-    } as never);
-    renderHook(() => useAtomGetAllSchedules(), { wrapper: wrap() });
-    await waitFor(() => expect(getSpy).toHaveBeenCalled());
-    expect(getSpy.mock.calls[0]?.[0]).toContain("atoms/schedules/all");
-  });
-});
-
-describe("useAtomSchedule", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("fetches a specific schedule by id", async () => {
-    const getSpy = vi.spyOn(http, "get").mockResolvedValue({
-      data: { status: "success", data: { id: 5 } },
-    } as never);
-    renderHook(() => useAtomSchedule("5"), { wrapper: wrap() });
-    await waitFor(() => expect(getSpy).toHaveBeenCalled());
-    expect(getSpy.mock.calls[0]?.[1]?.params).toEqual(expect.objectContaining({ scheduleId: "5" }));
-  });
-});
-
-describe("useSchedule", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("uses /default when no id is passed", async () => {
-    const getSpy = vi.spyOn(http, "get").mockResolvedValue({
-      data: { status: "success", data: {} },
-    } as never);
-    renderHook(() => useSchedule(), { wrapper: wrap() });
-    await waitFor(() => expect(getSpy).toHaveBeenCalled());
-    expect(getSpy.mock.calls[0]?.[0]).toContain("/default");
-  });
-
-  it("uses the provided id in the URL", async () => {
-    const getSpy = vi.spyOn(http, "get").mockResolvedValue({
-      data: { status: "success", data: {} },
-    } as never);
-    renderHook(() => useSchedule(42), { wrapper: wrap() });
-    await waitFor(() => expect(getSpy).toHaveBeenCalled());
-    expect(getSpy.mock.calls[0]?.[0]).toContain("42");
-  });
-});
-
-describe("useSchedules", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("fetches the v2 schedule list", async () => {
-    const getSpy = vi.spyOn(http, "get").mockResolvedValue({
-      data: { status: "success", data: [] },
-    } as never);
-    renderHook(() => useSchedules(), { wrapper: wrap() });
-    await waitFor(() => expect(getSpy).toHaveBeenCalled());
-  });
-});
-
-describe("useAtomCreateSchedule", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("invokes onSuccess on a success response", async () => {
-    vi.spyOn(http, "post").mockResolvedValue({
-      data: { status: "success", data: { schedule: { id: 1 } } },
-    } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useAtomCreateSchedule({ onSuccess }), { wrapper: wrap() });
-    act(() => {
-      result.current.mutate({ name: "new" } as never);
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalled());
-  });
-
-  it("invokes 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(() => useAtomCreateSchedule({ onError }), { wrapper: wrap() });
-    act(() => {
-      result.current.mutate({ name: "new" } as never);
-    });
-    await waitFor(() => expect(onError).toHaveBeenCalled());
-  });
-
-  it("has working no-arg invocation", () => {
-    const { result } = renderHook(() => useAtomCreateSchedule(), { wrapper: wrap() });
-    expect(typeof result.current.mutate).toBe("function");
-  });
-});
-
-describe("useAtomUpdateSchedule", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("returns a mutate function for the schedule PATCH endpoint", () => {
-    const { result } = renderHook(() => useAtomUpdateSchedule(), { wrapper: wrap() });
-    expect(typeof result.current.mutate).toBe("function");
-  });
-});
-
-describe("useDeleteSchedule", () => {
-  afterEach(() => vi.restoreAllMocks());
-
-  it("invokes onSuccess on a delete success", async () => {
-    vi.spyOn(http, "delete").mockResolvedValue({
-      data: { status: "success" },
-    } as never);
-    const onSuccess = vi.fn();
-    const { result } = renderHook(() => useDeleteSchedule({ onSuccess }), { wrapper: wrap() });
-    act(() => {
-      result.current.mutate({ id: 1 } as never);
-    });
-    await waitFor(() => expect(onSuccess).toHaveBeenCalled());
-  });
-
-  it("invokes onError on a failure response", async () => {
-    vi.spyOn(http, "delete").mockResolvedValue({
-      data: { status: "error", error: { message: "bad" } },
-    } as never);
-    const onError = vi.fn();
-    const { result } = renderHook(() => useDeleteSchedule({ onError }), { wrapper: wrap() });
-    act(() => {
-      result.current.mutate({ id: 1 } as never);
-    });
-    await waitFor(() => expect(onError).toHaveBeenCalled());
-  });
-
-  it("has working no-arg invocation", () => {
-    const { result } = renderHook(() => useDeleteSchedule(), { wrapper: wrap() });
-    expect(typeof result.current.mutate).toBe("function");
-  });
-});

package/src/hooks/schedules/types.ts

@@ -1,36 +0,0 @@
-type Schedule = {
-  id: number;
-  userId: number;
-  name: string;
-  timeZone: string | null;
-};
-
-export type CreateScheduleHandlerReturn = {
-  schedule: Schedule;
-};
-
-export type DuplicateScheduleHandlerReturn = {
-  schedule: Schedule;
-};
-
-export type GetAvailabilityListHandlerReturn = {
-  schedules: (Omit<Schedule, "userId"> & {
-    availability: {
-      id: number;
-      userId: number | null;
-      eventTypeId: number | null;
-      days: number[];
-      startTime: Date;
-      endTime: Date;
-      date: Date | null;
-      scheduleId: number | null;
-    }[];
-    isDefault: boolean;
-  })[];
-};
-
-export type CreateScheduleInput = {
-  name: string;
-  schedule?: { start: Date; end: Date }[][];
-  eventTypeId?: number;
-};

package/src/hooks/schedules/use-atom-create-schedule.ts

@@ -1,47 +0,0 @@
-import { useMutation, useQueryClient } from "@tanstack/react-query";
-
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiErrorResponse, ApiResponse, ApiSuccessResponse } from "../../contracts";
-
-import http from "../../lib/http";
-import type { CreateScheduleHandlerReturn, CreateScheduleInput as CreateScheduleSchema } from "./types";
-import { QUERY_KEY as SchedulesQueryKey } from "./use-atom-get-all-schedules";
-import { QUERY_KEY as ScheduleQueryKey } from "./use-atom-schedule";
-
-interface useAtomCreateScheduleOptions {
-  onSuccess?: (res: ApiSuccessResponse<CreateScheduleHandlerReturn>) => void;
-  onError?: (err: ApiErrorResponse) => void;
-}
-
-export const useAtomCreateSchedule = (
-  { onSuccess, onError }: useAtomCreateScheduleOptions = {
-    onSuccess: () => {
-      return;
-    },
-    onError: () => {
-      return;
-    },
-  }
-) => {
-  const queryClient = useQueryClient();
-
-  return useMutation<ApiResponse<CreateScheduleHandlerReturn>, unknown, CreateScheduleSchema>({
-    mutationFn: async (body: CreateScheduleSchema) => {
-      const url = `atoms/schedules/create`;
-      const response = await http.post<ApiResponse<CreateScheduleHandlerReturn>>(url, body);
-      return response.data;
-    },
-    onSuccess: (data) => {
-      if (data.status === SUCCESS_STATUS) {
-        onSuccess?.(data);
-        queryClient.invalidateQueries({ queryKey: [ScheduleQueryKey] });
-        queryClient.invalidateQueries({ queryKey: [SchedulesQueryKey] });
-      } else {
-        onError?.(data);
-      }
-    },
-    onError: (err) => {
-      onError?.(err as ApiErrorResponse);
-    },
-  });
-};

package/src/hooks/schedules/use-atom-duplicate-schedule.ts

@@ -1,45 +0,0 @@
-import { useMutation, useQueryClient } from "@tanstack/react-query";
-
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiErrorResponse, ApiResponse } from "../../contracts";
-
-import http from "../../lib/http";
-import type { DuplicateScheduleHandlerReturn } from "./types";
-import { QUERY_KEY as ScheduleQueryKey } from "./use-atom-schedule";
-
-interface useAtomDuplicateScheduleOptions {
-  onSuccess?: (res: ApiResponse<DuplicateScheduleHandlerReturn>) => void;
-  onError?: (err: ApiErrorResponse) => void;
-}
-
-export const useAtomDuplicateSchedule = (
-  { onSuccess, onError }: useAtomDuplicateScheduleOptions = {
-    onSuccess: () => {
-      return;
-    },
-    onError: () => {
-      return;
-    },
-  }
-) => {
-  const queryClient = useQueryClient();
-
-  return useMutation<ApiResponse<DuplicateScheduleHandlerReturn>, unknown, { scheduleId: number }>({
-    mutationFn: async ({ scheduleId }: { scheduleId: number }) => {
-      const url = `atoms/schedules/${scheduleId}/duplicate`;
-      const response = await http.post<ApiResponse<DuplicateScheduleHandlerReturn>>(url);
-      return response.data;
-    },
-    onSuccess: (data) => {
-      if (data.status === SUCCESS_STATUS) {
-        onSuccess?.(data);
-        queryClient.invalidateQueries({ queryKey: [ScheduleQueryKey] });
-      } else {
-        onError?.(data);
-      }
-    },
-    onError: (err) => {
-      onError?.(err as ApiErrorResponse);
-    },
-  });
-};

package/src/hooks/schedules/use-atom-get-all-schedules.ts

@@ -1,30 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiResponse } from "../../contracts";
-
-import http from "../../lib/http";
-import { useAtomsContext } from "../use-atoms-context";
-import type { GetAvailabilityListHandlerReturn } from "./types";
-
-export const QUERY_KEY = "use-atom-user-schedules";
-
-export const useAtomGetAllSchedules = () => {
-  const pathname = "atoms/schedules/all";
-  const { isInit, accessToken } = useAtomsContext();
-
-  const { isLoading, error, data, refetch } = useQuery({
-    queryKey: [QUERY_KEY],
-    queryFn: () => {
-      return http.get<ApiResponse<GetAvailabilityListHandlerReturn>>(pathname).then((res) => {
-        if (res.data.status === SUCCESS_STATUS) {
-          return res.data.data;
-        }
-        throw new Error(res.data.error?.message);
-      });
-    },
-    enabled: isInit && !!accessToken,
-  });
-
-  return { isLoading, error, data, refetch };
-};

package/src/hooks/schedules/use-atom-schedule.ts

@@ -1,33 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiResponse, AtomScheduleDetailed } from "../../contracts";
-
-import http from "../../lib/http";
-import { useAtomsContext } from "../use-atoms-context";
-
-export const QUERY_KEY = "use-atom-schedule";
-
-export const useAtomSchedule = (scheduleId?: string, isManagedEventType?: boolean) => {
-  const pathname = "atoms/schedules";
-  const { isInit, accessToken } = useAtomsContext();
-
-  const { isLoading, error, data } = useQuery({
-    queryKey: [QUERY_KEY, scheduleId, isManagedEventType],
-    queryFn: () => {
-      return http
-        .get<ApiResponse<AtomScheduleDetailed | null>>(pathname, {
-          params: { scheduleId, isManagedEventType },
-        })
-        .then((res) => {
-          if (res.data.status === SUCCESS_STATUS) {
-            return res.data.data;
-          }
-          throw new Error(res.data.error?.message);
-        });
-    },
-    enabled: isInit && !!accessToken,
-  });
-
-  return { isLoading, error, data };
-};

package/src/hooks/schedules/use-atom-update-schedule.ts

@@ -1,54 +0,0 @@
-// @ts-nocheck — atoms wrapper/hook over loose contracts + Radix 1.x
-import { useMutation, useQueryClient } from "@tanstack/react-query";
-
-import { SUCCESS_STATUS } from "../../constants";
-import type {
-  ApiErrorResponse,
-  ApiResponse,
-  AtomAtomUpdateScheduleResponse,
-  UpdateAtomScheduleDto,
-} from "../../contracts";
-
-import http from "../../lib/http";
-import { QUERY_KEY as ScheduleQueryKey } from "./use-atom-schedule";
-
-interface IUseAtomUpdateScheduleOptions {
-  onSuccess?: (res: ApiResponse<AtomUpdateScheduleResponse>) => void;
-  onError?: (err: ApiErrorResponse) => void;
-}
-
-export const useAtomUpdateSchedule = (
-  { onSuccess, onError }: IUseAtomUpdateScheduleOptions = {
-    onSuccess: () => {
-      return;
-    },
-    onError: () => {
-      return;
-    },
-  }
-) => {
-  const queryClient = useQueryClient();
-
-  return useMutation<
-    ApiResponse<AtomUpdateScheduleResponse>,
-    unknown,
-    { scheduleId: number; body: UpdateAtomScheduleDto }
-  >({
-    mutationFn: async ({ scheduleId, body }: { scheduleId: number; body: UpdateAtomScheduleDto }) => {
-      const url = `atoms/schedules/${scheduleId}`;
-      const response = await http.patch<ApiResponse<AtomUpdateScheduleResponse>>(url, body);
-      return response.data;
-    },
-    onSuccess: (data) => {
-      if (data.status === SUCCESS_STATUS) {
-        onSuccess?.(data);
-        queryClient.invalidateQueries({ queryKey: [ScheduleQueryKey] });
-      } else {
-        onError?.(data);
-      }
-    },
-    onError: (err) => {
-      onError?.(err as ApiErrorResponse);
-    },
-  });
-};

package/src/hooks/schedules/use-delete-schedule.ts

@@ -1,54 +0,0 @@
-import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { SUCCESS_STATUS, V2_ENDPOINTS } from "../../constants";
-import type { ApiErrorResponse, ApiResponse } from "../../contracts";
-
-import http from "../../lib/http";
-import { QUERY_KEY } from "./use-atom-schedule";
-
-interface IUseDeleteScheduleProps {
-  onSuccess?: (res: ApiResponse) => void;
-  onError?: (err: ApiErrorResponse) => void;
-}
-
-type DeleteScheduleInput = {
-  id: number;
-};
-
-const useDeleteSchedule = (
-  { onSuccess, onError }: IUseDeleteScheduleProps = {
-    onSuccess: () => {
-      return;
-    },
-    onError: () => {
-      return;
-    },
-  }
-) => {
-  const queryClient = useQueryClient();
-
-  const mutation = useMutation<ApiResponse<undefined>, unknown, DeleteScheduleInput>({
-    mutationFn: (data) => {
-      const { id } = data;
-      const pathname = `/${V2_ENDPOINTS.availability}/${id}`;
-
-      return http?.delete(pathname).then((res) => res.data);
-    },
-    onSuccess: (data) => {
-      if (data.status === SUCCESS_STATUS) {
-        onSuccess?.(data);
-      } else {
-        onError?.(data);
-      }
-    },
-    onError: (err) => {
-      onError?.(err as ApiErrorResponse);
-    },
-    onSettled: () => {
-      queryClient.invalidateQueries({ queryKey: [QUERY_KEY] });
-    },
-  });
-
-  return mutation;
-};
-
-export default useDeleteSchedule;

package/src/hooks/schedules/use-ensure-default-schedule.ts

@@ -1,23 +0,0 @@
-// @ts-nocheck — atoms wrapper over loose contracts + Radix prop-pick
-
-import { useEffect, useRef } from "react";
-import type { Schedule } from "../../vendor/schedule-list-item";
-
-export function useEnsureDefaultSchedule(
-  schedules: Schedule[],
-  onUpdateSchedule: (scheduleId: number) => void | Promise<void>
-): void {
-  const onUpdateRef = useRef(onUpdateSchedule);
-
-  useEffect(() => {
-    onUpdateRef.current = onUpdateSchedule;
-  });
-
-  useEffect(() => {
-    const defaultSchedule = schedules.filter((schedule) => schedule.isDefault);
-
-    if (defaultSchedule.length === 0 && schedules.length > 0) {
-      onUpdateRef.current(schedules[0].id);
-    }
-  }, [schedules]);
-}

package/src/hooks/schedules/use-schedule.ts

@@ -1,34 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-
-import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, V2_ENDPOINTS, VERSION_2024_06_11 } from "../../constants";
-import type { GetScheduleOutput_2024_06_11 } from "../../contracts";
-
-import http from "../../lib/http";
-import { useAtomsContext } from "../use-atoms-context";
-
-export const QUERY_KEY = "user-schedule";
-
-export const useSchedule = (id?: number | string) => {
-  const { isInit } = useAtomsContext();
-
-  const pathname = id ? `/${V2_ENDPOINTS.availability}/${id}` : `/${V2_ENDPOINTS.availability}/default`;
-
-  const { isLoading, error, data } = useQuery({
-    queryKey: [QUERY_KEY, `${id}`],
-    queryFn: () => {
-      return http
-        .get<GetScheduleOutput_2024_06_11>(pathname, {
-          headers: { [CAL_API_VERSION_HEADER]: VERSION_2024_06_11 },
-        })
-        .then((res) => {
-          if (res.data.status === SUCCESS_STATUS) {
-            return res.data.data;
-          }
-          throw new Error(res.data.error?.message);
-        });
-    },
-    enabled: isInit,
-  });
-
-  return { isLoading, error, data };
-};

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

@@ -1,34 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-
-import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, V2_ENDPOINTS, VERSION_2024_06_11 } from "../../constants";
-import type { GetSchedulesOutput_2024_06_11 } from "../../contracts";
-
-import http from "../../lib/http";
-import { useAtomsContext } from "../use-atoms-context";
-
-export const QUERY_KEY = "user-schedules";
-
-export const useSchedules = () => {
-  const { isInit } = useAtomsContext();
-
-  const pathname = `/${V2_ENDPOINTS.availability}`;
-
-  const { isLoading, error, data } = useQuery({
-    queryKey: [QUERY_KEY],
-    queryFn: () => {
-      return http
-        .get<GetSchedulesOutput_2024_06_11>(pathname, {
-          headers: { [CAL_API_VERSION_HEADER]: VERSION_2024_06_11 },
-        })
-        .then((res) => {
-          if (res.data.status === SUCCESS_STATUS) {
-            return res.data.data;
-          }
-          throw new Error(res.data.error?.message);
-        });
-    },
-    enabled: isInit,
-  });
-
-  return { isLoading, error, data };
-};

package/src/hooks/schedules/use-update-schedule.ts

@@ -1,58 +0,0 @@
-import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { SUCCESS_STATUS, V2_ENDPOINTS } from "../../constants";
-import type {
-  ApiErrorResponse,
-  ApiResponse,
-  ScheduleOutput_2024_06_11,
-  UpdateScheduleInput_2024_06_11,
-} from "../../contracts";
-
-import http from "../../lib/http";
-import { QUERY_KEY as ScheduleQueryKey } from "./use-schedule";
-
-interface IPUpdateOAuthClient {
-  onSuccess?: (res: ApiResponse<ScheduleOutput_2024_06_11>) => void;
-  onError?: (err: ApiErrorResponse) => void;
-}
-
-const useUpdateSchedule = (
-  { onSuccess, onError }: IPUpdateOAuthClient = {
-    onSuccess: () => {
-      return;
-    },
-    onError: () => {
-      return;
-    },
-  }
-) => {
-  const queryClient = useQueryClient();
-
-  const mutation = useMutation<
-    ApiResponse<ScheduleOutput_2024_06_11>,
-    unknown,
-    UpdateScheduleInput_2024_06_11 & { id: number }
-  >({
-    mutationFn: (data) => {
-      const pathname = `/${V2_ENDPOINTS.availability}/${data.id}`;
-
-      return http.patch<ApiResponse<ScheduleOutput_2024_06_11>>(pathname, data).then((res) => {
-        return res.data;
-      });
-    },
-    onSuccess: (data) => {
-      if (data.status === SUCCESS_STATUS) {
-        onSuccess?.(data);
-        queryClient.invalidateQueries({ queryKey: [ScheduleQueryKey] });
-      } else {
-        onError?.(data);
-      }
-    },
-    onError: (err) => {
-      onError?.(err as ApiErrorResponse);
-    },
-  });
-
-  return mutation;
-};
-
-export default useUpdateSchedule;