@calcom/atoms 2.8.0 → 2.8.2

package/src/event-types/hooks/__tests__/use-team-event-assignment.test.tsx

@@ -1,218 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { FormProvider, useForm } from "react-hook-form";
-import { describe, expect, it, vi } from "vitest";
-import { SchedulingType } from "../../../contracts";
-import { useTeamEventAssignment } from "../use-team-event-assignment";
-
-vi.mock("../../../hooks/use-atoms-locale", () => ({
-  useAtomsLocale: () => ({ t: (key: string) => key }),
-}));
-
-function makeWrapper(defaultValues: Record<string, unknown> = {}) {
-  return ({ children }: { children: ReactNode }) => {
-    const form = useForm({
-      defaultValues: {
-        slug: "30min",
-        assignAllTeamMembers: false,
-        children: [],
-        ...defaultValues,
-      },
-    });
-    return <FormProvider {...form}>{children}</FormProvider>;
-  };
-}
-
-const baseMember = {
-  id: 1,
-  email: "one@example.com",
-  username: "one",
-  avatar: "",
-  eventTypes: ["30min"],
-};
-
-describe("useTeamEventAssignment", () => {
-  it("flags managed event types", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min", schedulingType: SchedulingType.MANAGED },
-          teamMembers: [],
-        }),
-      { wrapper }
-    );
-    expect(result.current.isManagedEventType).toBe(true);
-  });
-
-  it("returns false for non-managed scheduling types", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min", schedulingType: SchedulingType.ROUND_ROBIN },
-          teamMembers: [],
-        }),
-      { wrapper }
-    );
-    expect(result.current.isManagedEventType).toBe(false);
-  });
-
-  it("reads eventTypeSlug from the form, falling back to eventType.slug", () => {
-    const wrapper = makeWrapper({ slug: "60min" });
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min" },
-          teamMembers: [],
-        }),
-      { wrapper }
-    );
-    expect(result.current.eventTypeSlug).toBe("60min");
-  });
-
-  it("filters team members missing username when there is no parent team", () => {
-    const wrapper = makeWrapper();
-    const members = [baseMember, { ...baseMember, id: 2, username: null, email: "two@example.com" }];
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min" },
-          teamMembers: members,
-        }),
-      { wrapper }
-    );
-    expect(result.current.teamMembersOptions).toHaveLength(1);
-  });
-
-  it("keeps all members when the event type has a parent team", () => {
-    const wrapper = makeWrapper();
-    const members = [baseMember, { ...baseMember, id: 2, username: null, email: "two@example.com" }];
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min", team: { parentId: 10 } },
-          teamMembers: members,
-        }),
-      { wrapper }
-    );
-    expect(result.current.teamMembersOptions).toHaveLength(2);
-  });
-
-  it("reflects the current assignAllTeamMembers value", () => {
-    const wrapper = makeWrapper({ assignAllTeamMembers: true });
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min" },
-          teamMembers: [],
-        }),
-      { wrapper }
-    );
-    expect(result.current.assignAllTeamMembers).toBe(true);
-  });
-
-  it("resetAssignAll flips assignAllTeamMembers back to false", () => {
-    const wrapper = makeWrapper({ assignAllTeamMembers: true });
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min" },
-          teamMembers: [],
-        }),
-      { wrapper }
-    );
-    act(() => {
-      result.current.resetAssignAll();
-    });
-    expect(result.current.assignAllTeamMembers).toBe(false);
-  });
-
-  it("attemptSetAssignAll toggles immediately for non-managed events", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min", schedulingType: SchedulingType.ROUND_ROBIN },
-          teamMembers: [],
-        }),
-      { wrapper }
-    );
-    act(() => {
-      result.current.attemptSetAssignAll(true);
-    });
-    expect(result.current.assignAllTeamMembers).toBe(true);
-    expect(result.current.warningDialog.isOpen).toBe(false);
-  });
-
-  it("attemptSetAssignAll surfaces a warning dialog on managed events before toggling", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min", schedulingType: SchedulingType.MANAGED },
-          teamMembers: [],
-        }),
-      { wrapper }
-    );
-    act(() => {
-      result.current.attemptSetAssignAll(true);
-    });
-    expect(result.current.warningDialog.isOpen).toBe(true);
-    expect(result.current.assignAllTeamMembers).toBe(false);
-  });
-
-  it("confirming the warning dialog applies the toggle", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min", schedulingType: SchedulingType.MANAGED },
-          teamMembers: [],
-        }),
-      { wrapper }
-    );
-    act(() => {
-      result.current.attemptSetAssignAll(true);
-    });
-    act(() => {
-      result.current.warningDialog.onConfirm();
-    });
-    expect(result.current.assignAllTeamMembers).toBe(true);
-    expect(result.current.warningDialog.isOpen).toBe(false);
-  });
-
-  it("closing the warning dialog cancels the toggle", () => {
-    const wrapper = makeWrapper();
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min", schedulingType: SchedulingType.MANAGED },
-          teamMembers: [],
-        }),
-      { wrapper }
-    );
-    act(() => {
-      result.current.attemptSetAssignAll(true);
-    });
-    act(() => {
-      result.current.warningDialog.onClose();
-    });
-    expect(result.current.warningDialog.isOpen).toBe(false);
-    expect(result.current.assignAllTeamMembers).toBe(false);
-  });
-
-  it("childrenEventTypeOptions returns an option per matching team member", () => {
-    const wrapper = makeWrapper();
-    const members = [baseMember, { ...baseMember, id: 2, email: "two@example.com", username: "two" }];
-    const { result } = renderHook(
-      () =>
-        useTeamEventAssignment({
-          eventType: { slug: "30min" },
-          teamMembers: members,
-        }),
-      { wrapper }
-    );
-    expect(result.current.childrenEventTypeOptions).toHaveLength(2);
-  });
-});

package/src/event-types/hooks/use-add-verified-email.ts

@@ -1,64 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiErrorResponse, ApiResponse } from "../../contracts";
-
-import { useAtomsContext } from "../../hooks/use-atoms-context";
-import { appendClientIdToEmail } from "../../lib/append-client-id-to-email";
-import http from "../../lib/http";
-
-interface IUseAddVerifiedEmail {
-  onSuccess?: (res: ApiResponse) => void;
-  onError?: (err: ApiErrorResponse | Error) => void;
-}
-
-export const useAddVerifiedEmail = (
-  { onSuccess, onError }: IUseAddVerifiedEmail = {
-    onSuccess: () => {
-      return;
-    },
-    onError: () => {
-      return;
-    },
-  }
-) => {
-  const { clientId } = useAtomsContext();
-
-  const verifiedEmailEntry = useMutation<
-    ApiResponse<{
-      status: string;
-      data: {
-        emailVerified: boolean;
-      };
-    }>,
-    unknown,
-    {
-      email: string;
-    }
-  >({
-    mutationFn: (data) => {
-      const { email } = data;
-      const emailToSend = appendClientIdToEmail(email, clientId);
-
-      return http
-        .post(`/atoms/emails/verified-emails`, {
-          email: emailToSend,
-        })
-        .then((res) => {
-          return res.data;
-        });
-    },
-    onSuccess: (data) => {
-      if (data.status === SUCCESS_STATUS) {
-        onSuccess?.(data);
-      } else {
-        onError?.(data);
-      }
-    },
-    onError: (err) => {
-      onError?.(err as ApiErrorResponse);
-    },
-  });
-
-  return verifiedEmailEntry;
-};

package/src/event-types/hooks/use-apps-data-stub.ts

@@ -1,19 +0,0 @@
-/**
- * atoms-local adapter (out of UI canonicalization — hook, not UI). Replaces @calcom/web/modules/apps/hooks/useAppsData.
- *
- * The webapp's useAppsData wires per-app form metadata into the
- * EventType form via context. atoms doesn't render app-store addons,
- * so this returns no-op getters/setters and an empty metadata object.
- * Callers that need real per-app settings should drive them through
- * the booking/event-type API directly.
- */
-export default function useAppsData() {
-  return {
-    getAppDataGetter: (_key: string) => (_field: string) => undefined as unknown,
-    getAppDataSetter:
-      (_key: string, _categories: string[], _credentialId?: number) => (_field: string, _value: unknown) => {
-        /* no-op */
-      },
-    eventTypeFormMetadata: {},
-  };
-}

package/src/event-types/hooks/use-assign-all-managed-warning.ts

@@ -1,45 +0,0 @@
-import { useCallback, useRef, useState } from "react";
-
-import { SchedulingType } from "../../contracts";
-
-/**
- * Manages the "Assign all team members" warning dialog for managed
- * event types. Mirrors the webapp hook — atoms needs the same UX
- * flow when isPlatform callers render the team-assignment tab.
- */
-export function useAssignAllManagedWarning() {
-  const [isOpen, setIsOpen] = useState(false);
-  const hasConfirmedEarlierRef = useRef(false);
-
-  const shouldShowWarning = useCallback(
-    ({
-      schedulingType,
-      oldAssignAllTeamMembers,
-      newAssignAllTeamMembers,
-    }: {
-      schedulingType: string | null;
-      oldAssignAllTeamMembers: boolean;
-      newAssignAllTeamMembers: boolean;
-    }) => {
-      const hasConfirmedEarlier = hasConfirmedEarlierRef.current;
-      return (
-        newAssignAllTeamMembers &&
-        !oldAssignAllTeamMembers &&
-        schedulingType === SchedulingType.MANAGED &&
-        !hasConfirmedEarlier
-      );
-    },
-    []
-  );
-
-  const show = useCallback(() => setIsOpen(true), []);
-
-  const confirm = useCallback(() => {
-    hasConfirmedEarlierRef.current = true;
-    setIsOpen(false);
-  }, []);
-
-  const cancel = useCallback(() => setIsOpen(false), []);
-
-  return { isOpen, shouldShowWarning, show, confirm, cancel };
-}

package/src/event-types/hooks/use-atom-event-type-app-integration.ts

@@ -1,49 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-
-import { SUCCESS_STATUS } from "../../constants";
-import type {
-  ApiResponse,
-  AtomApp as App,
-  AtomCredentialDataWithTeamName as CredentialDataWithTeamName,
-  AtomLocationOption as LocationOption,
-} from "../../contracts";
-
-import { useAtomsContext } from "../../hooks/use-atoms-context";
-import http from "../../lib/http";
-
-type UserTeams =
-  | []
-  | {
-      teamId: number;
-      name: string;
-      logoUrl: string | null;
-      credentialId: number;
-      isAdmin: boolean;
-    }[];
-
-type EnabledAppType = App & {
-  credential: CredentialDataWithTeamName;
-  credentials: CredentialDataWithTeamName[];
-  userCredentialIds: number[];
-  locationOption: LocationOption | null;
-  teams: UserTeams;
-};
-
-export const QUERY_KEY = "use-event-app-integration";
-export const useAtomsEventTypeById = (appSlug: string | null, teamId: number | null) => {
-  const pathname = `/atoms/event-types-app/${appSlug}${teamId ? `?teamId=${teamId}` : ""}`;
-  const { isInit, accessToken } = useAtomsContext();
-
-  return useQuery({
-    queryKey: [QUERY_KEY, appSlug],
-    queryFn: () => {
-      return http?.get<ApiResponse<{ app: EnabledAppType }>>(pathname).then((res) => {
-        if (res.data.status === SUCCESS_STATUS) {
-          return res.data.data;
-        }
-        throw new Error(res.data.error.message);
-      });
-    },
-    enabled: !!appSlug && isInit && !!accessToken,
-  });
-};

package/src/event-types/hooks/use-atom-event-type-by-id.ts

@@ -1,25 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-import { SUCCESS_STATUS, V2_ENDPOINTS } from "../../constants";
-import type { ApiResponse, ApiSuccessResponse, EventTypeSetupProps } from "../../contracts";
-
-import { useAtomsContext } from "../../hooks/use-atoms-context";
-import http from "../../lib/http";
-
-export const QUERY_KEY = "use-event-by-id";
-export const useAtomsEventTypeById = (id: number | null) => {
-  const pathname = `/atoms/${V2_ENDPOINTS.eventTypes}/${id}`;
-  const { isInit, accessToken } = useAtomsContext();
-
-  return useQuery({
-    queryKey: [QUERY_KEY, id],
-    queryFn: () => {
-      return http?.get<ApiResponse<EventTypeSetupProps>>(pathname).then((res) => {
-        if (res.data.status === SUCCESS_STATUS) {
-          return (res.data as ApiSuccessResponse<EventTypeSetupProps>).data;
-        }
-        throw new Error(res.data.error.message);
-      });
-    },
-    enabled: !!id && isInit && !!accessToken,
-  });
-};

package/src/event-types/hooks/use-atom-event-type-payment-info.ts

@@ -1,36 +0,0 @@
-// @ts-nocheck — atoms wrapper over loose contracts + Radix prop-pick
-import { useQuery } from "@tanstack/react-query";
-import { SUCCESS_STATUS } from "../../constants";
-import type { ApiResponse } from "../../contracts";
-import { useAtomsContext } from "../../hooks/use-atoms-context";
-import http from "../../lib/http";
-import type { PaymentPageProps } from "./payment-page-types";
-
-export const QUERY_KEY = "use-event-app-integration";
-export const useAtomsEventTypePaymentInfo = ({
-  uid,
-  onEventTypePaymentInfoSuccess,
-  onEventTypePaymentInfoFailure,
-}: {
-  uid: string;
-  onEventTypePaymentInfoSuccess?: () => void;
-  onEventTypePaymentInfoFailure?: () => void;
-}) => {
-  const pathname = `/atoms/payment/${uid}`;
-  const { isInit, accessToken } = useAtomsContext();
-
-  return useQuery({
-    queryKey: [QUERY_KEY, uid],
-    queryFn: () => {
-      return http?.get<ApiResponse<PaymentPageProps>>(pathname).then((res) => {
-        if (res.data.status === SUCCESS_STATUS) {
-          onEventTypePaymentInfoSuccess?.();
-          return res.data.data;
-        }
-        onEventTypePaymentInfoFailure?.();
-        throw new Error(res.data.error.message);
-      });
-    },
-    enabled: !!uid && isInit && !!accessToken,
-  });
-};

package/src/event-types/hooks/use-atom-get-all-event-types.ts

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

package/src/event-types/hooks/use-atom-host-schedules.ts

@@ -1,36 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-
-import { SUCCESS_STATUS } from "../../constants";
-import type { GetSchedulesOutput_2024_06_11 } from "../../contracts";
-
-import { useAtomsContext } from "../../hooks/use-atoms-context";
-import http from "../../lib/http";
-
-export const QUERY_KEY = "use-atom-host-schedule-by-id";
-
-export const useAtomHostSchedules = ({ userId, teamId }: { userId: number; teamId?: number }) => {
-  const { organizationId, userId: meId } = useAtomsContext();
-
-  const event = useQuery({
-    queryKey: [QUERY_KEY, organizationId, userId],
-    queryFn: async () => {
-      const pathname = `/organizations/${organizationId}/teams/${teamId}/users/${userId}/schedules`;
-      return http?.get<GetSchedulesOutput_2024_06_11>(pathname).then((res) => {
-        if (res.data.status === SUCCESS_STATUS) {
-          const schedules = res.data.data.map((schedule) => ({
-            id: schedule.id,
-            name: schedule.name,
-            isDefault: schedule.isDefault,
-            userId: schedule.ownerId,
-            readOnly: meId !== userId,
-          }));
-          return { schedules };
-        }
-        throw new Error(res.data?.error?.message ?? "Error while getting host schedules");
-      });
-    },
-    enabled: !!organizationId && !!teamId && !!userId,
-  });
-
-  return event;
-};

package/src/event-types/hooks/use-atom-update-event-type.ts

@@ -1,61 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import type { AxiosError } from "axios";
-import { SUCCESS_STATUS, V2_ENDPOINTS } from "../../constants";
-import type {
-  ApiErrorResponse,
-  ApiResponse,
-  ApiSuccessResponse,
-  EventType,
-  EventTypeUpdateInput,
-} from "../../contracts";
-
-import { useAtomsContext } from "../../hooks/use-atoms-context";
-import http from "../../lib/http";
-
-export const QUERY_KEY = "use-event-by-id";
-export type UseAtomUpdateEventTypeProps = {
-  onSuccess?: () => void;
-  onError?: (err: Error) => void;
-  onSettled?: () => void;
-  teamId?: number;
-};
-export const useAtomUpdateEventType = ({
-  onSuccess = () => {
-    return;
-  },
-  onError = () => {
-    return;
-  },
-  onSettled = () => {
-    return;
-  },
-  teamId,
-}: UseAtomUpdateEventTypeProps) => {
-  const { organizationId } = useAtomsContext();
-  return useMutation({
-    onSuccess,
-    onError,
-    onSettled,
-    mutationFn: async (data: EventTypeUpdateInput) => {
-      if (!data.id) throw new Error("Event type id is required");
-      let pathname = `/atoms/${V2_ENDPOINTS.eventTypes}/${data.id}`;
-
-      if (teamId) {
-        pathname = `/atoms/organizations/${organizationId}/teams/${teamId}/${V2_ENDPOINTS.eventTypes}/${data.id}`;
-      }
-      try {
-        const res = await http?.patch<ApiResponse<EventType>>(pathname, data);
-        if (res?.data.status === SUCCESS_STATUS) {
-          return (res.data as ApiSuccessResponse<EventType>).data;
-        }
-        throw new Error(res?.data.error.message);
-      } catch (err) {
-        const axiosError = err as AxiosError<ApiErrorResponse>;
-        if (axiosError.response?.data?.error?.message) {
-          throw new Error(axiosError.response.data.error.message);
-        }
-        throw err;
-      }
-    },
-  });
-};