Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

7.3 KB
Raw Blame
import Constants from "expo-constants";
import * as Linking from "expo-linking";
import * as SecureStore from "expo-secure-store";
import * as WebBrowser from "expo-web-browser";
import {
	createContext,
	type ReactNode,
	useCallback,
	useContext,
	useEffect,
	useMemo,
	useRef,
	useState,
} from "react";
import {
	createMobileApiClient,
	createSessionRequestUrl,
	type MobileApiClient,
	type MobileAuthConfigResponse,
	type MobileBootstrapResponse,
} from "@/api/mobile";
import { requireAuthRedirectSession } from "./session";

WebBrowser.maybeCompleteAuthSession();

const sessionKey = "cap.mobile.apiKey";
const userIdKey = "cap.mobile.userId";
const secureStoreOptions: SecureStore.SecureStoreOptions = {
	keychainAccessible: SecureStore.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
};

type AuthState = {
	status: "loading" | "signedOut" | "signedIn";
	apiKey: string | null;
	userId: string | null;
	authConfig: MobileAuthConfigResponse;
	bootstrap: MobileBootstrapResponse | null;
	client: MobileApiClient;
	requestEmailCode: (email: string) => Promise<void>;
	verifyEmailCode: (email: string, code: string) => Promise<void>;
	signInWithApple: () => Promise<void>;
	signInWithGoogle: () => Promise<void>;
	signInWithSso: (organizationId: string) => Promise<void>;
	signOut: () => Promise<void>;
	refresh: () => Promise<void>;
	setActiveOrganization: (organizationId: string) => Promise<void>;
};

const AuthContext = createContext<AuthState | null>(null);
const fallbackAuthConfig: MobileAuthConfigResponse = {
	appleAuthAvailable: false,
	googleAuthAvailable: true,
	workosAuthAvailable: true,
};

const getExtraString = (key: string, fallback: string) => {
	const extra = Constants.expoConfig?.extra;
	if (!extra || typeof extra !== "object") return fallback;
	const value = (extra as Record<string, unknown>)[key];
	return typeof value === "string" ? value : fallback;
};

export const apiBaseUrl = getExtraString("apiBaseUrl", "https://cap.so");

export function AuthProvider({ children }: { children: ReactNode }) {
	const [apiKey, setApiKey] = useState<string | null>(null);
	const [userId, setUserId] = useState<string | null>(null);
	const [authConfig, setAuthConfig] =
		useState<MobileAuthConfigResponse>(fallbackAuthConfig);
	const [bootstrap, setBootstrap] = useState<MobileBootstrapResponse | null>(
		null,
	);
	const [loading, setLoading] = useState(true);
	const sessionRevision = useRef(0);

	const client = useMemo(
		() =>
			createMobileApiClient({
				baseUrl: apiBaseUrl,
				getToken: () => apiKey,
			}),
		[apiKey],
	);
	const publicClient = useMemo(
		() =>
			createMobileApiClient({
				baseUrl: apiBaseUrl,
				getToken: () => null,
			}),
		[],
	);

	const refresh = useCallback(async () => {
		const revision = sessionRevision.current;
		const response = await client.bootstrap();
		if (revision === sessionRevision.current) setBootstrap(response);
	}, [client]);

	useEffect(() => {
		let active = true;
		const load = async () => {
			try {
				const [storedKey, storedUserId, nextAuthConfig] = await Promise.all([
					SecureStore.getItemAsync(sessionKey),
					SecureStore.getItemAsync(userIdKey),
					publicClient.getAuthConfig().catch(() => fallbackAuthConfig),
				]);
				if (!active) return;
				setApiKey(storedKey);
				setUserId(storedKey ? storedUserId : null);
				setAuthConfig(nextAuthConfig);
				if (!storedKey && storedUserId) {
					SecureStore.deleteItemAsync(userIdKey).catch(() => {});
				}
			} finally {
				if (active) setLoading(false);
			}
		};
		load();
		return () => {
			active = false;
		};
	}, [publicClient]);

	useEffect(() => {
		if (!apiKey) {
			setUserId(null);
			setBootstrap(null);
			return;
		}

		const revision = sessionRevision.current;
		refresh().catch(() => {
			if (revision !== sessionRevision.current) return;
			sessionRevision.current += 1;
			setApiKey(null);
			setUserId(null);
			setBootstrap(null);
			SecureStore.deleteItemAsync(sessionKey).catch(() => {});
			SecureStore.deleteItemAsync(userIdKey).catch(() => {});
		});
	}, [apiKey, refresh]);

	const storeSession = useCallback(
		async (session: { apiKey: string; userId: string | null }) => {
			sessionRevision.current += 1;
			await SecureStore.setItemAsync(
				sessionKey,
				session.apiKey,
				secureStoreOptions,
			);
			if (session.userId) {
				await SecureStore.setItemAsync(
					userIdKey,
					session.userId,
					secureStoreOptions,
				);
			} else {
				await SecureStore.deleteItemAsync(userIdKey);
			}
			setApiKey(session.apiKey);
			setUserId(session.userId);
		},
		[],
	);

	const requestEmailCode = useCallback(
		async (email: string) => {
			await client.requestEmailCode(email);
		},
		[client],
	);

	const verifyEmailCode = useCallback(
		async (email: string, code: string) => {
			const session = await client.verifyEmailCode({ email, code });
			await storeSession({
				apiKey: session.apiKey,
				userId: session.userId,
			});
		},
		[client, storeSession],
	);

	const signInWithProvider = useCallback(
		async (provider: "apple" | "google") => {
			const redirectUri = Linking.createURL("auth");
			const result = await WebBrowser.openAuthSessionAsync(
				createSessionRequestUrl(apiBaseUrl, redirectUri, provider),
				redirectUri,
			);
			if (result.type !== "success") return;

			await storeSession(requireAuthRedirectSession(result.url));
		},
		[storeSession],
	);

	const signInWithApple = useCallback(
		() => signInWithProvider("apple"),
		[signInWithProvider],
	);

	const signInWithGoogle = useCallback(
		() => signInWithProvider("google"),
		[signInWithProvider],
	);

	const signInWithSso = useCallback(
		async (organizationId: string) => {
			const redirectUri = Linking.createURL("auth");
			const result = await WebBrowser.openAuthSessionAsync(
				createSessionRequestUrl(
					apiBaseUrl,
					redirectUri,
					"workos",
					organizationId,
				),
				redirectUri,
			);
			if (result.type !== "success") return;

			await storeSession(requireAuthRedirectSession(result.url));
		},
		[storeSession],
	);

	const signOut = useCallback(async () => {
		sessionRevision.current += 1;
		if (apiKey) {
			await client.revokeSession().catch(() => {});
		}
		await Promise.all([
			SecureStore.deleteItemAsync(sessionKey),
			SecureStore.deleteItemAsync(userIdKey),
		]);
		sessionRevision.current += 1;
		setApiKey(null);
		setUserId(null);
		setBootstrap(null);
	}, [apiKey, client]);

	const setActiveOrganization = useCallback(
		async (organizationId: string) => {
			const revision = sessionRevision.current;
			const nextBootstrap = await client.setActiveOrganization(organizationId);
			if (revision === sessionRevision.current) setBootstrap(nextBootstrap);
		},
		[client],
	);

	const value = useMemo<AuthState>(
		() => ({
			status: loading ? "loading" : apiKey ? "signedIn" : "signedOut",
			apiKey,
			userId,
			authConfig,
			bootstrap,
			client,
			requestEmailCode,
			verifyEmailCode,
			signInWithApple,
			signInWithGoogle,
			signInWithSso,
			signOut,
			refresh,
			setActiveOrganization,
		}),
		[
			loading,
			apiKey,
			userId,
			authConfig,
			bootstrap,
			client,
			requestEmailCode,
			verifyEmailCode,
			signInWithApple,
			signInWithGoogle,
			signInWithSso,
			signOut,
			refresh,
			setActiveOrganization,
		],
	);

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

export const useAuth = () => {
	const value = useContext(AuthContext);
	if (!value) throw new Error("useAuth must be used inside AuthProvider");
	return value;
};