Skip to content

Rallly is an open-source scheduling and collaboration tool designed to make organizing events and meetings easier.

3.4 KB
Raw Blame
"use client";
import { posthog } from "@rallly/posthog/client";
import { useRouter } from "next/navigation";
import React from "react";
import type { UserAbility } from "@/features/user/ability";
import { defineAbilityFor } from "@/features/user/ability";
import type { UserDTO } from "@/features/user/schema";
import type { GuestSessionResult } from "@/features/user/utils";
import { toGuestSessionResult } from "@/features/user/utils";
import { authClient } from "@/lib/auth-client";
import { useLocale } from "@/lib/locale/client";
import { isOwner } from "@/lib/utils/permissions";

const UserContext = React.createContext<UserDTO | null | undefined>(undefined);

export function UserProvider({
  user,
  children,
}: {
  user: UserDTO | null;
  children: React.ReactNode;
}) {
  const userId = user?.id;
  const isGuest = user?.isGuest;
  const { locale } = useLocale();

  const name = user?.name;
  const email = user?.email;

  // The client is already identified as this user from init (initPostHog in
  // packages/posthog/src/client.ts), so no identify() here. Name and
  // email ride along so a profile PostHog has to recreate for an existing
  // account is never empty. Changing the language refreshes the router with
  // a new [locale] param, so this re-runs; posthog-js drops a repeat $set
  // with unchanged properties.
  React.useEffect(() => {
    if (userId && !isGuest) {
      posthog.setPersonProperties({ name, email, locale });
    }
  }, [userId, isGuest, name, email, locale]);

  return <UserContext.Provider value={user}>{children}</UserContext.Provider>;
}

/**
 * For components rendered on routes gated by a logged-in (non-guest) user
 * (e.g. behind loadUser). Throws instead of returning null so consumers
 * don't need to handle the unauthenticated case.
 */
export function useAuthedUser() {
  const user = React.useContext(UserContext);

  if (user === undefined) {
    throw new Error("useAuthedUser must be used within a UserProvider");
  }

  if (!user || user.isGuest) {
    throw new Error(
      "useAuthedUser was rendered on a route without a logged in user. Components that call it belong on login-gated routes.",
    );
  }

  return user;
}

export function useUser() {
  const user = React.useContext(UserContext);
  const router = useRouter();

  if (user === undefined) {
    throw new Error("useUser must be used within a UserProvider");
  }

  return React.useMemo(() => {
    return {
      user: user ?? undefined,
      createGuestIfNeeded: async (): Promise<GuestSessionResult> => {
        if (user) return { ok: true };

        let result: GuestSessionResult;
        try {
          const { error } = await authClient.signIn.anonymous();
          result = toGuestSessionResult(error);
          if (result.ok) {
            // A browser that blocks cookies drops Set-Cookie and still
            // reports success, so only reading the session back proves it.
            const { data: session } = await authClient.getSession();
            if (!session?.user) {
              result = { ok: false, reason: "sessionUnavailable" };
            }
          }
        } catch {
          result = { ok: false, reason: "sessionUnavailable" };
        }

        if (result.ok) router.refresh();
        return result;
      },
      getAbility: (): UserAbility => defineAbilityFor(user ?? undefined),
      ownsObject: (resource: { userId?: string | null }) => {
        return user ? isOwner(resource, { id: user.id }) : false;
      },
    };
  }, [user, router]);
}