ignite-parse-auth-kit 1.0.0

package/app/context/EpisodeContext.tsx

@@ -0,0 +1,136 @@
+import {
+  createContext,
+  FC,
+  PropsWithChildren,
+  useCallback,
+  useContext,
+  useMemo,
+  useState,
+} from "react"
+
+import { translate } from "@/i18n/translate"
+import { api } from "@/services/api"
+import type { EpisodeItem } from "@/services/api/types"
+import { formatDate } from "@/utils/formatDate"
+
+export type EpisodeContextType = {
+  totalEpisodes: number
+  totalFavorites: number
+  episodesForList: EpisodeItem[]
+  fetchEpisodes: () => Promise<void>
+  favoritesOnly: boolean
+  toggleFavoritesOnly: () => void
+  hasFavorite: (episode: EpisodeItem) => boolean
+  toggleFavorite: (episode: EpisodeItem) => void
+}
+
+export const EpisodeContext = createContext<EpisodeContextType | null>(null)
+
+export interface EpisodeProviderProps {}
+
+export const EpisodeProvider: FC<PropsWithChildren<EpisodeProviderProps>> = ({ children }) => {
+  const [episodes, setEpisodes] = useState<EpisodeItem[]>([])
+  const [favorites, setFavorites] = useState<string[]>([])
+  const [favoritesOnly, setFavoritesOnly] = useState<boolean>(false)
+
+  const fetchEpisodes = useCallback(async () => {
+    const response = await api.getEpisodes()
+    if (response.kind === "ok") {
+      setEpisodes(response.episodes)
+    } else {
+      console.error(`Error fetching episodes: ${JSON.stringify(response)}`)
+    }
+  }, [])
+
+  const toggleFavoritesOnly = useCallback(() => {
+    setFavoritesOnly((prev) => !prev)
+  }, [])
+
+  const toggleFavorite = useCallback(
+    (episode: EpisodeItem) => {
+      if (favorites.some((fav) => fav === episode.guid)) {
+        setFavorites((prev) => prev.filter((fav) => fav !== episode.guid))
+      } else {
+        setFavorites((prev) => [...prev, episode.guid])
+      }
+    },
+    [favorites],
+  )
+
+  const hasFavorite = useCallback(
+    (episode: EpisodeItem) => favorites.some((fav) => fav === episode.guid),
+    [favorites],
+  )
+
+  const episodesForList = useMemo(() => {
+    return favoritesOnly ? episodes.filter((episode) => favorites.includes(episode.guid)) : episodes
+  }, [episodes, favorites, favoritesOnly])
+
+  const value = {
+    totalEpisodes: episodes.length,
+    totalFavorites: favorites.length,
+    episodesForList,
+    fetchEpisodes,
+    favoritesOnly,
+    toggleFavoritesOnly,
+    hasFavorite,
+    toggleFavorite,
+  }
+
+  return <EpisodeContext.Provider value={value}>{children}</EpisodeContext.Provider>
+}
+
+export const useEpisodes = () => {
+  const context = useContext(EpisodeContext)
+  if (!context) throw new Error("useEpisodes must be used within an EpisodeProvider")
+  return context
+}
+
+// A helper hook to extract and format episode details
+export const useEpisode = (episode: EpisodeItem) => {
+  const { hasFavorite } = useEpisodes()
+
+  const isFavorite = hasFavorite(episode)
+
+  let datePublished
+  try {
+    const formatted = formatDate(episode.pubDate)
+    datePublished = {
+      textLabel: formatted,
+      accessibilityLabel: translate("demoPodcastListScreen:accessibility.publishLabel", {
+        date: formatted,
+      }),
+    }
+  } catch {
+    datePublished = { textLabel: "", accessibilityLabel: "" }
+  }
+
+  const seconds = Number(episode.enclosure?.duration ?? 0)
+  const h = Math.floor(seconds / 3600)
+  const m = Math.floor((seconds % 3600) / 60)
+  const s = Math.floor((seconds % 3600) % 60)
+  const duration = {
+    textLabel: `${h > 0 ? `${h}:` : ""}${m > 0 ? `${m}:` : ""}${s}`,
+    accessibilityLabel: translate("demoPodcastListScreen:accessibility.durationLabel", {
+      hours: h,
+      minutes: m,
+      seconds: s,
+    }),
+  }
+
+  const trimmedTitle = episode.title?.trim()
+  const titleMatches = trimmedTitle?.match(/^(RNR.*\d)(?: - )(.*$)/)
+  const parsedTitleAndSubtitle =
+    titleMatches && titleMatches.length === 3
+      ? { title: titleMatches[1], subtitle: titleMatches[2] }
+      : { title: trimmedTitle, subtitle: "" }
+
+  return {
+    isFavorite,
+    datePublished,
+    duration,
+    parsedTitleAndSubtitle,
+  }
+}
+
+// @demo remove-file

package/app/context/auth/AuthProvider.tsx

@@ -0,0 +1,340 @@
+import React, {
+  createContext,
+  FC,
+  PropsWithChildren,
+  useCallback,
+  useEffect,
+  useReducer,
+} from "react";
+import { useMMKVString, useMMKVObject } from "react-native-mmkv";
+import Parse from "@/lib/Parse";
+import type {
+  AuthContextType,
+  AuthProviderProps,
+  PersistedUserData,
+  GoogleAuthResponse,
+} from "./types";
+import { authReducer, initialAuthState } from "./reducer";
+import {
+  loginUser,
+  signUpUser,
+  signInWithGoogle,
+  requestPasswordReset as requestPasswordResetService,
+  logoutUser,
+  getCurrentUser,
+  restoreUserSession,
+  checkParseServerConnection,
+} from "./services";
+import { validateEmail, validatePassword, validateUsername } from "./validation";
+
+/**
+ * AuthContext
+ * - Centralizes authentication state and actions for the app using Parse.
+ * - Persists a minimal user snapshot and session token in MMKV for fast restore.
+ * - Exposes typed helpers for login, signup, Google OAuth, logout, password reset, and status checks.
+ */
+
+export const AuthContext = createContext<AuthContextType | null>(null);
+
+export const AuthProvider: FC<PropsWithChildren<AuthProviderProps>> = ({
+  children,
+}) => {
+  const [state, dispatch] = useReducer(authReducer, initialAuthState);
+
+  // Persisted storage (fast restore across app restarts)
+  const [persistedAuthToken, setPersistedAuthToken] = useMMKVString(
+    "AuthProvider.authToken"
+  );
+  const [persistedUserData, setPersistedUserData] = useMMKVObject<PersistedUserData>(
+    "AuthProvider.userData"
+  );
+
+  // On boot: try to restore a valid session from persisted data
+  useEffect(() => {
+    const initializeAuth = async () => {
+      if (persistedAuthToken && persistedUserData) {
+        try {
+          // 1) Prefer the current user already held by Parse if the token matches
+          const currentUser = await Parse.User.currentAsync();
+          if (currentUser && currentUser.getSessionToken() === persistedAuthToken) {
+            dispatch({ type: "SET_CURRENT_USER", payload: currentUser });
+            return;
+          }
+        } catch (error) {
+          console.warn("Could not get current user from Parse:", error);
+        }
+
+        // 2) Fallback: try to restore session from token using Parse API
+        try {
+          const user = await restoreUserSession(persistedAuthToken);
+          if (user) {
+            dispatch({
+              type: "SET_AUTH_TOKEN",
+              payload: { token: persistedAuthToken },
+            });
+            dispatch({ type: "SET_CURRENT_USER", payload: user });
+          } else {
+            // Clear invalid persisted data to avoid loops
+            setPersistedAuthToken(undefined);
+            setPersistedUserData(undefined);
+          }
+        } catch (error) {
+          console.error("Failed to restore user session:", error);
+          // Clear invalid persisted data to avoid loops
+          setPersistedAuthToken(undefined);
+          setPersistedUserData(undefined);
+        }
+      }
+    };
+
+    initializeAuth();
+  }, [persistedAuthToken, persistedUserData, setPersistedAuthToken, setPersistedUserData]);
+
+  // Lightweight action wrappers
+  const setAuthEmail = useCallback((email: string) => {
+    dispatch({ type: "SET_AUTH_EMAIL", payload: email });
+  }, []);
+
+  const setAuthPassword = useCallback((password: string) => {
+    dispatch({ type: "SET_AUTH_PASSWORD", payload: password });
+  }, []);
+
+  const setError = useCallback((error: string) => {
+    dispatch({ type: "SET_ERROR", payload: error });
+  }, []);
+
+  const setAuthToken = useCallback(
+    (token?: string) => {
+      dispatch({ type: "SET_AUTH_TOKEN", payload: { token } });
+      setPersistedAuthToken(token);
+    },
+    [setPersistedAuthToken]
+  );
+
+  const clearResetMessage = useCallback(() => {
+    dispatch({ type: "CLEAR_RESET_MESSAGE" });
+  }, []);
+
+  // Single place to persist both token and a minimal user snapshot
+  const persistUserData = useCallback(
+    (user: Parse.User) => {
+      const userData: PersistedUserData = {
+        objectId: user.id,
+        sessionToken: user.getSessionToken(),
+        username: user.getUsername() || "",
+        email: user.getEmail() || "",
+      };
+      setPersistedAuthToken(user.getSessionToken());
+      setPersistedUserData(userData as any);
+    },
+    [setPersistedAuthToken, setPersistedUserData]
+  );
+
+  const resetAuthState = useCallback(() => {
+    dispatch({ type: "RESET_AUTH_STATE" });
+  }, []);
+
+  const clearForm = useCallback(() => {
+    dispatch({ type: "CLEAR_FORM" });
+  }, []);
+
+  const login = useCallback(async (): Promise<{
+    success: boolean;
+    error?: string;
+  }> => {
+    dispatch({ type: "SET_LOADING", payload: true });
+    dispatch({ type: "SET_ERROR", payload: "" });
+
+    try {
+      const result = await loginUser(state.authEmail, state.authPassword);
+
+      if (result.success && result.user) {
+        dispatch({ type: "SET_CURRENT_USER", payload: result.user });
+        persistUserData(result.user);
+        dispatch({ type: "CLEAR_FORM" }); // clear form fields only
+      } else if (result.error) {
+        dispatch({ type: "SET_ERROR", payload: result.error });
+      }
+
+      return result;
+    } finally {
+      dispatch({ type: "SET_LOADING", payload: false });
+    }
+  }, [state.authEmail, state.authPassword, persistUserData]);
+
+  const signUp = useCallback(
+    async (username: string): Promise<{ success: boolean; error?: string }> => {
+      dispatch({ type: "SET_LOADING", payload: true });
+      dispatch({ type: "SET_ERROR", payload: "" });
+
+      try {
+        const result = await signUpUser(username, state.authEmail, state.authPassword);
+
+        if (result.success && result.user) {
+          dispatch({ type: "SET_CURRENT_USER", payload: result.user });
+          persistUserData(result.user);
+          dispatch({ type: "CLEAR_FORM" }); // clear form fields only
+        } else if (result.error) {
+          dispatch({ type: "SET_ERROR", payload: result.error });
+        }
+
+        return result;
+      } finally {
+        dispatch({ type: "SET_LOADING", payload: false });
+      }
+    },
+    [state.authEmail, state.authPassword, persistUserData]
+  );
+
+  const googleSignIn = useCallback(
+    async (
+      response: GoogleAuthResponse
+    ): Promise<{ success: boolean; error?: string; user?: Parse.User }> => {
+      dispatch({ type: "SET_LOADING", payload: true });
+      dispatch({ type: "SET_ERROR", payload: "" });
+
+      try {
+        const result = await signInWithGoogle(response);
+
+        if (result.success && result.user) {
+          dispatch({ type: "SET_CURRENT_USER", payload: result.user });
+          persistUserData(result.user);
+          dispatch({ type: "CLEAR_FORM" });
+        } else if (result.error) {
+          dispatch({ type: "SET_ERROR", payload: result.error });
+        }
+
+        return result;
+      } finally {
+        dispatch({ type: "SET_LOADING", payload: false });
+      }
+    },
+    [persistUserData]
+  );
+
+  const requestPasswordResetAction = useCallback(
+    async (email: string): Promise<{ success: boolean; error?: string; message?: string }> => {
+      dispatch({ type: "SET_LOADING", payload: true });
+      dispatch({ type: "SET_ERROR", payload: "" });
+      dispatch({ type: "CLEAR_RESET_MESSAGE" });
+
+      try {
+        const result = await requestPasswordResetService(email);
+
+        if (result.success && result.message) {
+          dispatch({ type: "SET_RESET_PASSWORD_MESSAGE", payload: result.message });
+        } else if (result.error) {
+          dispatch({ type: "SET_ERROR", payload: result.error });
+        }
+
+        return result;
+      } finally {
+        dispatch({ type: "SET_LOADING", payload: false });
+      }
+    },
+    []
+  );
+
+  const logout = useCallback(async (): Promise<{
+    success: boolean;
+    error?: string;
+  }> => {
+    try {
+      // Clear persisted data first
+      setPersistedAuthToken(undefined);
+      setPersistedUserData(undefined);
+
+      // Reset all in-memory auth state
+      dispatch({ type: "RESET_AUTH_STATE" });
+
+      // Then attempt Parse logout
+      const result = await logoutUser();
+
+      if (result.error) {
+        dispatch({ type: "SET_ERROR", payload: result.error });
+      }
+
+      return result;
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : "Failed to log out";
+      console.error("Logout error:", errorMessage);
+      dispatch({ type: "SET_ERROR", payload: errorMessage });
+      return { success: false, error: errorMessage };
+    }
+  }, [setPersistedAuthToken, setPersistedUserData]);
+
+  const checkCurrentUser = useCallback(async (): Promise<boolean> => {
+    try {
+      const currentUser = await getCurrentUser();
+      if (currentUser) {
+        dispatch({ type: "SET_CURRENT_USER", payload: currentUser });
+        persistUserData(currentUser);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : "Unknown error";
+      console.error("Error checking current user:", errorMessage);
+      return false;
+    }
+  }, [persistUserData]);
+
+  const checkServerStatus = useCallback(async (): Promise<{
+    isRunning: boolean;
+    message: string;
+  }> => {
+    try {
+      const isRunning = await checkParseServerConnection();
+      return {
+        isRunning,
+        message: isRunning ? "Server is running" : "Server is not accessible",
+      };
+    } catch (error) {
+      return { isRunning: false, message: "Failed to check server status" };
+    }
+  }, []);
+
+  // On mount: re-sync the current user from Parse if available
+  useEffect(() => {
+    checkCurrentUser();
+  }, [checkCurrentUser]);
+
+  // Memo-like object literal passed to consumers
+  const value: AuthContextType = {
+    // State
+    isAuthenticated: !!state.currentUser || !!state.authToken,
+    authToken: state.authToken,
+    authEmail: state.authEmail,
+    authPassword: state.authPassword,
+    isLoading: state.isLoading,
+    error: state.error,
+    currentUser: state.currentUser,
+    username: state.username,
+    resetPasswordMessage: state.resetPasswordMessage,
+
+    // Actions
+    setAuthEmail,
+    setAuthPassword,
+    setError,
+    setAuthToken,
+    resetAuthState,
+    clearForm,
+    clearResetMessage,
+    login,
+    signUp,
+    googleSignIn,
+    requestPasswordReset: requestPasswordResetAction,
+    logout,
+    checkCurrentUser,
+    checkServerStatus,
+
+    // Validation helpers
+    validateEmail,
+    validatePassword,
+    validateUsername,
+  };
+
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+};

package/app/context/auth/hooks.ts

@@ -0,0 +1,29 @@
+import { useContext } from "react";
+import { AuthContext } from "./AuthProvider";
+import { getCurrentUser as getUser, fetchAllUsers } from "./services";
+
+/**
+ * Custom hooks for authentication
+ */
+
+/**
+ * Hook to access auth context
+ * Must be used within an AuthProvider
+ */
+export const useAuth = () => {
+  const context = useContext(AuthContext);
+  if (!context) throw new Error("useAuth must be used within an AuthProvider");
+  return context;
+};
+
+/**
+ * Convenience helper to get current user
+ * Can be used outside of React components
+ */
+export const getCurrentUser = getUser;
+
+/**
+ * Convenience helper to fetch all users
+ * Can be used outside of React components
+ */
+export const fetchAllUsersHelper = fetchAllUsers;

package/app/context/auth/index.ts

@@ -0,0 +1,38 @@
+/**
+ * Auth module exports
+ * Central export point for all authentication functionality
+ */
+
+// Types
+export type {
+  IAppUser,
+  GoogleAuthResponse,
+  AuthState,
+  AuthAction,
+  AuthContextType,
+  AuthProviderProps,
+  PersistedUserData,
+} from "./types";
+
+// Provider and Context
+export { AuthProvider, AuthContext } from "./AuthProvider";
+
+// Hooks
+export { useAuth, getCurrentUser, fetchAllUsersHelper as fetchAllUsers } from "./hooks";
+
+// Validation utilities
+export { validateEmail, validatePassword, validateUsername } from "./validation";
+
+// Services (for advanced usage)
+export {
+  checkParseServerConnection,
+  loginUser,
+  signUpUser,
+  signInWithGoogle,
+  requestPasswordReset,
+  logoutUser,
+  restoreUserSession,
+} from "./services";
+
+// Reducer (for advanced usage)
+export { authReducer, initialAuthState } from "./reducer";

package/app/context/auth/reducer.ts

@@ -0,0 +1,68 @@
+import type { AuthState, AuthAction } from "./types";
+
+/**
+ * Auth reducer
+ * Handles all auth state transitions in one place
+ */
+
+// Initial value for the reducer
+export const initialAuthState: AuthState = {
+  authEmail: "",
+  authPassword: "",
+  isLoading: false,
+  error: "",
+  currentUser: undefined,
+  username: undefined,
+  resetPasswordMessage: undefined,
+};
+
+export const authReducer = (state: AuthState, action: AuthAction): AuthState => {
+  switch (action.type) {
+    case "SET_AUTH_EMAIL":
+      return { ...state, authEmail: action.payload.replace(/\s+/g, "") };
+    case "SET_AUTH_PASSWORD":
+      return { ...state, authPassword: action.payload };
+    case "SET_ERROR":
+      return { ...state, error: action.payload };
+    case "SET_AUTH_TOKEN":
+      return { ...state, authToken: action.payload.token };
+    case "SET_LOADING":
+      return { ...state, isLoading: action.payload };
+    case "SET_CURRENT_USER":
+      return {
+        ...state,
+        currentUser: action.payload,
+        authToken: action.payload?.getSessionToken(),
+        username: action.payload?.getUsername(),
+      };
+    case "SET_RESET_PASSWORD_MESSAGE":
+      return { ...state, resetPasswordMessage: action.payload };
+    case "CLEAR_RESET_MESSAGE":
+      return { ...state, resetPasswordMessage: undefined };
+    case "RESET_AUTH_STATE":
+      // Full reset (used for logout)
+      return {
+        ...state,
+        authEmail: "",
+        authPassword: "",
+        error: "",
+        isLoading: false,
+        currentUser: undefined,
+        authToken: undefined,
+        username: undefined,
+        resetPasswordMessage: undefined,
+      };
+    case "CLEAR_FORM":
+      // Clear only form fields; keep the authenticated user
+      return {
+        ...state,
+        authEmail: "",
+        authPassword: "",
+        error: "",
+        isLoading: false,
+        resetPasswordMessage: undefined,
+      };
+    default:
+      return state;
+  }
+};