@mr.dj2u/library-registry 0.2.0 → 0.3.0

package/assets/mds/src/features/auth/adapters/firebase-auth-adapter.tsx

@@ -0,0 +1,147 @@
+import { useCallback, useEffect, useMemo, useState, type ReactNode } from 'react';
+import {
+  createUserWithEmailAndPassword,
+  onAuthStateChanged,
+  sendPasswordResetEmail,
+  signInWithEmailAndPassword,
+  signOut as firebaseSignOut,
+} from 'firebase/auth';
+
+import { firebaseAuth, getFirebaseAuth } from '../../services/firebase';
+
+import type { AuthActionInput, AuthActionResult, AuthAdapter, AuthSession, AuthUser } from './auth-types';
+import type { User } from 'firebase/auth';
+
+function mapFirebaseUser(user: User): AuthUser {
+  return {
+    id: user.uid,
+    email: user.email,
+    name: user.displayName,
+    provider: 'firebase',
+    metadata: {
+      emailVerified: user.emailVerified,
+      phoneNumber: user.phoneNumber,
+      photoURL: user.photoURL,
+    },
+  };
+}
+
+function mapFirebaseSession(user: User | null): AuthSession | null {
+  if (!user) return null;
+  return {
+    user: mapFirebaseUser(user),
+  };
+}
+
+function authError(error: unknown): AuthActionResult {
+  const message = error instanceof Error ? error.message : String(error);
+  return { ok: false, error: message };
+}
+
+export function AuthAdapterProvider({ children }: { children: ReactNode }) {
+  return <>{children}</>;
+}
+
+export function useAuthAdapter(): AuthAdapter {
+  const configurationError = firebaseAuth
+    ? null
+    : 'Set the EXPO_PUBLIC_FIREBASE_* variables before using Firebase auth.';
+  const [session, setSession] = useState<AuthSession | null>(null);
+  const [isLoading, setIsLoading] = useState(() => Boolean(firebaseAuth));
+  const [error, setError] = useState<string | null>(configurationError);
+
+  useEffect(() => {
+    if (!firebaseAuth) {
+      return;
+    }
+    return onAuthStateChanged(
+      firebaseAuth,
+      (user) => {
+        setSession(mapFirebaseSession(user));
+        setError(null);
+        setIsLoading(false);
+      },
+      (nextError) => {
+        setError(nextError.message);
+        setIsLoading(false);
+      },
+    );
+  }, []);
+
+  const signInWithEmailPassword = useCallback(async ({ email, password }: AuthActionInput) => {
+    try {
+      await signInWithEmailAndPassword(getFirebaseAuth(), email.trim(), password);
+      return { ok: true } satisfies AuthActionResult;
+    } catch (error) {
+      return authError(error);
+    }
+  }, []);
+
+  const signUpWithEmailPassword = useCallback(async ({ email, password }: AuthActionInput) => {
+    try {
+      await createUserWithEmailAndPassword(getFirebaseAuth(), email.trim(), password);
+      return { ok: true } satisfies AuthActionResult;
+    } catch (error) {
+      return authError(error);
+    }
+  }, []);
+
+  const requestPasswordReset = useCallback(async (email: string) => {
+    try {
+      await sendPasswordResetEmail(getFirebaseAuth(), email.trim());
+      return { ok: true, message: 'Password reset email sent.' } satisfies AuthActionResult;
+    } catch (error) {
+      return authError(error);
+    }
+  }, []);
+
+  const signOut = useCallback(async () => {
+    try {
+      await firebaseSignOut(getFirebaseAuth());
+      return { ok: true } satisfies AuthActionResult;
+    } catch (error) {
+      return authError(error);
+    }
+  }, []);
+
+  const refreshSession = useCallback(async () => {
+    if (!firebaseAuth) {
+      setError(configurationError);
+      setSession(null);
+      setIsLoading(false);
+      return;
+    }
+    setIsLoading(true);
+    try {
+      await firebaseAuth.currentUser?.reload();
+      setSession(mapFirebaseSession(firebaseAuth.currentUser));
+      setError(null);
+    } catch (error) {
+      setError(error instanceof Error ? error.message : String(error));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [configurationError]);
+
+  return useMemo<AuthAdapter>(
+    () => ({
+      provider: 'firebase',
+      state: { isLoading, session, error },
+      refreshSession,
+      signInWithEmailPassword,
+      signUpWithEmailPassword,
+      requestPasswordReset,
+      signOut,
+    }),
+    [
+      error,
+      isLoading,
+      refreshSession,
+      requestPasswordReset,
+      session,
+      signInWithEmailPassword,
+      signOut,
+      signUpWithEmailPassword,
+    ],
+  );
+}

package/assets/mds/src/features/auth/adapters/supabase-auth-adapter.tsx

@@ -0,0 +1,166 @@
+import { useCallback, useEffect, useMemo, useState, type ReactNode } from 'react';
+
+import { getSupabaseClient, supabase } from '../../services/supabase';
+
+import type {
+  AuthActionInput,
+  AuthActionResult,
+  AuthAdapter,
+  AuthSession,
+  AuthUser,
+} from './auth-types';
+import type { Session, User } from '@supabase/supabase-js';
+
+function mapSupabaseUser(user: User): AuthUser {
+  return {
+    id: user.id,
+    email: user.email,
+    name:
+      typeof user.user_metadata?.name === 'string'
+        ? user.user_metadata.name
+        : typeof user.user_metadata?.full_name === 'string'
+          ? user.user_metadata.full_name
+          : null,
+    provider: 'supabase',
+    metadata: user.user_metadata,
+  };
+}
+
+function mapSupabaseSession(session: Session | null): AuthSession | null {
+  if (!session?.user) return null;
+  return {
+    user: mapSupabaseUser(session.user),
+    accessToken: session.access_token,
+  };
+}
+
+function authError(error: unknown): AuthActionResult {
+  const message = error instanceof Error ? error.message : String(error);
+  return { ok: false, error: message };
+}
+
+export function AuthAdapterProvider({ children }: { children: ReactNode }) {
+  return <>{children}</>;
+}
+
+export function useAuthAdapter(): AuthAdapter {
+  const configurationError = supabase
+    ? null
+    : 'Set EXPO_PUBLIC_SUPABASE_URL and EXPO_PUBLIC_SUPABASE_PUBLISHABLE_KEY before using Supabase auth. EXPO_PUBLIC_SUPABASE_KEY and EXPO_PUBLIC_SUPABASE_ANON_KEY are accepted fallbacks.';
+  const [session, setSession] = useState<AuthSession | null>(null);
+  const [isLoading, setIsLoading] = useState(() => Boolean(supabase));
+  const [error, setError] = useState<string | null>(configurationError);
+
+  useEffect(() => {
+    let mounted = true;
+    if (!supabase) {
+      return;
+    }
+
+    void supabase.auth.getSession().then(({ data, error: sessionError }) => {
+      if (!mounted) return;
+      setError(sessionError?.message ?? null);
+      setSession(mapSupabaseSession(data.session));
+      setIsLoading(false);
+    });
+
+    const {
+      data: { subscription },
+    } = supabase.auth.onAuthStateChange((_event, nextSession) => {
+      setSession(mapSupabaseSession(nextSession));
+      setError(null);
+      setIsLoading(false);
+    });
+
+    return () => {
+      mounted = false;
+      subscription.unsubscribe();
+    };
+  }, []);
+
+  const signInWithEmailPassword = useCallback(async ({ email, password }: AuthActionInput) => {
+    try {
+      const client = getSupabaseClient();
+      const { error } = await client.auth.signInWithPassword({ email, password });
+      if (error) return { ok: false, error: error.message };
+      return { ok: true } satisfies AuthActionResult;
+    } catch (error) {
+      return authError(error);
+    }
+  }, []);
+
+  const signUpWithEmailPassword = useCallback(async ({ email, password }: AuthActionInput) => {
+    try {
+      const client = getSupabaseClient();
+      const { data, error } = await client.auth.signUp({ email, password });
+      if (error) return { ok: false, error: error.message };
+      if (data.user && !data.session) {
+        return {
+          ok: true,
+          message: 'Check your email to confirm this account, then sign in.',
+        } satisfies AuthActionResult;
+      }
+      return { ok: true } satisfies AuthActionResult;
+    } catch (error) {
+      return authError(error);
+    }
+  }, []);
+
+  const requestPasswordReset = useCallback(async (email: string) => {
+    try {
+      const client = getSupabaseClient();
+      const { error } = await client.auth.resetPasswordForEmail(email.trim());
+      if (error) return { ok: false, error: error.message };
+      return { ok: true, message: 'Password reset email sent.' } satisfies AuthActionResult;
+    } catch (error) {
+      return authError(error);
+    }
+  }, []);
+
+  const signOut = useCallback(async () => {
+    try {
+      const client = getSupabaseClient();
+      const { error } = await client.auth.signOut();
+      if (error) return { ok: false, error: error.message };
+      return { ok: true } satisfies AuthActionResult;
+    } catch (error) {
+      return authError(error);
+    }
+  }, []);
+
+  const refreshSession = useCallback(async () => {
+    if (!supabase) {
+      setError(configurationError);
+      setSession(null);
+      setIsLoading(false);
+      return;
+    }
+    setIsLoading(true);
+    const { data, error: sessionError } = await supabase.auth.getSession();
+    setError(sessionError?.message ?? null);
+    setSession(mapSupabaseSession(data.session));
+    setIsLoading(false);
+  }, [configurationError]);
+
+  return useMemo<AuthAdapter>(
+    () => ({
+      provider: 'supabase',
+      state: { isLoading, session, error },
+      refreshSession,
+      signInWithEmailPassword,
+      signUpWithEmailPassword,
+      requestPasswordReset,
+      signOut,
+    }),
+    [
+      error,
+      isLoading,
+      refreshSession,
+      requestPasswordReset,
+      session,
+      signInWithEmailPassword,
+      signOut,
+      signUpWithEmailPassword,
+    ]
+  );
+}

package/assets/mds/src/features/auth/auth-guard-logic.ts

@@ -0,0 +1,19 @@
+import type { AuthAdapterState } from './auth-types';
+
+export type AuthGuardDecision = 'loading' | 'authorized' | 'fallback' | 'redirect';
+
+export function resolveAuthGuardDecision(
+  state: AuthAdapterState,
+  options: { fallback?: unknown; fallbackHref?: string }
+): AuthGuardDecision {
+  if (state.isLoading) {
+    return 'loading';
+  }
+  if (state.session?.user) {
+    return 'authorized';
+  }
+  if (options.fallback !== undefined && options.fallback !== null) {
+    return 'fallback';
+  }
+  return options.fallbackHref ? 'redirect' : 'fallback';
+}

package/assets/mds/src/features/auth/auth-guard.tsx

@@ -0,0 +1,77 @@
+import { Redirect, useFocusEffect } from 'expo-router';
+import { useCallback, useEffect, type ReactNode } from 'react';
+import { ActivityIndicator, StyleSheet, Text, View } from 'react-native';
+
+import { useAppTheme } from '../../theme/provider';
+import { resolveAuthGuardDecision, type AuthGuardDecision } from './auth-guard-logic';
+
+import type { AuthAdapter } from './auth-types';
+
+export interface AuthGuardProps {
+  auth: AuthAdapter;
+  children: ReactNode;
+  fallbackHref?: string;
+  fallback?: ReactNode;
+}
+
+export function AuthGuard({
+  auth,
+  children,
+  fallbackHref = '/sign-in',
+  fallback,
+}: AuthGuardProps) {
+  const theme = useAppTheme();
+  const colors = theme.activeColors;
+
+  const refreshAuth = useCallback(() => {
+    void auth.refreshSession();
+  }, [auth]);
+
+  useEffect(() => {
+    refreshAuth();
+  }, [refreshAuth]);
+
+  useFocusEffect(
+    useCallback(() => {
+      refreshAuth();
+    }, [refreshAuth])
+  );
+
+  const decision: AuthGuardDecision = resolveAuthGuardDecision(auth.state, {
+    fallback,
+    fallbackHref,
+  });
+
+  if (decision === 'loading') {
+    return (
+      <View style={[styles.loading, { backgroundColor: colors.background }]}>
+        <ActivityIndicator color={colors.primary} />
+        <Text style={[styles.loadingText, { color: colors.text }]}>Checking session...</Text>
+      </View>
+    );
+  }
+
+  if (decision === 'authorized') {
+    return <>{children}</>;
+  }
+
+  if (decision === 'redirect' && fallbackHref) {
+    return <Redirect href={fallbackHref} />;
+  }
+
+  return <>{fallback ?? null}</>;
+}
+
+const styles = StyleSheet.create({
+  loading: {
+    alignItems: 'center',
+    flex: 1,
+    gap: 12,
+    justifyContent: 'center',
+    padding: 24,
+  },
+  loadingText: {
+    fontSize: 14,
+    fontWeight: '700',
+  },
+});

package/assets/mds/src/features/auth/auth-provider.tsx

@@ -0,0 +1,60 @@
+import { createContext, useContext, useMemo, type ReactNode } from 'react';
+
+import { AuthAdapterProvider, useAuthAdapter } from './auth-adapter';
+
+import type { AuthActionInput, AuthActionResult, AuthProviderId, AuthUser } from './auth-types';
+
+export type AuthStatus = 'loading' | 'authenticated' | 'anonymous';
+
+export interface AuthContextValue {
+  provider: AuthProviderId;
+  status: AuthStatus;
+  isLoading: boolean;
+  isAuthenticated: boolean;
+  user: AuthUser | null;
+  error?: string | null;
+  signIn(input: AuthActionInput): Promise<AuthActionResult>;
+  signUp(input: AuthActionInput): Promise<AuthActionResult>;
+  requestPasswordReset(email: string): Promise<AuthActionResult>;
+  signOut(): Promise<AuthActionResult>;
+}
+
+const AuthContext = createContext<AuthContextValue | null>(null);
+
+function AuthStateProvider({ children }: { children: ReactNode }) {
+  const adapter = useAuthAdapter();
+  const { state } = adapter;
+  const value = useMemo<AuthContextValue>(() => {
+    const isAuthenticated = Boolean(state.session?.user);
+    return {
+      provider: adapter.provider,
+      status: state.isLoading ? 'loading' : isAuthenticated ? 'authenticated' : 'anonymous',
+      isLoading: state.isLoading,
+      isAuthenticated,
+      user: state.session?.user ?? null,
+      error: state.error,
+      signIn: adapter.signInWithEmailPassword,
+      signUp: adapter.signUpWithEmailPassword,
+      requestPasswordReset: adapter.requestPasswordReset,
+      signOut: adapter.signOut,
+    };
+  }, [adapter, state]);
+
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+}
+
+export function AuthProvider({ children }: { children: ReactNode }) {
+  return (
+    <AuthAdapterProvider>
+      <AuthStateProvider>{children}</AuthStateProvider>
+    </AuthAdapterProvider>
+  );
+}
+
+export function useAuth(): AuthContextValue {
+  const value = useContext(AuthContext);
+  if (!value) {
+    throw new Error('useAuth must be used inside AuthProvider.');
+  }
+  return value;
+}