ignite-parse-auth-kit 1.0.0

package/app/context/auth/services.ts

@@ -0,0 +1,394 @@
+import Parse from "@/lib/Parse";
+import type { GoogleAuthResponse, PersistedUserData } from "./types";
+import { validateEmail, validatePassword, validateUsername } from "./validation";
+
+/**
+ * Authentication services
+ * Contains all Parse-related authentication operations
+ */
+
+/**
+ * Lightweight probe to confirm the Parse backend is reachable
+ */
+export const checkParseServerConnection = async (): Promise<boolean> => {
+  try {
+    const TestObject = Parse.Object.extend("TestConnection");
+    const query = new Parse.Query(TestObject);
+    query.limit(1);
+    await query.find();
+    return true;
+  } catch (error) {
+    console.error("Parse server connection check failed:", error);
+    return false;
+  }
+};
+
+/**
+ * Logs in a user with email and password
+ */
+export const loginUser = async (
+  email: string,
+  password: string
+): Promise<{ success: boolean; error?: string; user?: Parse.User }> => {
+  try {
+    // 1) Validate inputs
+    const emailError = validateEmail(email);
+    const passwordError = validatePassword(password);
+
+    if (emailError || passwordError) {
+      const errorMessage = emailError || passwordError;
+      return { success: false, error: errorMessage };
+    }
+
+    console.log("Checking Parse server connection...");
+    const isServerRunning = await checkParseServerConnection();
+
+    if (!isServerRunning) {
+      const errorMessage =
+        "Parse server is not running. Please check your server connection.";
+      console.error("Server check failed:", errorMessage);
+      return { success: false, error: errorMessage };
+    }
+
+    // 2) Attempt Parse login
+    console.log("Parse server is running. Proceeding with login...");
+
+    const user = await Parse.User.logIn(email, password);
+    return { success: true, user };
+  } catch (error) {
+    let errorMessage = "Failed to log in";
+
+    if (error instanceof Error) {
+      if (error.message.includes("Invalid username/password")) {
+        errorMessage = "Invalid email or password. Please try again.";
+      } else if (
+        error.message.includes("XMLHttpRequest") ||
+        error.message.includes("Network Error") ||
+        error.message.includes("Failed to fetch") ||
+        error.message.includes("ECONNREFUSED")
+      ) {
+        errorMessage =
+          "Cannot connect to server. Please check if the Parse server is running.";
+      } else {
+        errorMessage = error.message;
+      }
+    }
+
+    console.error("Login error:", errorMessage);
+    return { success: false, error: errorMessage };
+  }
+};
+
+/**
+ * Signs up a new user
+ */
+export const signUpUser = async (
+  username: string,
+  email: string,
+  password: string
+): Promise<{ success: boolean; error?: string; user?: Parse.User }> => {
+  try {
+    // 1) Validate inputs
+    const emailError = validateEmail(email);
+    const passwordError = validatePassword(password);
+    const usernameError = validateUsername(username);
+
+    if (emailError || passwordError || usernameError) {
+      const errorMessage = emailError || passwordError || usernameError;
+      return { success: false, error: errorMessage };
+    }
+
+    console.log("Checking Parse server connection...");
+    const isServerRunning = await checkParseServerConnection();
+
+    if (!isServerRunning) {
+      const errorMessage =
+        "Parse server is not running. Please check your server connection.";
+      console.error("Server check failed:", errorMessage);
+      return { success: false, error: errorMessage };
+    }
+
+    // 2) Create and sign up a new Parse user
+    console.log("Parse server is running. Proceeding with signup...");
+
+    const user = new Parse.User();
+    user.set("username", username.trim());
+    user.set("email", email);
+    user.set("password", password);
+
+    const newUser = await user.signUp();
+
+    console.log("Signup successful!");
+    return { success: true, user: newUser };
+  } catch (error) {
+    let errorMessage = "Failed to sign up";
+
+    if (error instanceof Error) {
+      if (error.message.includes("username") && error.message.includes("taken")) {
+        errorMessage = "Username is already taken. Please choose another one.";
+      } else if (error.message.includes("email") && error.message.includes("taken")) {
+        errorMessage = "Email is already registered. Please use another email or try logging in.";
+      } else if (error.message.includes("Account already exists")) {
+        errorMessage = "An account with this email already exists. Please try logging in.";
+      } else if (
+        error.message.includes("XMLHttpRequest") ||
+        error.message.includes("Network Error") ||
+        error.message.includes("Failed to fetch") ||
+        error.message.includes("ECONNREFUSED")
+      ) {
+        errorMessage =
+          "Cannot connect to server. Please check if the Parse server is running.";
+      } else {
+        errorMessage = error.message;
+      }
+    }
+
+    console.error("Signup error:", errorMessage);
+    return { success: false, error: errorMessage };
+  }
+};
+
+/**
+ * Signs in a user with Google OAuth
+ */
+export const signInWithGoogle = async (
+  response: GoogleAuthResponse
+): Promise<{ success: boolean; error?: string; user?: Parse.User }> => {
+  try {
+    // 1) Validate OAuth response
+    if (response?.type !== "success") {
+      console.log("Google authentication was not successful");
+      return {
+        success: false,
+        error: "Google authentication was cancelled or failed",
+      };
+    }
+
+    if (
+      !response.authentication?.idToken ||
+      !response.authentication?.accessToken
+    ) {
+      console.error(
+        "Missing required authentication data in response",
+        response.authentication
+      );
+      return {
+        success: false,
+        error:
+          "Incomplete authentication data. Please try signing in again.",
+      };
+    }
+
+    // 2) Ensure backend is reachable
+    console.log("Checking Parse server connection...");
+    const isServerRunning = await checkParseServerConnection();
+
+    if (!isServerRunning) {
+      const errorMessage =
+        "Parse server is not running. Please check your server connection.";
+      console.error("Server check failed:", errorMessage);
+      return { success: false, error: errorMessage };
+    }
+
+    // 3) Fetch Google profile and authenticate with Parse using authData
+    console.log("Parse server is running. Proceeding with Google sign-in...");
+
+    const { idToken, accessToken } = response.authentication;
+
+    // Fetch Google user profile
+    const profileResponse = await fetch(
+      "https://www.googleapis.com/oauth2/v3/userinfo",
+      {
+        headers: { Authorization: `Bearer ${accessToken}` },
+      }
+    );
+
+    if (!profileResponse.ok) {
+      throw new Error(
+        `Failed to fetch user profile: ${profileResponse.status}`
+      );
+    }
+
+    const profile = await profileResponse.json();
+
+    const { sub: googleUserId, email, name, picture } = profile;
+
+    if (!googleUserId) {
+      throw new Error("Google ID (sub) not found in user profile");
+    }
+
+    if (!email || !name) {
+      throw new Error(
+        "Required user information missing from Google profile"
+      );
+    }
+
+    // Prepare Parse authentication data
+    const authData = {
+      id: googleUserId,
+      id_token: idToken,
+      access_token: accessToken,
+    };
+
+    // Authenticate with Parse
+    const user = await Parse.User.logInWith("google", { authData });
+
+    // Update user profile
+    user.set("username", name.trim());
+    user.set("email", email);
+
+    console.log("Google login successful:", {
+      userId: googleUserId,
+      email,
+      username: name,
+      hasPicture: Boolean(picture),
+    });
+
+    return { success: true, user };
+  } catch (error) {
+    let errorMessage = "Failed to sign in with Google";
+
+    if (error instanceof Error) {
+      if (
+        error.message.includes("XMLHttpRequest") ||
+        error.message.includes("Network Error") ||
+        error.message.includes("Failed to fetch") ||
+        error.message.includes("ECONNREFUSED")
+      ) {
+        errorMessage =
+          "Cannot connect to server. Please check if the Parse server is running.";
+      } else {
+        errorMessage = error.message;
+      }
+    }
+
+    console.error("Google sign-in error:", errorMessage);
+    return { success: false, error: errorMessage };
+  }
+};
+
+/**
+ * Requests a password reset for the given email
+ */
+export const requestPasswordReset = async (
+  email: string
+): Promise<{ success: boolean; error?: string; message?: string }> => {
+  try {
+    // 1) Validate email
+    const emailError = validateEmail(email);
+    if (emailError) {
+      return { success: false, error: emailError };
+    }
+
+    // 2) Check server connection
+    console.log("Checking Parse server connection...");
+    const isServerRunning = await checkParseServerConnection();
+
+    if (!isServerRunning) {
+      const errorMessage =
+        "Parse server is not running. Please check your server connection.";
+      console.error("Server check failed:", errorMessage);
+      return { success: false, error: errorMessage };
+    }
+
+    // 3) Request password reset
+    console.log("Parse server is running. Requesting password reset...");
+    await Parse.User.requestPasswordReset(email);
+
+    const successMessage = `Password reset email sent to ${email}. Please check your inbox and follow the instructions to reset your password.`;
+
+    console.log("Password reset request successful for:", email);
+    return { success: true, message: successMessage };
+  } catch (error) {
+    let errorMessage = "Failed to request password reset";
+
+    if (error instanceof Error) {
+      if (error.message.includes("no user found with email")) {
+        errorMessage = "No account found with this email address.";
+      } else if (error.message.includes("email adapter")) {
+        errorMessage = "Email service is not configured. Please contact support.";
+      } else if (
+        error.message.includes("XMLHttpRequest") ||
+        error.message.includes("Network Error") ||
+        error.message.includes("Failed to fetch") ||
+        error.message.includes("ECONNREFUSED")
+      ) {
+        errorMessage =
+          "Cannot connect to server. Please check if the Parse server is running.";
+      } else {
+        errorMessage = error.message;
+      }
+    }
+
+    console.error("Password reset error:", errorMessage);
+    return { success: false, error: errorMessage };
+  }
+};
+
+/**
+ * Logs out the current user
+ */
+export const logoutUser = async (): Promise<{
+  success: boolean;
+  error?: string;
+}> => {
+  try {
+    // Attempt Parse logout (may fail silently on RN; that's OK)
+    try {
+      await Parse.User.logOut();
+    } catch (logoutError) {
+      console.warn(
+        "Parse.User.logOut() failed (common in React Native):",
+        logoutError
+      );
+    }
+
+    return { success: true };
+  } catch (error) {
+    const errorMessage =
+      error instanceof Error ? error.message : "Failed to log out";
+    console.error("Logout error:", errorMessage);
+    return { success: false, error: errorMessage };
+  }
+};
+
+/**
+ * Gets the current user from Parse
+ */
+export const getCurrentUser = async (): Promise<Parse.User | null> => {
+  try {
+    return await Parse.User.currentAsync();
+  } catch (error) {
+    console.error("Error getting current user:", error);
+    return null;
+  }
+};
+
+/**
+ * Fetches all users from Parse
+ */
+export const fetchAllUsers = async (): Promise<Parse.User[]> => {
+  try {
+    const query = new Parse.Query(Parse.User);
+    const results = await query.find();
+    return results;
+  } catch (error) {
+    console.error("Error fetching users:", error);
+    return [];
+  }
+};
+
+/**
+ * Restores a user session from a persisted token
+ */
+export const restoreUserSession = async (
+  token: string
+): Promise<Parse.User | null> => {
+  try {
+    const user = await Parse.User.become(token);
+    return user;
+  } catch (error) {
+    console.error("Failed to restore user session:", error);
+    return null;
+  }
+};

package/app/context/auth/types.ts

@@ -0,0 +1,99 @@
+import Parse from "@/lib/Parse";
+import type { TokenResponse } from "expo-auth-session";
+
+/**
+ * Type definitions for authentication system
+ */
+
+// Narrow Parse user shape we rely on across the UI
+export interface IAppUser extends Parse.User {
+  getEmail(): string;
+  getUsername(): string;
+  getSessionToken(): string;
+}
+
+export interface GoogleAuthResponse {
+  type: "success" | "dismiss" | "cancel" | "opened" | "locked" | "error";
+  errorCode?: string | null;
+  error?: any;
+  params?: Record<string, string>;
+  authentication?:
+    | (TokenResponse & {
+        idToken?: string;
+        accessToken?: string;
+      })
+    | null;
+  url?: string;
+}
+
+// In-memory auth state kept in the provider
+export interface AuthState {
+  authToken?: string;
+  authEmail: string;
+  authPassword: string;
+  isLoading: boolean;
+  error: string;
+  currentUser?: Parse.User;
+  username?: string;
+  resetPasswordMessage?: string;
+}
+
+// Reducer actions
+export type AuthAction =
+  | { type: "SET_AUTH_EMAIL"; payload: string }
+  | { type: "SET_AUTH_PASSWORD"; payload: string }
+  | { type: "SET_ERROR"; payload: string }
+  | { type: "SET_AUTH_TOKEN"; payload: { token?: string } }
+  | { type: "SET_LOADING"; payload: boolean }
+  | { type: "SET_CURRENT_USER"; payload: Parse.User | undefined }
+  | { type: "SET_RESET_PASSWORD_MESSAGE"; payload: string }
+  | { type: "RESET_AUTH_STATE" }
+  | { type: "CLEAR_FORM" }
+  | { type: "CLEAR_RESET_MESSAGE" };
+
+// Public API exposed via the Auth context
+export type AuthContextType = {
+  // State
+  isAuthenticated: boolean;
+  authToken?: string;
+  authEmail: string;
+  authPassword: string;
+  isLoading: boolean;
+  error: string;
+  currentUser?: Parse.User;
+  username?: string;
+  resetPasswordMessage?: string;
+
+  // Actions
+  setAuthEmail: (email: string) => void;
+  setAuthPassword: (password: string) => void;
+  setError: (error: string) => void;
+  setAuthToken: (token?: string) => void;
+  resetAuthState: () => void;
+  clearForm: () => void;
+  clearResetMessage: () => void;
+  login: () => Promise<{ success: boolean; error?: string }>;
+  signUp: (username: string) => Promise<{ success: boolean; error?: string }>;
+  googleSignIn: (
+    response: GoogleAuthResponse
+  ) => Promise<{ success: boolean; error?: string; user?: Parse.User }>;
+  requestPasswordReset: (email: string) => Promise<{ success: boolean; error?: string; message?: string }>;
+  logout: () => Promise<{ success: boolean; error?: string }>;
+  checkCurrentUser: () => Promise<boolean>;
+  checkServerStatus: () => Promise<{ isRunning: boolean; message: string }>;
+
+  // Validation helpers
+  validateEmail: (email: string) => string | undefined;
+  validatePassword: (password: string) => string | undefined;
+  validateUsername: (username: string) => string | undefined;
+};
+
+export interface AuthProviderProps {}
+
+// Persisted user data structure
+export interface PersistedUserData {
+  objectId: string;
+  sessionToken: string;
+  username: string;
+  email: string;
+}

package/app/context/auth/validation.ts

@@ -0,0 +1,45 @@
+/**
+ * Validation utilities for authentication
+ */
+
+/**
+ * Validates an email address
+ * @param email - The email address to validate
+ * @returns Error message if invalid, undefined if valid
+ */
+export const validateEmail = (email: string): string | undefined => {
+  if (!email.length) return "Email can't be blank";
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+    return "Must be a valid email address";
+  }
+  return undefined;
+};
+
+/**
+ * Validates a password
+ * @param password - The password to validate
+ * @returns Error message if invalid, undefined if valid
+ */
+export const validatePassword = (password: string): string | undefined => {
+  if (!password.length) return "Password can't be blank";
+  if (password.length < 6) {
+    return "Password must be at least 6 characters";
+  }
+  return undefined;
+};
+
+/**
+ * Validates a username
+ * @param username - The username to validate
+ * @returns Error message if invalid, undefined if valid
+ */
+export const validateUsername = (username: string): string | undefined => {
+  if (!username.trim().length) return "Username can't be blank";
+  if (username.trim().length < 3) {
+    return "Username must be at least 3 characters";
+  }
+  if (!/^[a-zA-Z0-9_]+$/.test(username.trim())) {
+    return "Username can only contain letters, numbers, and underscores";
+  }
+  return undefined;
+};

package/app/devtools/ReactotronClient.ts

@@ -0,0 +1,9 @@
+/**
+ * This file is loaded in React Native and exports the RN version
+ * of Reactotron's client.
+ *
+ * Web is loaded from ReactotronClient.web.ts.
+ */
+import Reactotron from "reactotron-react-native"
+
+export { Reactotron }

package/app/devtools/ReactotronClient.web.ts

@@ -0,0 +1,12 @@
+/**
+ * This file is loaded in web and exports the React.js version
+ * of Reactotron's client.
+ *
+ * React Native is loaded from ReactotronClient.ts.
+ *
+ * If your project does not need web support, you can delete this file and
+ * remove reactotron-react-js from your package.json dependencies.
+ */
+import Reactotron from "reactotron-react-js"
+
+export { Reactotron }

package/app/devtools/ReactotronConfig.ts

@@ -0,0 +1,139 @@
+/**
+ * This file does the setup for integration with Reactotron, which is a
+ * free desktop app for inspecting and debugging your React Native app.
+ * @see https://github.com/infinitered/reactotron
+ */
+import { Platform, NativeModules } from "react-native"
+import { ArgType } from "reactotron-core-client"
+import { ReactotronReactNative } from "reactotron-react-native"
+import mmkvPlugin from "reactotron-react-native-mmkv"
+
+import { goBack, resetRoot, navigate } from "@/navigators/navigationUtilities"
+import { storage } from "@/utils/storage"
+
+import { Reactotron } from "./ReactotronClient"
+
+const reactotron = Reactotron.configure({
+  name: require("../../package.json").name,
+  onConnect: () => {
+    /** since this file gets hot reloaded, let's clear the past logs every time we connect */
+    Reactotron.clear()
+  },
+})
+
+reactotron.use(mmkvPlugin<ReactotronReactNative>({ storage }))
+
+if (Platform.OS !== "web") {
+  reactotron.useReactNative({
+    networking: {
+      ignoreUrls: /symbolicate/,
+    },
+  })
+}
+
+/**
+ * Reactotron allows you to define custom commands that you can run
+ * from Reactotron itself, and they will run in your app.
+ *
+ * Define them in the section below with `onCustomCommand`. Use your
+ * creativity -- this is great for development to quickly and easily
+ * get your app into the state you want.
+ *
+ * NOTE: If you edit this file while running the app, you will need to do a full refresh
+ * or else your custom commands won't be registered correctly.
+ */
+reactotron.onCustomCommand({
+  title: "Show Dev Menu",
+  description: "Opens the React Native dev menu",
+  command: "showDevMenu",
+  handler: () => {
+    Reactotron.log("Showing React Native dev menu")
+    NativeModules.DevMenu.show()
+  },
+})
+
+reactotron.onCustomCommand({
+  title: "Reset Navigation State",
+  description: "Resets the navigation state",
+  command: "resetNavigation",
+  handler: () => {
+    Reactotron.log("resetting navigation state")
+    resetRoot({ index: 0, routes: [] })
+  },
+})
+
+reactotron.onCustomCommand<[{ name: "route"; type: ArgType.String }]>({
+  command: "navigateTo",
+  handler: (args) => {
+    const { route } = args ?? {}
+    if (route) {
+      Reactotron.log(`Navigating to: ${route}`)
+      // @ts-ignore
+      navigate(route as any) // this should be tied to the navigator, but since this is for debugging, we can navigate to illegal routes
+    } else {
+      Reactotron.log("Could not navigate. No route provided.")
+    }
+  },
+  title: "Navigate To Screen",
+  description: "Navigates to a screen by name.",
+  args: [{ name: "route", type: ArgType.String }],
+})
+
+reactotron.onCustomCommand({
+  title: "Go Back",
+  description: "Goes back",
+  command: "goBack",
+  handler: () => {
+    Reactotron.log("Going back")
+    goBack()
+  },
+})
+
+/**
+ * We're going to add `console.tron` to the Reactotron object.
+ * Now, anywhere in our app in development, we can use Reactotron like so:
+ *
+ * ```
+ * if (__DEV__) {
+ *  console.tron.display({
+ *    name: 'JOKE',
+ *    preview: 'What's the best thing about Switzerland?',
+ *    value: 'I don't know, but the flag is a big plus!',
+ *    important: true
+ *  })
+ * }
+ * ```
+ *
+ * Use this power responsibly! :)
+ */
+console.tron = reactotron
+
+/**
+ * We tell typescript about our dark magic
+ *
+ * You can also import Reactotron yourself from ./reactotronClient
+ * and use it directly, like Reactotron.log('hello world')
+ */
+declare global {
+  interface Console {
+    /**
+     * Reactotron client for logging, displaying, measuring performance, and more.
+     * @see https://github.com/infinitered/reactotron
+     * @example
+     * if (__DEV__) {
+     *  console.tron.display({
+     *    name: 'JOKE',
+     *    preview: 'What's the best thing about Switzerland?',
+     *    value: 'I don't know, but the flag is a big plus!',
+     *    important: true
+     *  })
+     * }
+     */
+    tron: typeof reactotron
+  }
+}
+
+/**
+ * Now that we've setup all our Reactotron configuration, let's connect!
+ */
+reactotron.connect()