From b4ef3a04bb40d3c764ec9b7f520264881f1be2bd Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Thu, 1 Oct 2026 19:42:03 -0700
Subject: [PATCH 01/18] feat(Authentication): added a new folders that contain
 token save, get, delete logic

---
 src/features/auth/secureStore.ts | 33 ++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 src/features/auth/secureStore.ts

diff --git a/src/features/auth/secureStore.ts b/src/features/auth/secureStore.ts
new file mode 100644
index 0000000..575d90e
--- /dev/null
+++ b/src/features/auth/secureStore.ts
@@ -0,0 +1,33 @@
+import * as SecureStore from 'expo-secure-store';
+
+const TOKEN_KEY = 'jwt-token';
+
+interface TokenStore {
+    getToken: () => Promise<string | null>;
+    setToken: (token: string) => Promise<void>;
+    deleteToken: () => Promise<void>;
+}
+
+ export const tokenStore: TokenStore = {
+    async getToken() {
+        try {
+            return await SecureStore.getItemAsync(TOKEN_KEY);
+        } catch {
+            throw Error("Failed to get token please retry.");
+        }
+    },
+    async setToken(token: string) {
+        try {
+            await SecureStore.setItemAsync(TOKEN_KEY, token);
+        } catch {
+            throw Error("Failed to set token please try again.")
+        }
+    },
+    async deleteToken() {
+        try {
+            await SecureStore.deleteItemAsync(TOKEN_KEY);
+        } catch {
+            throw Error("Failed to delete token please try again.")
+        }
+    }
+}
\ No newline at end of file

From 01c73749da4ca6ad2249363a359b40529c5e522b Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Fri, 2 Oct 2026 19:06:31 -0700
Subject: [PATCH 02/18] feat(Authentication): Added error session state and
 session action for session restoration failure

---
 src/state/session.ts | 31 +++++++++++++++++++++++++++++--
 1 file changed, 29 insertions(+), 2 deletions(-)

diff --git a/src/state/session.ts b/src/state/session.ts
index 40adc05..8e1f95f 100644
--- a/src/state/session.ts
+++ b/src/state/session.ts
@@ -1,3 +1,5 @@
+import { readonly } from "zod";
+
 export type UserRole = 'student' | 'mentor';
 
 export type SessionUser = {
@@ -16,7 +18,12 @@ export type SessionState =
   | {
       readonly status: 'authenticated';
       readonly user: SessionUser;
-    };
+    }
+  |
+   {
+      readonly status: 'error';
+      readonly errorMessage: string;
+   };
 
 export type SessionAction =
   | {
@@ -28,7 +35,18 @@ export type SessionAction =
     }
   | {
       readonly type: 'signedOut';
-    };
+    }
+  | {
+      readonly type: 'anonymous';
+    }
+  | {
+      readonly type: 'launchError';
+      readonly errorMessage: string;
+    }
+  | {
+      readonly type: 'launchRestore';
+    }
+  
 
 export const initialSessionState: SessionState = {
   status: 'bootstrapping',
@@ -48,6 +66,15 @@ export function sessionReducer(
       };
     case 'signedOut':
       return state.status === 'anonymous' ? state : { status: 'anonymous' };
+    case 'launchError':
+      return { 
+        status: 'error', 
+        errorMessage: action.errorMessage, 
+      };
+    case 'anonymous':
+      return { status: 'anonymous' };
+    case 'launchRestore':
+      return { status: 'bootstrapping'}
     default: {
       const exhaustiveAction: never = action;
       return exhaustiveAction;

From a4f4effe635b56f31f92cf6408282605fbb6ea98 Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Fri, 2 Oct 2026 19:16:44 -0700
Subject: [PATCH 03/18] feat(Authentication): Added signIn, signOut,
 restoreSession logic with face AuthGateway

---
 src/providers/SessionProvider.tsx | 153 +++++++++++++++++++++++++++++-
 1 file changed, 149 insertions(+), 4 deletions(-)

diff --git a/src/providers/SessionProvider.tsx b/src/providers/SessionProvider.tsx
index be6dd66..670ade7 100644
--- a/src/providers/SessionProvider.tsx
+++ b/src/providers/SessionProvider.tsx
@@ -4,6 +4,7 @@ import {
   useContext,
   useEffect,
   useReducer,
+  useRef,
 } from 'react';
 
 import {
@@ -14,10 +15,16 @@ import {
   type UserRole,
 } from '@/state/session';
 
+import { tokenStore } from '@/features/auth/secureStore';
+
+import { useQueryClient } from '@tanstack/react-query';
+
 type SessionContextValue = {
   session: SessionState;
   mockSignInAs: (role: UserRole) => void;
-  signOut: () => void;
+  signIn: (username: string, password: string) => Promise<void>;
+  signOut: () => Promise<void>;
+  restoreSession: () => Promise<void>;
 };
 
 const mockUsers: Record<UserRole, SessionUser> = {
@@ -33,14 +40,100 @@ const mockUsers: Record<UserRole, SessionUser> = {
   },
 };
 
+// FAKE GATEWAY
+interface AuthGateway {
+  login: (username: string, password: string) => Promise<string>;
+  validate: (token: string) => Promise<boolean>;
+}
+
+const authGateway: AuthGateway = {
+  async login(username: string, password: string): Promise<string> {
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, 1000);
+    });
+
+    return 'token123';
+  },
+  async validate(token: string): Promise<boolean> {
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, 1000);
+    });
+
+    return true;
+  },
+};
+
 const SessionContext = createContext<SessionContextValue | null>(null);
 
 export function SessionProvider({ children }: PropsWithChildren) {
   const [session, dispatch] = useReducer(sessionReducer, initialSessionState);
 
+  // Used to clear cache when signing out.
+  const queryClient = useQueryClient();
+
+  // On launch check if a user has a valid session
   useEffect(() => {
-    dispatch({ type: 'bootstrapCompleted' });
+    restoreSession();
   }, []);
+  
+  const restoreRef = useRef(false);
+  async function restoreSession(): Promise<void> {
+    // This prevents a user from pressing on the retry button multiple times.
+    // Which will cause this function to run multiple times.
+    if (restoreRef.current) {
+      return;
+    }
+
+    restoreRef.current = true;
+
+    dispatch({ type: 'launchRestore'})
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, 2000);
+    });
+    try {
+      const token = await tokenStore.getToken();
+
+      // A saved token exist, now validate it.
+      if (token) {
+        const validToken = await authGateway.validate(token);
+
+        // for now mock role
+        const role = 'student';
+
+        if (validToken) {
+          dispatch({
+            type: 'authenticated',
+            user: mockUsers[role],
+          });
+        } else {
+          // token is invalid. Make an expired token state
+
+          // Delete the expired token
+          await tokenStore.deleteToken();
+
+          // For now just make state anonymous
+          dispatch({ type: 'bootstrapCompleted' });
+        }
+      } else {
+        // There is no saveed token so state is anonymous
+        dispatch({ type: 'anonymous' });
+      }
+    } catch (error) {
+      // Show an error state. Ask to refetch, since there may be a valid token.
+      // Error is caused either by secure token get failing, or connection failure when validating.
+      const message =
+        error instanceof Error
+          ? error.message
+          : 'Failed to restore session. Please try again.';
+
+      dispatch({
+        type: 'launchError',
+        errorMessage: message,
+      });
+    } finally {
+      restoreRef.current = false;
+    }
+  }
 
   function mockSignInAs(role: UserRole) {
     dispatch({
@@ -49,8 +142,58 @@ export function SessionProvider({ children }: PropsWithChildren) {
     });
   }
 
-  function signOut() {
-    dispatch({ type: 'signedOut' });
+  async function signIn(username: string, password: string): Promise<void> {
+    try {
+      const token = await authGateway.login(username, password);
+
+      if (!token) {
+        // Empty token recieved
+        throw new Error('Invalid token. Please try again.');
+      }
+
+      // Validate token
+      const valid = await authGateway.validate(token);
+
+      if (!valid) {
+        throw new Error('Invalid token. Please sign in again.');
+      }
+
+      await tokenStore.setToken(token);
+
+      // For now assume role until we're able to decode the token and get users role
+      const role = 'student';
+
+      dispatch({
+        type: 'authenticated',
+        user: mockUsers[role],
+      });
+    } catch (error) {
+      const message =
+        error instanceof Error
+          ? error.message
+          : 'Sign in failed. Please try again.';
+      throw Error(message);
+    }
+  }
+
+  async function signOut() {
+    try {
+      // delete the saved token
+      await tokenStore.deleteToken();
+
+      // cancel any on going queries and clear cache.
+      await queryClient.cancelQueries();
+      queryClient.clear();
+
+      // make the users sign out and their status anonymous
+      dispatch({ type: 'signedOut' });
+    } catch (error) {
+      const message =
+        error instanceof Error
+          ? error.message
+          : 'Sign out failed. Please try again.';
+      throw Error(message);
+    }
   }
 
   return (
@@ -58,7 +201,9 @@ export function SessionProvider({ children }: PropsWithChildren) {
       value={{
         session,
         mockSignInAs,
+        signIn,
         signOut,
+        restoreSession,
       }}
     >
       {children}

From 6a4ffc1dadd9becc9633eeb144c54b3e31fc468c Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Tue, 6 Oct 2026 16:52:15 -0700
Subject: [PATCH 04/18] feat(Authentication): Added sign out to profile.tsx
 with InlineError if there is an error

---
 app/(app)/(tabs)/profile.tsx | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/app/(app)/(tabs)/profile.tsx b/app/(app)/(tabs)/profile.tsx
index f620b6a..b09afc9 100644
--- a/app/(app)/(tabs)/profile.tsx
+++ b/app/(app)/(tabs)/profile.tsx
@@ -15,6 +15,8 @@ import {
   spacing,
 } from '@/design/tokens';
 import { useSession } from '@/providers/SessionProvider';
+import { useState } from 'react';
+import { InlineError } from '@/components/feedback/InlineError';
 
 type Badge = {
   id: string;
@@ -139,6 +141,21 @@ export default function ProfileRoute() {
     session.status === 'authenticated' ? session.user.role : 'student';
   const initial = displayName.charAt(0).toUpperCase();
   const earnedCount = BADGES.filter((b) => b.earned).length;
+  const [signingOut, setSigningOut] = useState(false);
+  const [error, setError] = useState('');
+
+  const signOutPressed = async () => {
+    setSigningOut(true);
+
+    try {
+      await signOut();
+    } catch (error) {
+      setSigningOut(false);
+      const message = error instanceof Error ? error.message : 'Sign out failed. Please try again.';
+      setError(message);
+    }
+   
+  };
 
   return (
     <SafeAreaView style={s.safe}>
@@ -258,7 +275,8 @@ export default function ProfileRoute() {
         <Pressable
           accessibilityLabel="Sign out"
           accessibilityRole="button"
-          onPress={signOut}
+          onPress={signOutPressed}
+          disabled={signingOut}
           style={({ pressed }) => [
             s.signOutBtn,
             pressed && s.signOutBtnPressed,
@@ -267,6 +285,8 @@ export default function ProfileRoute() {
           <Text style={s.signOutText}>Sign out</Text>
         </Pressable>
 
+         {error && <InlineError message={error} />}
+
         <View style={{ height: spacing.xl }} />
       </ScrollView>
     </SafeAreaView>

From 36a10a4a734d49d489ffa4a2723a711f3a8f8c49 Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Tue, 6 Oct 2026 16:56:44 -0700
Subject: [PATCH 05/18] feat(Authentication): Added sign in to sign-in.tsx with
 InlineError and Spinner when loading

---
 app/(public)/sign-in.tsx | 46 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 44 insertions(+), 2 deletions(-)

diff --git a/app/(public)/sign-in.tsx b/app/(public)/sign-in.tsx
index f3c3dfe..3dab9d2 100644
--- a/app/(public)/sign-in.tsx
+++ b/app/(public)/sign-in.tsx
@@ -26,17 +26,23 @@ import {
   radii,
   spacing,
 } from '@/design/tokens';
+
 import { useSession } from '@/providers/SessionProvider';
+import { Spinner } from '@/components/ui/Spinner';
+import { InlineError } from '@/components/feedback/InlineError';
 
 const chessPiecePattern = require('@/assets/images/chess-piece-pattern.png');
 
 export default function SignInRoute() {
-  const { mockSignInAs } = useSession();
+  const { mockSignInAs, signIn, session } = useSession();
   const [username, setUsername] = useState('');
   const [password, setPassword] = useState('');
   const [usernameFocused, setUsernameFocused] = useState(false);
   const [passwordFocused, setPasswordFocused] = useState(false);
   const [showPassword, setShowPassword] = useState(false);
+  const [signingIn, setSigningIn] = useState(false);
+
+  const [error, setError] = useState(session.status === 'expired' ? session.expiredMessage : '');
 
   const [btnScale] = useState(() => new Animated.Value(1));
   const pressIn = () =>
@@ -54,6 +60,34 @@ export default function SignInRoute() {
       bounciness: 4,
     }).start();
 
+  const signInPressed = async () => {
+    setError('')
+    setSigningIn(true);
+
+    if (!username || !password) {
+      setSigningIn(false);
+
+      // Show invalid-credentials message
+      setError('Please enter your username and password');
+
+      return;
+    }
+
+    try {
+      await signIn(username, password);
+    } catch (error) {
+      setSigningIn(false);
+      const message =
+        error instanceof Error
+          ? error.message
+          : 'Sign in failed. Please try again.';
+
+      setError(message);
+    }
+
+    // SessionProvider will update screen.
+  };
+
   return (
     <SafeAreaView style={s.safe}>
       {/* ── Patterned Background ──────────────── */}
@@ -142,12 +176,20 @@ export default function SignInRoute() {
                 accessibilityRole="button"
                 onPressIn={pressIn}
                 onPressOut={pressOut}
+                onPress={signInPressed}
+                disabled={signingIn}
                 style={s.enterBtn}
               >
-                <Text style={s.enterBtnText}>Sign In →</Text>
+                {signingIn ? (
+                  <Spinner label="Preparing your session" />
+                ) : (
+                  <Text style={s.enterBtnText}>Sign In →</Text>
+                )}
               </Pressable>
             </Animated.View>
 
+            {error && <InlineError message={error} />}
+
             <View style={s.signupRow}>
               <Text style={s.signupHint}>New here? </Text>
               <Pressable hitSlop={8}>

From 5308639fe05cce466d691e60d9823f86ab1bb525 Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Tue, 6 Oct 2026 17:04:59 -0700
Subject: [PATCH 06/18] feat(Authentication): Added expiredSessoin to
 SessionProvider.tsx. Function used when users session expires. Removed fake
 AuthGateway

---
 src/providers/SessionProvider.tsx | 79 +++++++++++++++++--------------
 1 file changed, 43 insertions(+), 36 deletions(-)

diff --git a/src/providers/SessionProvider.tsx b/src/providers/SessionProvider.tsx
index 670ade7..5312e15 100644
--- a/src/providers/SessionProvider.tsx
+++ b/src/providers/SessionProvider.tsx
@@ -15,15 +15,17 @@ import {
   type UserRole,
 } from '@/state/session';
 
-import { tokenStore } from '@/features/auth/secureStore';
+import { tokenStore } from '@/services/storage/TokenStore';
 
 import { useQueryClient } from '@tanstack/react-query';
+import { authGateway } from '@/services/auth/AuthGateway';
 
 type SessionContextValue = {
   session: SessionState;
   mockSignInAs: (role: UserRole) => void;
   signIn: (username: string, password: string) => Promise<void>;
   signOut: () => Promise<void>;
+  expiredSession: () => Promise<void>;
   restoreSession: () => Promise<void>;
 };
 
@@ -40,28 +42,7 @@ const mockUsers: Record<UserRole, SessionUser> = {
   },
 };
 
-// FAKE GATEWAY
-interface AuthGateway {
-  login: (username: string, password: string) => Promise<string>;
-  validate: (token: string) => Promise<boolean>;
-}
-
-const authGateway: AuthGateway = {
-  async login(username: string, password: string): Promise<string> {
-    await new Promise<void>((resolve) => {
-      setTimeout(resolve, 1000);
-    });
 
-    return 'token123';
-  },
-  async validate(token: string): Promise<boolean> {
-    await new Promise<void>((resolve) => {
-      setTimeout(resolve, 1000);
-    });
-
-    return true;
-  },
-};
 
 const SessionContext = createContext<SessionContextValue | null>(null);
 
@@ -75,8 +56,9 @@ export function SessionProvider({ children }: PropsWithChildren) {
   useEffect(() => {
     restoreSession();
   }, []);
-  
+
   const restoreRef = useRef(false);
+
   async function restoreSession(): Promise<void> {
     // This prevents a user from pressing on the retry button multiple times.
     // Which will cause this function to run multiple times.
@@ -86,7 +68,7 @@ export function SessionProvider({ children }: PropsWithChildren) {
 
     restoreRef.current = true;
 
-    dispatch({ type: 'launchRestore'})
+    dispatch({ type: 'launchRestore' });
     await new Promise<void>((resolve) => {
       setTimeout(resolve, 2000);
     });
@@ -97,25 +79,19 @@ export function SessionProvider({ children }: PropsWithChildren) {
       if (token) {
         const validToken = await authGateway.validate(token);
 
-        // for now mock role
-        const role = 'student';
-
         if (validToken) {
+          // for now mock role
+          const role = 'student';
           dispatch({
             type: 'authenticated',
             user: mockUsers[role],
           });
         } else {
-          // token is invalid. Make an expired token state
-
-          // Delete the expired token
-          await tokenStore.deleteToken();
-
-          // For now just make state anonymous
-          dispatch({ type: 'bootstrapCompleted' });
+          // token is invalid. Session state is expired
+          await expiredSession();
         }
       } else {
-        // There is no saveed token so state is anonymous
+        // There is no saved token / previous session so state is anonymous
         dispatch({ type: 'anonymous' });
       }
     } catch (error) {
@@ -142,13 +118,43 @@ export function SessionProvider({ children }: PropsWithChildren) {
     });
   }
 
+  // This function will get called if there is a 401 response meaning the token is expired.
+  // Or if the token expired when the app was first launched
+  // use ref incase multiple 401 responses happens and expiredSession gets called multiple times.
+
+  const expiringRef = useRef(false);
+  async function expiredSession() {
+    if (expiringRef.current) {
+      return;
+    }
+
+    expiringRef.current = true;
+
+    // This ensures if deleteToken fails cancelQueries still gets called
+    try {
+      await Promise.allSettled([
+        tokenStore.deleteToken(),
+        queryClient.cancelQueries(),
+      ]);
+
+      queryClient.clear();
+
+      dispatch({
+        type: 'expired',
+        expiredMessage: 'Your session has expired. Please sign in again.',
+      });
+    } finally {
+      expiringRef.current = false;
+    }
+  }
+
   async function signIn(username: string, password: string): Promise<void> {
     try {
       const token = await authGateway.login(username, password);
 
       if (!token) {
         // Empty token recieved
-        throw new Error('Invalid token. Please try again.');
+        throw new Error('Invalid credentials. Please try again.');
       }
 
       // Validate token
@@ -203,6 +209,7 @@ export function SessionProvider({ children }: PropsWithChildren) {
         mockSignInAs,
         signIn,
         signOut,
+        expiredSession,
         restoreSession,
       }}
     >

From f46bedf52a88c7d6522a9c5297836354d0a7e533 Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Wed, 7 Oct 2026 19:19:36 -0700
Subject: [PATCH 07/18] Added error state status state with sign out + retry in
 root layo ut

---
 app/_layout.tsx | 28 ++++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/app/_layout.tsx b/app/_layout.tsx
index 60995a0..2bf76bc 100644
--- a/app/_layout.tsx
+++ b/app/_layout.tsx
@@ -8,6 +8,8 @@ import { QueryProvider } from '@/providers/QueryProvider';
 
 import '@/config/env';
 
+import LaunchError from '@/features/auth/components/launch-error';
+
 export default function RootLayout() {
   return (
     <QueryProvider>
@@ -20,7 +22,7 @@ export default function RootLayout() {
 }
 
 function RootNavigator() {
-  const { session } = useSession();
+  const { session, restoreSession, signOut } = useSession();
 
   if (session.status === 'bootstrapping') {
     return (
@@ -30,9 +32,31 @@ function RootNavigator() {
     );
   }
 
+  // If an error occured on launch while checking if a user has a session.
+  if (session.status === 'error') {
+    // Get error message from session
+    const message = session.errorMessage;
+    return (
+      <Screen
+        background="patterned"
+        centered
+        testID="session-bootstrap-screen" // change this
+        contentStyle={{ gap: 16 }}
+      >
+        <LaunchError
+          message={message}
+          restoreSession={restoreSession}
+          signOut={signOut}
+        />
+      </Screen>
+    );
+  }
+
   return (
     <Stack screenOptions={{ headerShown: false }}>
-      <Stack.Protected guard={session.status === 'anonymous'}>
+      <Stack.Protected
+        guard={session.status === 'anonymous' || session.status === 'expired'}
+      >
         <Stack.Screen name="(public)" />
       </Stack.Protected>
 

From 2a9079c2a1b1bcd2a01d923d779d6b952f291474 Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Sat, 10 Oct 2026 18:45:24 -0700
Subject: [PATCH 08/18] feat(Authentication): Added test

---
 test/authentication.test.tsx | 274 +++++++++++++++++++++++++++++++++++
 1 file changed, 274 insertions(+)
 create mode 100644 test/authentication.test.tsx

diff --git a/test/authentication.test.tsx b/test/authentication.test.tsx
new file mode 100644
index 0000000..1e0362b
--- /dev/null
+++ b/test/authentication.test.tsx
@@ -0,0 +1,274 @@
+import { router } from 'expo-router';
+import {
+  act,
+  fireEvent,
+  renderRouter,
+  screen,
+  waitFor,
+} from 'expo-router/testing-library';
+import { render } from '@testing-library/react-native';
+import { QueryClientProvider } from '@tanstack/react-query';
+import { Button, Text, View } from 'react-native';
+
+import { AppError } from '@/services/api/apiError';
+import { authGateway } from '@/services/auth/AuthGateway';
+import { tokenStore } from '@/services/storage/TokenStore';
+import { createQueryClient } from '@/providers/QueryProvider';
+import { SessionProvider, useSession } from '@/providers/SessionProvider';
+import { renderAnonymous } from './fixtures/renderAnonymous';
+import { studentToken } from './fixtures/studentToken';
+
+function submitSignIn(username: string, password: string) {
+  fireEvent.changeText(screen.getByTestId('username-input'), username);
+  fireEvent.changeText(screen.getByTestId('password-input'), password);
+  fireEvent.press(screen.getByRole('button', { name: 'Sign in' }));
+}
+
+function MockScreen() {
+  const { session, mockSignInAs, signOut } = useSession();
+
+  return (
+    <View>
+      <Text>{session.status}</Text>
+      <Button title="Mock student" onPress={() => mockSignInAs('student')} />
+      <Button title="Sign out" onPress={signOut} />
+    </View>
+  );
+}
+
+describe('authentication', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('Successful login stores the token.', async () => {
+    let savedToken: string | null = null;
+    const login = jest
+      .spyOn(authGateway, 'login')
+      .mockResolvedValue(studentToken);
+    const setToken = jest
+      .spyOn(tokenStore, 'setToken')
+      .mockImplementation(async (token) => {
+        savedToken = token;
+      });
+    jest
+      .spyOn(tokenStore, 'getToken')
+      .mockResolvedValueOnce(null)
+      .mockImplementation(async () => savedToken);
+
+    const renderedRouter = renderRouter('./app', { initialUrl: '/sign-in' });
+    await screen.findByText('Welcome back');
+    submitSignIn('User', 'password123');
+
+    await waitFor(() => expect(renderedRouter.getPathname()).toBe('/'));
+    expect(login).toHaveBeenCalledWith('User', 'password123');
+    expect(setToken).toHaveBeenCalledWith(studentToken);
+    expect(await tokenStore.getToken()).toBe(studentToken);
+  });
+
+  it('Invalid credentials show an error.', async () => {
+    const login = jest
+      .spyOn(authGateway, 'login')
+      .mockRejectedValue(
+        new AppError('UNKNOWN', 'Invalid username or password.'),
+      );
+    const renderedRouter = await renderAnonymous('/sign-in');
+    submitSignIn('User', 'wrong-password');
+
+    expect(
+      await screen.findByText('Invalid username or password.'),
+    ).toBeOnTheScreen();
+    expect(renderedRouter.getPathname()).toBe('/sign-in');
+    expect(login).toHaveBeenCalledTimes(1);
+  });
+
+  it.each([
+    ['', ''],
+    ['   ', '   '],
+    ['User', ''],
+    ['', 'password123'],
+  ])('Blank fields are rejected (%s, %s).', async (username, password) => {
+    const login = jest.spyOn(authGateway, 'login');
+    const renderedRouter = await renderAnonymous('/sign-in');
+    submitSignIn(username, password);
+
+    expect(
+      await screen.findByText('Please enter your username and password'),
+    ).toBeOnTheScreen();
+    expect(renderedRouter.getPathname()).toBe('/sign-in');
+    expect(login).not.toHaveBeenCalled();
+  });
+
+  it('Connection failure shows a retryable error.', async () => {
+    const login = jest
+      .spyOn(authGateway, 'login')
+      .mockRejectedValueOnce(
+        new AppError('NETWORK_ERROR', 'Unable to connect to the server.'),
+      )
+      .mockResolvedValue(studentToken);
+    const renderedRouter = await renderAnonymous('/sign-in');
+    submitSignIn('User', 'password123');
+
+    expect(
+      await screen.findByText('Unable to connect to the server.'),
+    ).toBeOnTheScreen();
+    expect(renderedRouter.getPathname()).toBe('/sign-in');
+
+    fireEvent.press(screen.getByRole('button', { name: 'Sign in' }));
+    await waitFor(() => expect(renderedRouter.getPathname()).toBe('/'));
+    expect(login).toHaveBeenCalledTimes(2);
+  });
+
+  it('A stored valid token restores the session.', async () => {
+    const getToken = jest
+      .spyOn(tokenStore, 'getToken')
+      .mockResolvedValue(studentToken);
+    const validate = jest
+      .spyOn(authGateway, 'validate')
+      .mockResolvedValue(true);
+    const renderedRouter = renderRouter('./app', { initialUrl: '/sign-in' });
+
+    await waitFor(() => expect(renderedRouter.getPathname()).toBe('/'));
+    expect(screen.getByText('Quick Actions')).toBeOnTheScreen();
+    expect(getToken).toHaveBeenCalled();
+    expect(validate).toHaveBeenCalledWith(studentToken);
+  });
+
+  it('An expired token is deleted.', async () => {
+    let savedToken: string | null = studentToken;
+    jest
+      .spyOn(tokenStore, 'getToken')
+      .mockImplementation(async () => savedToken);
+    const deleteToken = jest
+      .spyOn(tokenStore, 'deleteToken')
+      .mockImplementation(async () => {
+        savedToken = null;
+      });
+    const validate = jest
+      .spyOn(authGateway, 'validate')
+      .mockResolvedValue(false);
+    const renderedRouter = renderRouter('./app', { initialUrl: '/sign-in' });
+
+    expect(
+      await screen.findByText(
+        'Your session has expired. Please sign in again.',
+      ),
+    ).toBeOnTheScreen();
+    expect(renderedRouter.getPathname()).toBe('/sign-in');
+
+    expect(validate).toHaveBeenCalledWith(studentToken);
+    expect(deleteToken).toHaveBeenCalledTimes(1);
+    expect(await tokenStore.getToken()).toBeNull();
+  });
+
+  it('A validation connection failure does not immediately destroy a potentially valid token.', async () => {
+    const getToken = jest
+      .spyOn(tokenStore, 'getToken')
+      .mockResolvedValue(studentToken);
+    const deleteToken = jest.spyOn(tokenStore, 'deleteToken');
+    const validate = jest
+      .spyOn(authGateway, 'validate')
+      .mockRejectedValueOnce(
+        new AppError('NETWORK_ERROR', 'Unable to connect to the server.'),
+      )
+      .mockResolvedValue(true);
+    const renderedRouter = renderRouter('./app', { initialUrl: '/sign-in' });
+
+    expect(await screen.findByTestId('session-error-screen')).toBeOnTheScreen();
+    expect(deleteToken).not.toHaveBeenCalled();
+    fireEvent.press(screen.getByRole('button', { name: 'Retry' }));
+
+    await waitFor(() => expect(renderedRouter.getPathname()).toBe('/'));
+    expect(getToken).toHaveBeenCalledTimes(2);
+    expect(validate).toHaveBeenCalledTimes(2);
+    expect(deleteToken).not.toHaveBeenCalled();
+  });
+
+  it('Sign Out deletes the token.', async () => {
+    let savedToken: string | null = null;
+    jest.spyOn(authGateway, 'login').mockResolvedValue(studentToken);
+    jest.spyOn(tokenStore, 'setToken').mockImplementation(async (token) => {
+      savedToken = token;
+    });
+    jest
+      .spyOn(tokenStore, 'getToken')
+      .mockResolvedValueOnce(null)
+      .mockImplementation(async () => savedToken);
+    const deleteToken = jest
+      .spyOn(tokenStore, 'deleteToken')
+      .mockImplementation(async () => {
+        savedToken = null;
+      });
+    const renderedRouter = renderRouter('./app', { initialUrl: '/sign-in' });
+    await screen.findByText('Welcome back');
+    submitSignIn('User', 'password123');
+    await waitFor(() => expect(renderedRouter.getPathname()).toBe('/'));
+
+    act(() => router.push('/profile'));
+    await waitFor(() => expect(renderedRouter.getPathname()).toBe('/profile'));
+    fireEvent.press(screen.getByRole('button', { name: 'Sign out' }));
+
+    await waitFor(() => expect(renderedRouter.getPathname()).toBe('/sign-in'));
+    expect(deleteToken).toHaveBeenCalledTimes(1);
+    expect(await tokenStore.getToken()).toBeNull();
+  });
+
+  it('Sign Out clears private cached data.', async () => {
+    const queryClient = createQueryClient();
+    const privateKey = ['student', 'profile'];
+    render(
+      <QueryClientProvider client={queryClient}>
+        <SessionProvider>
+          <MockScreen />
+        </SessionProvider>
+      </QueryClientProvider>,
+    );
+
+    await screen.findByText('anonymous');
+    fireEvent.press(screen.getByRole('button', { name: 'Mock student' }));
+    expect(screen.getByText('authenticated')).toBeOnTheScreen();
+    queryClient.setQueryData(privateKey, { name: 'Test Student' });
+    expect(queryClient.getQueryData(privateKey)).toBeDefined();
+    fireEvent.press(screen.getByRole('button', { name: 'Sign out' }));
+
+    await waitFor(() => {
+      expect(screen.getByText('anonymous')).toBeOnTheScreen();
+      expect(queryClient.getQueryData(privateKey)).toBeUndefined();
+    });
+  });
+
+  it('The password is never stored.', async () => {
+    jest.spyOn(authGateway, 'login').mockResolvedValue(studentToken);
+    const setToken = jest
+      .spyOn(tokenStore, 'setToken')
+      .mockResolvedValue(undefined);
+    await renderAnonymous('/sign-in');
+    submitSignIn('User', 'password123');
+
+    await screen.findByText('Quick Actions');
+    expect(setToken).toHaveBeenCalledTimes(1);
+    expect(setToken).toHaveBeenCalledWith(studentToken);
+    expect(setToken).not.toHaveBeenCalledWith('password123');
+  });
+
+  it('Protected screens cannot be reopened after Sign Out.', async () => {
+    jest.spyOn(authGateway, 'login').mockResolvedValue(studentToken);
+    const renderedRouter = await renderAnonymous('/sign-in');
+    submitSignIn('User', 'password123');
+    await waitFor(() => expect(renderedRouter.getPathname()).toBe('/'));
+
+    act(() => router.push('/profile'));
+    await waitFor(() => expect(renderedRouter.getPathname()).toBe('/profile'));
+    fireEvent.press(screen.getByRole('button', { name: 'Sign out' }));
+    await waitFor(() => expect(renderedRouter.getPathname()).toBe('/sign-in'));
+
+    if (router.canGoBack()) {
+      act(() => router.back());
+      await waitFor(() =>
+        expect(renderedRouter.getPathname()).toBe('/sign-in'),
+      );
+    }
+    act(() => router.push('/profile'));
+    await waitFor(() => expect(renderedRouter.getPathname()).toBe('/sign-in'));
+  });
+});

From 4646390ef82576ff588de13afe406e0a5ed7c6ec Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Sat, 10 Oct 2026 18:47:02 -0700
Subject: [PATCH 09/18] test(Authentication): updated SessionProvider test with
 QueryProvider

---
 test/SessionProvider.test.tsx | 33 ++++++++++++++++++++++-----------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/test/SessionProvider.test.tsx b/test/SessionProvider.test.tsx
index 60df8d2..43a1c3a 100644
--- a/test/SessionProvider.test.tsx
+++ b/test/SessionProvider.test.tsx
@@ -6,6 +6,7 @@ import {
 } from '@testing-library/react-native';
 import { Button, Text, View } from 'react-native';
 
+import { QueryProvider } from '@/providers/QueryProvider';
 import { SessionProvider, useSession } from '@/providers/SessionProvider';
 
 function SessionTestHarness() {
@@ -31,9 +32,11 @@ function SessionTestHarness() {
 describe('SessionProvider', () => {
   it('finishes bootstrap as anonymous', async () => {
     render(
-      <SessionProvider>
-        <SessionTestHarness />
-      </SessionProvider>,
+      <QueryProvider>
+        <SessionProvider>
+          <SessionTestHarness />
+        </SessionProvider>
+      </QueryProvider>,
     );
 
     await waitFor(() => {
@@ -43,11 +46,15 @@ describe('SessionProvider', () => {
 
   it('supports mocked student sign-in and sign-out', async () => {
     render(
-      <SessionProvider>
-        <SessionTestHarness />
-      </SessionProvider>,
+      <QueryProvider>
+        <SessionProvider>
+          <SessionTestHarness />
+        </SessionProvider>
+      </QueryProvider>,
     );
 
+    await screen.findByText('anonymous');
+
     fireEvent.press(
       screen.getByRole('button', {
         name: 'Mock student',
@@ -64,16 +71,20 @@ describe('SessionProvider', () => {
       }),
     );
 
-    expect(screen.getByText('anonymous')).toBeOnTheScreen();
+    await screen.findByText('anonymous');
   });
 
-  it('supports mocked mentor sign-in', () => {
+  it('supports mocked mentor sign-in', async () => {
     render(
-      <SessionProvider>
-        <SessionTestHarness />
-      </SessionProvider>,
+      <QueryProvider>
+        <SessionProvider>
+          <SessionTestHarness />
+        </SessionProvider>
+      </QueryProvider>,
     );
 
+    await screen.findByText('anonymous');
+
     fireEvent.press(
       screen.getByRole('button', {
         name: 'Mock mentor',

From 0aad84260d1f3a73fa0cb2b90fa26c20583b3822 Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Sat, 10 Oct 2026 19:04:58 -0700
Subject: [PATCH 10/18] fix(Authentication): added AppError + ConnectionBanner
 to sign-in.tsx

---
 app/(public)/sign-in.tsx | 45 +++++++++++++++++++++++++++-------------
 1 file changed, 31 insertions(+), 14 deletions(-)

diff --git a/app/(public)/sign-in.tsx b/app/(public)/sign-in.tsx
index 3dab9d2..ce7f81f 100644
--- a/app/(public)/sign-in.tsx
+++ b/app/(public)/sign-in.tsx
@@ -30,6 +30,9 @@ import {
 import { useSession } from '@/providers/SessionProvider';
 import { Spinner } from '@/components/ui/Spinner';
 import { InlineError } from '@/components/feedback/InlineError';
+import { ConnectionBanner } from '@/components/feedback/ConnectionBanner';
+import { isNonEmptyString } from '@/utils/isNonEmptyString';
+import { AppError } from '@/services/api/apiError';
 
 const chessPiecePattern = require('@/assets/images/chess-piece-pattern.png');
 
@@ -41,8 +44,10 @@ export default function SignInRoute() {
   const [passwordFocused, setPasswordFocused] = useState(false);
   const [showPassword, setShowPassword] = useState(false);
   const [signingIn, setSigningIn] = useState(false);
-
-  const [error, setError] = useState(session.status === 'expired' ? session.expiredMessage : '');
+  const [error, setError] = useState(
+    session.status === 'expired' ? session.expiredMessage : '',
+  );
+  const [connectionError, setConnectionError] = useState('');
 
   const [btnScale] = useState(() => new Animated.Value(1));
   const pressIn = () =>
@@ -61,13 +66,13 @@ export default function SignInRoute() {
     }).start();
 
   const signInPressed = async () => {
-    setError('')
+    setError('');
+    setConnectionError('');
     setSigningIn(true);
 
-    if (!username || !password) {
+    if (!isNonEmptyString(username) || !isNonEmptyString(password)) {
       setSigningIn(false);
 
-      // Show invalid-credentials message
       setError('Please enter your username and password');
 
       return;
@@ -77,15 +82,22 @@ export default function SignInRoute() {
       await signIn(username, password);
     } catch (error) {
       setSigningIn(false);
-      const message =
-        error instanceof Error
-          ? error.message
-          : 'Sign in failed. Please try again.';
-
-      setError(message);
+      if (error instanceof AppError) {
+        switch (error.code) {
+          case 'NETWORK_ERROR':
+            setConnectionError(error.message);
+            break;
+          case 'REQUEST_TIMEOUT':
+            setConnectionError(error.message);
+            break;
+          default:
+            setError(error.message);
+            break;
+        }
+      } else {
+        setError('Sign in failed. Please try again.');
+      }
     }
-
-    // SessionProvider will update screen.
   };
 
   return (
@@ -128,6 +140,7 @@ export default function SignInRoute() {
               <View style={[s.field, usernameFocused && s.fieldFocused]}>
                 <Text style={s.fieldIcon}>👤</Text>
                 <TextInput
+                testID="username-input"
                   autoCapitalize="none"
                   autoCorrect={false}
                   onBlur={() => setUsernameFocused(false)}
@@ -144,6 +157,7 @@ export default function SignInRoute() {
               <View style={[s.field, passwordFocused && s.fieldFocused]}>
                 <Text style={s.fieldIcon}>🔒</Text>
                 <TextInput
+                  testID="password-input"
                   autoCapitalize="none"
                   autoCorrect={false}
                   onBlur={() => setPasswordFocused(false)}
@@ -181,7 +195,7 @@ export default function SignInRoute() {
                 style={s.enterBtn}
               >
                 {signingIn ? (
-                  <Spinner label="Preparing your session" />
+                  <Spinner label="Signing In" />
                 ) : (
                   <Text style={s.enterBtnText}>Sign In →</Text>
                 )}
@@ -190,6 +204,9 @@ export default function SignInRoute() {
 
             {error && <InlineError message={error} />}
 
+            {connectionError && (
+              <ConnectionBanner message={connectionError} status="offline" />
+            )}
             <View style={s.signupRow}>
               <Text style={s.signupHint}>New here? </Text>
               <Pressable hitSlop={8}>

From aaee854f75a10eccda2b6f40c847dfe0f719cde7 Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Sat, 10 Oct 2026 19:05:45 -0700
Subject: [PATCH 11/18] fix(Authentication): Added AppError and
 ConnectionBanner to profile.tsx

---
 app/(app)/(tabs)/profile.tsx | 36 +++++++++++++++++++++++++++++++-----
 1 file changed, 31 insertions(+), 5 deletions(-)

diff --git a/app/(app)/(tabs)/profile.tsx b/app/(app)/(tabs)/profile.tsx
index b09afc9..18116ec 100644
--- a/app/(app)/(tabs)/profile.tsx
+++ b/app/(app)/(tabs)/profile.tsx
@@ -17,6 +17,9 @@ import {
 import { useSession } from '@/providers/SessionProvider';
 import { useState } from 'react';
 import { InlineError } from '@/components/feedback/InlineError';
+import { AppError } from '@/services/api/apiError';
+import { ConnectionBanner } from '@/components/feedback/ConnectionBanner';
+import { Spinner } from '@/components/ui/Spinner';
 
 type Badge = {
   id: string;
@@ -143,18 +146,33 @@ export default function ProfileRoute() {
   const earnedCount = BADGES.filter((b) => b.earned).length;
   const [signingOut, setSigningOut] = useState(false);
   const [error, setError] = useState('');
+  const [connectionError, setConnectionError] = useState('');
 
   const signOutPressed = async () => {
     setSigningOut(true);
+    setError('');
+    setConnectionError('');
 
     try {
       await signOut();
     } catch (error) {
       setSigningOut(false);
-      const message = error instanceof Error ? error.message : 'Sign out failed. Please try again.';
-      setError(message);
+      if (error instanceof AppError) {
+        switch (error.code) {
+          case 'NETWORK_ERROR':
+            setConnectionError(error.message);
+            break;
+          case 'REQUEST_TIMEOUT':
+            setConnectionError(error.message);
+            break;
+          default:
+            setError(error.message);
+            break;
+        }
+      } else {
+        setError('Sign out failed. Please try again.');
+      }
     }
-   
   };
 
   return (
@@ -282,10 +300,18 @@ export default function ProfileRoute() {
             pressed && s.signOutBtnPressed,
           ]}
         >
-          <Text style={s.signOutText}>Sign out</Text>
+          {signingOut ? (
+            <Spinner label="Signing out" />
+          ) : (
+            <Text style={s.signOutText}>Sign out</Text>
+          )}
         </Pressable>
 
-         {error && <InlineError message={error} />}
+        {error && <InlineError message={error} />}
+
+        {connectionError && (
+          <ConnectionBanner message={connectionError} status="offline" />
+        )}
 
         <View style={{ height: spacing.xl }} />
       </ScrollView>

From ec0c4693e8b352b79e56a14547a65fe93036183c Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Sat, 10 Oct 2026 19:09:18 -0700
Subject: [PATCH 12/18] fix(Authentication): Added error screen for root layout

---
 app/_layout.tsx                               |  6 +++---
 src/features/auth/components/error-screen.tsx | 20 +++++++++++++++++++
 2 files changed, 23 insertions(+), 3 deletions(-)
 create mode 100644 src/features/auth/components/error-screen.tsx

diff --git a/app/_layout.tsx b/app/_layout.tsx
index 2bf76bc..4590d13 100644
--- a/app/_layout.tsx
+++ b/app/_layout.tsx
@@ -8,7 +8,7 @@ import { QueryProvider } from '@/providers/QueryProvider';
 
 import '@/config/env';
 
-import LaunchError from '@/features/auth/components/launch-error';
+import ErrorScreen from '@/features/auth/components/error-screen';
 
 export default function RootLayout() {
   return (
@@ -40,10 +40,10 @@ function RootNavigator() {
       <Screen
         background="patterned"
         centered
-        testID="session-bootstrap-screen" // change this
+        testID="session-error-screen"
         contentStyle={{ gap: 16 }}
       >
-        <LaunchError
+        <ErrorScreen
           message={message}
           restoreSession={restoreSession}
           signOut={signOut}
diff --git a/src/features/auth/components/error-screen.tsx b/src/features/auth/components/error-screen.tsx
new file mode 100644
index 0000000..288e736
--- /dev/null
+++ b/src/features/auth/components/error-screen.tsx
@@ -0,0 +1,20 @@
+import { Button } from '@/components/ui/Button';
+import { InlineError } from '@/components/feedback/InlineError';
+
+export default function ErrorScreen({
+  message,
+  restoreSession,
+  signOut,
+}: {
+  message: string;
+  restoreSession: () => Promise<void>;
+  signOut: () => Promise<void>;
+}) {
+  return (
+    <>
+      <InlineError message={message} />
+      <Button onPress={restoreSession} >Retry</Button>
+      <Button onPress={signOut}>Sign Out</Button>
+    </>
+  );
+}

From b261dbb5380aacc74d05d80991aa69bf8bf901d7 Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Sat, 10 Oct 2026 20:28:56 -0700
Subject: [PATCH 13/18] fix(Authentication): Added fakeAuthgateway for dev only
 testing

---
 app/(public)/sign-in.tsx          |  64 +++++-----
 src/providers/SessionProvider.tsx | 199 +++++++++++++++++++-----------
 src/types/authGateway.ts          |   7 ++
 3 files changed, 171 insertions(+), 99 deletions(-)
 create mode 100644 src/types/authGateway.ts

diff --git a/app/(public)/sign-in.tsx b/app/(public)/sign-in.tsx
index ce7f81f..bdb7d36 100644
--- a/app/(public)/sign-in.tsx
+++ b/app/(public)/sign-in.tsx
@@ -140,7 +140,7 @@ export default function SignInRoute() {
               <View style={[s.field, usernameFocused && s.fieldFocused]}>
                 <Text style={s.fieldIcon}>👤</Text>
                 <TextInput
-                testID="username-input"
+                  testID="username-input"
                   autoCapitalize="none"
                   autoCorrect={false}
                   onBlur={() => setUsernameFocused(false)}
@@ -216,34 +216,42 @@ export default function SignInRoute() {
           </View>
 
           {/* ── Dev Quick-Login ───────────────────── */}
-          <View style={s.dev}>
-            <View style={s.devDivider}>
-              <View style={s.devLine} />
-              <Text style={s.devLabel}>DEV ONLY</Text>
-              <View style={s.devLine} />
-            </View>
-            <View style={s.devRow}>
-              {(['student', 'mentor'] as const).map((role) => (
-                <Pressable
-                  key={role}
-                  accessibilityLabel={`Continue as ${role}`}
-                  accessibilityRole="button"
-                  onPress={() => mockSignInAs(role)}
-                  style={({ pressed }) => [
-                    s.devBtn,
-                    pressed && s.devBtnPressed,
-                  ]}
-                >
-                  <Text style={s.devBtnIcon}>
-                    {role === 'student' ? '🎒' : '🎓'}
-                  </Text>
-                  <Text style={s.devBtnText}>
-                    {role === 'student' ? 'Student' : 'Mentor'}
-                  </Text>
-                </Pressable>
-              ))}
+          {__DEV__ && (
+            <View style={s.dev}>
+              <View style={s.devDivider}>
+                <View style={s.devLine} />
+                <Text style={s.devLabel}>DEV ONLY</Text>
+                <View style={s.devLine} />
+              </View>
+              <View style={s.devRow}>
+                {(['student', 'mentor'] as const).map((role) => (
+                  <Pressable
+                    key={role}
+                    accessibilityLabel={`Continue as ${role}`}
+                    accessibilityRole="button"
+                    onPress={() => {
+                      void mockSignInAs(role).catch(() => {
+                        setError(
+                          'Unable to start a test session. Please try again.',
+                        );
+                      });
+                    }}
+                    style={({ pressed }) => [
+                      s.devBtn,
+                      pressed && s.devBtnPressed,
+                    ]}
+                  >
+                    <Text style={s.devBtnIcon}>
+                      {role === 'student' ? '🎒' : '🎓'}
+                    </Text>
+                    <Text style={s.devBtnText}>
+                      {role === 'student' ? 'Student' : 'Mentor'}
+                    </Text>
+                  </Pressable>
+                ))}
+              </View>
             </View>
-          </View>
+          )}
         </ScrollView>
       </KeyboardAvoidingView>
     </SafeAreaView>
diff --git a/src/providers/SessionProvider.tsx b/src/providers/SessionProvider.tsx
index 5312e15..b0bdf32 100644
--- a/src/providers/SessionProvider.tsx
+++ b/src/providers/SessionProvider.tsx
@@ -11,7 +11,6 @@ import {
   initialSessionState,
   sessionReducer,
   type SessionState,
-  type SessionUser,
   type UserRole,
 } from '@/state/session';
 
@@ -19,31 +18,47 @@ import { tokenStore } from '@/services/storage/TokenStore';
 
 import { useQueryClient } from '@tanstack/react-query';
 import { authGateway } from '@/services/auth/AuthGateway';
+import { AppError } from '@/services/api/apiError';
+import { decodeJWT } from '@/services/auth/decodeJWT';
+import type { AuthGateway } from '@/types/authGateway';
 
 type SessionContextValue = {
   session: SessionState;
-  mockSignInAs: (role: UserRole) => void;
+  mockSignInAs: (role: UserRole) => Promise<void>;
   signIn: (username: string, password: string) => Promise<void>;
   signOut: () => Promise<void>;
   expiredSession: () => Promise<void>;
   restoreSession: () => Promise<void>;
 };
 
-const mockUsers: Record<UserRole, SessionUser> = {
-  student: {
-    id: 'mock-student',
-    displayName: 'Mock Student',
-    role: 'student',
+export const studentToken =
+  'eyJ0eXAiOiJKV1QifQ.eyJpZCI6Im1vY2stc3R1ZGVudCIsImRpc3BsYXlOYW1lIjoiTW9jayBTdHVkZW50Iiwicm9sZSI6InN0dWRlbnQifQ.fake';
+
+export const mentorToken =
+  'eyJ0eXAiOiJKV1QifQ.eyJpZCI6Im1vY2stbWVudG9yIiwiZGlzcGxheU5hbWUiOiJNb2NrIE1lbnRvciIsInJvbGUiOiJtZW50b3IifQ.fake';
+
+const fakeAuthGateway: AuthGateway = {
+  async login(username) {
+    if (username === 'student') return studentToken;
+    if (username === 'mentor') return mentorToken;
+    throw new AppError('UNKNOWN', 'Unknown test account.');
   },
-  mentor: {
-    id: 'mock-mentor',
-    displayName: 'Mock Mentor',
-    role: 'mentor',
+  async logout() {
+    try {
+      await tokenStore.deleteToken();
+    } catch (error) {
+      if (error instanceof AppError) {
+        throw error;
+      }
+
+      throw new AppError('UNKNOWN', 'Sign out failed. Please try again.');
+    }
+  },
+  async validate(token) {
+    return token === studentToken || token === mentorToken;
   },
 };
 
-
-
 const SessionContext = createContext<SessionContextValue | null>(null);
 
 export function SessionProvider({ children }: PropsWithChildren) {
@@ -52,11 +67,6 @@ export function SessionProvider({ children }: PropsWithChildren) {
   // Used to clear cache when signing out.
   const queryClient = useQueryClient();
 
-  // On launch check if a user has a valid session
-  useEffect(() => {
-    restoreSession();
-  }, []);
-
   const restoreRef = useRef(false);
 
   async function restoreSession(): Promise<void> {
@@ -68,23 +78,37 @@ export function SessionProvider({ children }: PropsWithChildren) {
 
     restoreRef.current = true;
 
-    dispatch({ type: 'launchRestore' });
-    await new Promise<void>((resolve) => {
-      setTimeout(resolve, 2000);
-    });
+    dispatch({ type: 'restore' });
+
     try {
       const token = await tokenStore.getToken();
 
-      // A saved token exist, now validate it.
       if (token) {
-        const validToken = await authGateway.validate(token);
+        // For dev testing
+        const isFakeToken =
+          __DEV__ && (token === studentToken || token === mentorToken);
+        const validToken = isFakeToken
+          ? await fakeAuthGateway.validate(token)
+          : await authGateway.validate(token);
 
         if (validToken) {
-          // for now mock role
-          const role = 'student';
+          const decoded = decodeJWT(token);
+
+          if (
+            typeof decoded.id !== 'string' ||
+            typeof decoded.displayName !== 'string' ||
+            (decoded.role !== 'student' && decoded.role !== 'mentor')
+          ) {
+            throw new Error('Missing user claims');
+          }
+
           dispatch({
             type: 'authenticated',
-            user: mockUsers[role],
+            user: {
+              id: decoded.id,
+              displayName: decoded.displayName,
+              role: decoded.role,
+            },
           });
         } else {
           // token is invalid. Session state is expired
@@ -97,31 +121,51 @@ export function SessionProvider({ children }: PropsWithChildren) {
     } catch (error) {
       // Show an error state. Ask to refetch, since there may be a valid token.
       // Error is caused either by secure token get failing, or connection failure when validating.
-      const message =
-        error instanceof Error
-          ? error.message
-          : 'Failed to restore session. Please try again.';
-
-      dispatch({
-        type: 'launchError',
-        errorMessage: message,
-      });
+      if (error instanceof AppError && error.code === 'SESSION_EXPIRED') {
+        await expiredSession();
+      } else {
+        const message =
+          error instanceof AppError
+            ? error.message
+            : 'Failed to restore session. Please try again.';
+
+        dispatch({
+          type: 'error',
+          errorMessage: message,
+        });
+      }
     } finally {
       restoreRef.current = false;
     }
   }
 
-  function mockSignInAs(role: UserRole) {
+  async function mockSignInAs(role: UserRole) {
+    if (!__DEV__) return;
+
+    const token = await fakeAuthGateway.login(role, '');
+
+    const decoded = decodeJWT(token);
+
+    if (
+      typeof decoded.id !== 'string' ||
+      typeof decoded.displayName !== 'string' ||
+      (decoded.role !== 'student' && decoded.role !== 'mentor')
+    ) {
+      throw new Error('Missing user claims');
+    }
+
+    await tokenStore.setToken(token);
+
     dispatch({
       type: 'authenticated',
-      user: mockUsers[role],
+      user: {
+        id: decoded.id,
+        displayName: decoded.displayName,
+        role: decoded.role,
+      },
     });
   }
 
-  // This function will get called if there is a 401 response meaning the token is expired.
-  // Or if the token expired when the app was first launched
-  // use ref incase multiple 401 responses happens and expiredSession gets called multiple times.
-
   const expiringRef = useRef(false);
   async function expiredSession() {
     if (expiringRef.current) {
@@ -132,17 +176,21 @@ export function SessionProvider({ children }: PropsWithChildren) {
 
     // This ensures if deleteToken fails cancelQueries still gets called
     try {
-      await Promise.allSettled([
-        tokenStore.deleteToken(),
-        queryClient.cancelQueries(),
-      ]);
-
+      await queryClient.cancelQueries();
       queryClient.clear();
 
+      await tokenStore.deleteToken();
+
       dispatch({
         type: 'expired',
         expiredMessage: 'Your session has expired. Please sign in again.',
       });
+    } catch {
+      dispatch({
+        type: 'error',
+        errorMessage:
+          'Your session has expired, but we could not sign you out. Please sign out.',
+      });
     } finally {
       expiringRef.current = false;
     }
@@ -154,54 +202,63 @@ export function SessionProvider({ children }: PropsWithChildren) {
 
       if (!token) {
         // Empty token recieved
-        throw new Error('Invalid credentials. Please try again.');
+        throw new AppError(
+          'INVALID_RESPONSE',
+          'The server returned an invalid response.',
+        );
       }
 
-      // Validate token
-      const valid = await authGateway.validate(token);
+      const decoded = decodeJWT(token);
 
-      if (!valid) {
-        throw new Error('Invalid token. Please sign in again.');
+      if (
+        typeof decoded.id !== 'string' ||
+        typeof decoded.displayName !== 'string' ||
+        (decoded.role !== 'student' && decoded.role !== 'mentor')
+      ) {
+        throw new Error('Missing user claims');
       }
 
       await tokenStore.setToken(token);
 
-      // For now assume role until we're able to decode the token and get users role
-      const role = 'student';
-
       dispatch({
         type: 'authenticated',
-        user: mockUsers[role],
+        user: {
+          id: decoded.id,
+          displayName: decoded.displayName,
+          role: decoded.role,
+        },
       });
     } catch (error) {
-      const message =
-        error instanceof Error
-          ? error.message
-          : 'Sign in failed. Please try again.';
-      throw Error(message);
+      if (error instanceof AppError) {
+        throw error;
+      } else {
+        throw new AppError('UNKNOWN', 'Sign in failed. Please try again.');
+      }
     }
   }
 
   async function signOut() {
     try {
-      // delete the saved token
-      await tokenStore.deleteToken();
-
-      // cancel any on going queries and clear cache.
       await queryClient.cancelQueries();
       queryClient.clear();
 
-      // make the users sign out and their status anonymous
+      await authGateway.logout();
+
       dispatch({ type: 'signedOut' });
     } catch (error) {
-      const message =
-        error instanceof Error
-          ? error.message
-          : 'Sign out failed. Please try again.';
-      throw Error(message);
+      if (error instanceof AppError) {
+        throw error;
+      } else {
+        throw new AppError('UNKNOWN', 'Sign out failed. Please try again.');
+      }
     }
   }
 
+  // On launch check if a user has a valid session
+  useEffect(() => {
+    restoreSession();
+  }, []);
+
   return (
     <SessionContext.Provider
       value={{
diff --git a/src/types/authGateway.ts b/src/types/authGateway.ts
new file mode 100644
index 0000000..bf832e9
--- /dev/null
+++ b/src/types/authGateway.ts
@@ -0,0 +1,7 @@
+export interface AuthGateway {
+  login: (username: string, password: string) => Promise<string>;
+  logout: () => Promise<void>;
+  validate: (token: string) => Promise<boolean>;
+}
+
+export type LoginResponse = { token: string };
\ No newline at end of file

From 53e40128356750b48117d3340ade8f78de4beadb Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Sat, 10 Oct 2026 20:31:41 -0700
Subject: [PATCH 14/18] test(Authentication): Added authentication testing and
 modified existing testing

---
 test/SessionProvider.test.tsx    |  4 ++--
 test/authentication.test.tsx     |  2 +-
 test/fixtures/renderAnonymous.ts | 14 ++++++++++++++
 test/fixtures/studentToken.ts    |  2 ++
 test/navigation.test.tsx         | 12 +-----------
 5 files changed, 20 insertions(+), 14 deletions(-)
 create mode 100644 test/fixtures/renderAnonymous.ts
 create mode 100644 test/fixtures/studentToken.ts

diff --git a/test/SessionProvider.test.tsx b/test/SessionProvider.test.tsx
index 43a1c3a..8b43396 100644
--- a/test/SessionProvider.test.tsx
+++ b/test/SessionProvider.test.tsx
@@ -61,7 +61,7 @@ describe('SessionProvider', () => {
       }),
     );
 
-    expect(screen.getByText('authenticated')).toBeOnTheScreen();
+    expect(await screen.findByText('authenticated')).toBeOnTheScreen();
 
     expect(screen.getByText('student')).toBeOnTheScreen();
 
@@ -91,6 +91,6 @@ describe('SessionProvider', () => {
       }),
     );
 
-    expect(screen.getByText('mentor')).toBeOnTheScreen();
+    expect(await screen.findByText('mentor')).toBeOnTheScreen();
   });
 });
diff --git a/test/authentication.test.tsx b/test/authentication.test.tsx
index 1e0362b..22b9bb5 100644
--- a/test/authentication.test.tsx
+++ b/test/authentication.test.tsx
@@ -226,7 +226,7 @@ describe('authentication', () => {
 
     await screen.findByText('anonymous');
     fireEvent.press(screen.getByRole('button', { name: 'Mock student' }));
-    expect(screen.getByText('authenticated')).toBeOnTheScreen();
+    expect(await screen.findByText('authenticated')).toBeOnTheScreen();
     queryClient.setQueryData(privateKey, { name: 'Test Student' });
     expect(queryClient.getQueryData(privateKey)).toBeDefined();
     fireEvent.press(screen.getByRole('button', { name: 'Sign out' }));
diff --git a/test/fixtures/renderAnonymous.ts b/test/fixtures/renderAnonymous.ts
new file mode 100644
index 0000000..327697f
--- /dev/null
+++ b/test/fixtures/renderAnonymous.ts
@@ -0,0 +1,14 @@
+import { renderRouter, screen, waitFor } from 'expo-router/testing-library';
+import { tokenStore } from '@/services/storage/TokenStore';
+
+export async function renderAnonymous(initialUrl = '/') {
+  jest.spyOn(tokenStore, 'getToken').mockResolvedValue(null);
+
+  const renderedRouter = renderRouter('./app', { initialUrl });
+
+  await waitFor(() => {
+    expect(screen.getByText('Welcome back')).toBeOnTheScreen();
+  });
+
+  return renderedRouter;
+}
diff --git a/test/fixtures/studentToken.ts b/test/fixtures/studentToken.ts
new file mode 100644
index 0000000..c77377d
--- /dev/null
+++ b/test/fixtures/studentToken.ts
@@ -0,0 +1,2 @@
+export const studentToken =
+  'eyJ0eXAiOiJKV1QifQ.eyJpZCI6IjEyMyIsImRpc3BsYXlOYW1lIjoiVGVzdCBTdHVkZW50Iiwicm9sZSI6InN0dWRlbnQifQ.fake';
diff --git a/test/navigation.test.tsx b/test/navigation.test.tsx
index 6b9bd83..3a9cc70 100644
--- a/test/navigation.test.tsx
+++ b/test/navigation.test.tsx
@@ -7,17 +7,7 @@ import {
   waitFor,
 } from 'expo-router/testing-library';
 
-async function renderAnonymous(initialUrl = '/') {
-  const renderedRouter = renderRouter('./app', {
-    initialUrl,
-  });
-
-  await waitFor(() => {
-    expect(screen.getByText('Welcome back')).toBeOnTheScreen();
-  });
-
-  return renderedRouter;
-}
+import { renderAnonymous } from './fixtures/renderAnonymous';
 
 describe('session-aware navigation', () => {
   it('redirects an anonymous user away from a protected route', async () => {

From e6c9c1bdeda967edac1886f8bb60c6435d1cf160 Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Sat, 10 Oct 2026 20:34:15 -0700
Subject: [PATCH 15/18] feat(Authentication): AuthGateway connected to
 apiClient, JWT decoding, and TokenStore

---
 src/services/auth/AuthGateway.ts   | 56 ++++++++++++++++++++++++++++++
 src/services/auth/decodeJWT.ts     | 20 +++++++++++
 src/services/storage/TokenStore.ts | 34 ++++++++++++++++++
 src/state/session.ts               | 37 ++++++++++++--------
 4 files changed, 133 insertions(+), 14 deletions(-)
 create mode 100644 src/services/auth/AuthGateway.ts
 create mode 100644 src/services/auth/decodeJWT.ts
 create mode 100644 src/services/storage/TokenStore.ts

diff --git a/src/services/auth/AuthGateway.ts b/src/services/auth/AuthGateway.ts
new file mode 100644
index 0000000..ae4e4a0
--- /dev/null
+++ b/src/services/auth/AuthGateway.ts
@@ -0,0 +1,56 @@
+import { apiClient } from '@/services/api/apiClient';
+import { AppError } from '@/services/api/apiError';
+import type { ApiClientInterface } from '@/types/apiClient.types';
+import { tokenStore } from '../storage/TokenStore';
+import { AuthGateway, LoginResponse } from '@/types/authGateway';
+
+
+
+export function createAuthGateway(client: ApiClientInterface): AuthGateway {
+  return {
+    async login(username, password) {
+      try {
+        const response: LoginResponse | null = await client.post<LoginResponse>(
+          '/auth/login',
+          { username, password },
+        );
+
+        return response?.token ?? '';
+      } catch (error) {
+        throw error;
+      }
+    },
+
+    async logout() {
+      try {
+        await tokenStore.deleteToken();
+      } catch (error) {
+        if(error instanceof AppError) {
+          throw error;
+        }
+
+        throw new AppError('UNKNOWN', 'Sign out failed. Please try again.');
+      }
+    },
+
+    async validate(token) {
+      try {
+        await client.post<unknown, undefined>('/auth/validate', undefined, {
+          headers: { Authorization: `Bearer ${token}` },
+        });
+        return true;
+      } catch (error) {
+        if (
+          error instanceof AppError &&
+          error.code === 'SESSION_EXPIRED' &&
+          error.status === 401
+        ) {
+          return false;
+        }
+        throw error;
+      }
+    },
+  };
+}
+
+export const authGateway = createAuthGateway(apiClient);
diff --git a/src/services/auth/decodeJWT.ts b/src/services/auth/decodeJWT.ts
new file mode 100644
index 0000000..b2e8737
--- /dev/null
+++ b/src/services/auth/decodeJWT.ts
@@ -0,0 +1,20 @@
+export function decodeJWT(token: string): Record<string, unknown> {
+  const parts = token.split('.');
+  if (parts.length !== 3 || !parts[1]) throw new Error('Invalid JWT');
+
+  const base64 = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+  const bytes = atob(base64.padEnd(Math.ceil(base64.length / 4) * 4, '='));
+  const json = decodeURIComponent(
+    Array.from(
+      bytes,
+      (char) => `%${char.charCodeAt(0).toString(16).padStart(2, '0')}`,
+    ).join(''),
+  );
+  const payload: unknown = JSON.parse(json);
+
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    throw new Error('Invalid JWT payload');
+  }
+
+  return payload as Record<string, unknown>;
+}
diff --git a/src/services/storage/TokenStore.ts b/src/services/storage/TokenStore.ts
new file mode 100644
index 0000000..10026b3
--- /dev/null
+++ b/src/services/storage/TokenStore.ts
@@ -0,0 +1,34 @@
+import * as SecureStore from 'expo-secure-store';
+import { AppError } from '../api/apiError';
+
+const TOKEN_KEY = 'jwt-token';
+
+interface TokenStore {
+  getToken: () => Promise<string | null>;
+  setToken: (token: string) => Promise<void>;
+  deleteToken: () => Promise<void>;
+}
+
+export const tokenStore: TokenStore = {
+  async getToken() {
+    try {
+      return await SecureStore.getItemAsync(TOKEN_KEY);
+    } catch {
+      throw new AppError('UNKNOWN', 'Failed to get token please retry.');
+    }
+  },
+  async setToken(token: string) {
+    try {
+      await SecureStore.setItemAsync(TOKEN_KEY, token);
+    } catch {
+      throw new AppError('UNKNOWN', 'Failed to set token please try again.');
+    }
+  },
+  async deleteToken() {
+    try {
+      await SecureStore.deleteItemAsync(TOKEN_KEY);
+    } catch {
+      throw new AppError('UNKNOWN', 'Failed to delete token please try again.');
+    }
+  },
+};
diff --git a/src/state/session.ts b/src/state/session.ts
index 8e1f95f..6e59973 100644
--- a/src/state/session.ts
+++ b/src/state/session.ts
@@ -1,4 +1,4 @@
-import { readonly } from "zod";
+import { readonly } from 'zod';
 
 export type UserRole = 'student' | 'mentor';
 
@@ -19,11 +19,14 @@ export type SessionState =
       readonly status: 'authenticated';
       readonly user: SessionUser;
     }
-  |
-   {
+  | {
+      readonly status: 'expired';
+      readonly expiredMessage: string;
+    }
+  | {
       readonly status: 'error';
       readonly errorMessage: string;
-   };
+    }
 
 export type SessionAction =
   | {
@@ -40,13 +43,16 @@ export type SessionAction =
       readonly type: 'anonymous';
     }
   | {
-      readonly type: 'launchError';
+      readonly type: 'error';
       readonly errorMessage: string;
     }
   | {
-      readonly type: 'launchRestore';
+      readonly type: 'restore';
+    }
+  | {
+      readonly type: 'expired';
+      readonly expiredMessage: string;
     }
-  
 
 export const initialSessionState: SessionState = {
   status: 'bootstrapping',
@@ -66,15 +72,18 @@ export function sessionReducer(
       };
     case 'signedOut':
       return state.status === 'anonymous' ? state : { status: 'anonymous' };
-    case 'launchError':
-      return { 
-        status: 'error', 
-        errorMessage: action.errorMessage, 
-      };
     case 'anonymous':
       return { status: 'anonymous' };
-    case 'launchRestore':
-      return { status: 'bootstrapping'}
+    case 'expired':
+      return { status: 'expired', expiredMessage: action.expiredMessage };
+    case 'error':
+      return {
+        status: 'error',
+        errorMessage: action.errorMessage,
+      };
+    case 'restore':
+      return { status: 'bootstrapping' };
+
     default: {
       const exhaustiveAction: never = action;
       return exhaustiveAction;

From a1207de46aecfb3162116192d3bfa22920364b01 Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Sat, 10 Oct 2026 21:45:25 -0700
Subject: [PATCH 16/18] fix(Authentication): deleted secureStore and
 studentToken

---
 src/features/auth/secureStore.ts | 33 --------------------------------
 test/authentication.test.tsx     |  4 +++-
 test/fixtures/studentToken.ts    |  2 --
 3 files changed, 3 insertions(+), 36 deletions(-)
 delete mode 100644 src/features/auth/secureStore.ts
 delete mode 100644 test/fixtures/studentToken.ts

diff --git a/src/features/auth/secureStore.ts b/src/features/auth/secureStore.ts
deleted file mode 100644
index 575d90e..0000000
--- a/src/features/auth/secureStore.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import * as SecureStore from 'expo-secure-store';
-
-const TOKEN_KEY = 'jwt-token';
-
-interface TokenStore {
-    getToken: () => Promise<string | null>;
-    setToken: (token: string) => Promise<void>;
-    deleteToken: () => Promise<void>;
-}
-
- export const tokenStore: TokenStore = {
-    async getToken() {
-        try {
-            return await SecureStore.getItemAsync(TOKEN_KEY);
-        } catch {
-            throw Error("Failed to get token please retry.");
-        }
-    },
-    async setToken(token: string) {
-        try {
-            await SecureStore.setItemAsync(TOKEN_KEY, token);
-        } catch {
-            throw Error("Failed to set token please try again.")
-        }
-    },
-    async deleteToken() {
-        try {
-            await SecureStore.deleteItemAsync(TOKEN_KEY);
-        } catch {
-            throw Error("Failed to delete token please try again.")
-        }
-    }
-}
\ No newline at end of file
diff --git a/test/authentication.test.tsx b/test/authentication.test.tsx
index 22b9bb5..8f309fd 100644
--- a/test/authentication.test.tsx
+++ b/test/authentication.test.tsx
@@ -16,7 +16,9 @@ import { tokenStore } from '@/services/storage/TokenStore';
 import { createQueryClient } from '@/providers/QueryProvider';
 import { SessionProvider, useSession } from '@/providers/SessionProvider';
 import { renderAnonymous } from './fixtures/renderAnonymous';
-import { studentToken } from './fixtures/studentToken';
+
+const studentToken =
+  'eyJ0eXAiOiJKV1QifQ.eyJpZCI6IjEyMyIsImRpc3BsYXlOYW1lIjoiVGVzdCBTdHVkZW50Iiwicm9sZSI6InN0dWRlbnQifQ.fake';
 
 function submitSignIn(username: string, password: string) {
   fireEvent.changeText(screen.getByTestId('username-input'), username);
diff --git a/test/fixtures/studentToken.ts b/test/fixtures/studentToken.ts
deleted file mode 100644
index c77377d..0000000
--- a/test/fixtures/studentToken.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export const studentToken =
-  'eyJ0eXAiOiJKV1QifQ.eyJpZCI6IjEyMyIsImRpc3BsYXlOYW1lIjoiVGVzdCBTdHVkZW50Iiwicm9sZSI6InN0dWRlbnQifQ.fake';

From 9b9e3999f75cca5070f14abceb60bc4efc5ec2ab Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Sat, 10 Oct 2026 22:41:47 -0700
Subject: [PATCH 17/18] fix(Authentication): Fixed SessionUser to work with
 backedn and formating

---
 src/features/auth/components/error-screen.tsx |  2 +-
 src/providers/SessionProvider.tsx             | 98 ++++++++++---------
 src/services/auth/AuthGateway.ts              |  4 +-
 src/state/session.ts                          |  8 +-
 src/types/authGateway.ts                      |  2 +-
 test/authentication.test.tsx                  |  2 +-
 test/session.test.ts                          |  2 +-
 7 files changed, 59 insertions(+), 59 deletions(-)

diff --git a/src/features/auth/components/error-screen.tsx b/src/features/auth/components/error-screen.tsx
index 288e736..71a75d4 100644
--- a/src/features/auth/components/error-screen.tsx
+++ b/src/features/auth/components/error-screen.tsx
@@ -13,7 +13,7 @@ export default function ErrorScreen({
   return (
     <>
       <InlineError message={message} />
-      <Button onPress={restoreSession} >Retry</Button>
+      <Button onPress={restoreSession}>Retry</Button>
       <Button onPress={signOut}>Sign Out</Button>
     </>
   );
diff --git a/src/providers/SessionProvider.tsx b/src/providers/SessionProvider.tsx
index b0bdf32..fbb7d1c 100644
--- a/src/providers/SessionProvider.tsx
+++ b/src/providers/SessionProvider.tsx
@@ -1,6 +1,7 @@
 import {
   createContext,
   type PropsWithChildren,
+  useCallback,
   useContext,
   useEffect,
   useReducer,
@@ -32,10 +33,10 @@ type SessionContextValue = {
 };
 
 export const studentToken =
-  'eyJ0eXAiOiJKV1QifQ.eyJpZCI6Im1vY2stc3R1ZGVudCIsImRpc3BsYXlOYW1lIjoiTW9jayBTdHVkZW50Iiwicm9sZSI6InN0dWRlbnQifQ.fake';
+  'eyJ0eXAiOiJKV1QifQ.eyJ1c2VybmFtZSI6Im1vY2stc3R1ZGVudCIsImZpcnN0TmFtZSI6Ik1vY2siLCJsYXN0TmFtZSI6IlN0dWRlbnQiLCJyb2xlIjoic3R1ZGVudCJ9.fake';
 
 export const mentorToken =
-  'eyJ0eXAiOiJKV1QifQ.eyJpZCI6Im1vY2stbWVudG9yIiwiZGlzcGxheU5hbWUiOiJNb2NrIE1lbnRvciIsInJvbGUiOiJtZW50b3IifQ.fake';
+  'eyJ0eXAiOiJKV1QifQ.eyJ1c2VybmFtZSI6Im1vY2stbWVudG9yIiwiZmlyc3ROYW1lIjoiTW9jayIsImxhc3ROYW1lIjoiTWVudG9yIiwicm9sZSI6Im1lbnRvciJ9.fake';
 
 const fakeAuthGateway: AuthGateway = {
   async login(username) {
@@ -67,9 +68,39 @@ export function SessionProvider({ children }: PropsWithChildren) {
   // Used to clear cache when signing out.
   const queryClient = useQueryClient();
 
+  const expiringRef = useRef(false);
+  const expiredSession = useCallback(async () => {
+    if (expiringRef.current) {
+      return;
+    }
+
+    expiringRef.current = true;
+
+    // This ensures if deleteToken fails cancelQueries still gets called
+    try {
+      await queryClient.cancelQueries();
+      queryClient.clear();
+
+      await tokenStore.deleteToken();
+
+      dispatch({
+        type: 'expired',
+        expiredMessage: 'Your session has expired. Please sign in again.',
+      });
+    } catch {
+      dispatch({
+        type: 'error',
+        errorMessage:
+          'Your session has expired, but we could not sign you out. Please sign out.',
+      });
+    } finally {
+      expiringRef.current = false;
+    }
+  }, [queryClient]);
+
   const restoreRef = useRef(false);
 
-  async function restoreSession(): Promise<void> {
+  const restoreSession = useCallback(async (): Promise<void> => {
     // This prevents a user from pressing on the retry button multiple times.
     // Which will cause this function to run multiple times.
     if (restoreRef.current) {
@@ -95,8 +126,9 @@ export function SessionProvider({ children }: PropsWithChildren) {
           const decoded = decodeJWT(token);
 
           if (
-            typeof decoded.id !== 'string' ||
-            typeof decoded.displayName !== 'string' ||
+            typeof decoded.firstName !== 'string' ||
+            typeof decoded.lastName !== 'string' ||
+            typeof decoded.username !== 'string' ||
             (decoded.role !== 'student' && decoded.role !== 'mentor')
           ) {
             throw new Error('Missing user claims');
@@ -105,8 +137,8 @@ export function SessionProvider({ children }: PropsWithChildren) {
           dispatch({
             type: 'authenticated',
             user: {
-              id: decoded.id,
-              displayName: decoded.displayName,
+              username: decoded.username,
+              displayName: decoded.firstName + ' ' + decoded.lastName,
               role: decoded.role,
             },
           });
@@ -137,7 +169,7 @@ export function SessionProvider({ children }: PropsWithChildren) {
     } finally {
       restoreRef.current = false;
     }
-  }
+  }, [expiredSession]);
 
   async function mockSignInAs(role: UserRole) {
     if (!__DEV__) return;
@@ -147,8 +179,9 @@ export function SessionProvider({ children }: PropsWithChildren) {
     const decoded = decodeJWT(token);
 
     if (
-      typeof decoded.id !== 'string' ||
-      typeof decoded.displayName !== 'string' ||
+      typeof decoded.firstName !== 'string' ||
+      typeof decoded.lastName !== 'string' ||
+      typeof decoded.username !== 'string' ||
       (decoded.role !== 'student' && decoded.role !== 'mentor')
     ) {
       throw new Error('Missing user claims');
@@ -159,43 +192,13 @@ export function SessionProvider({ children }: PropsWithChildren) {
     dispatch({
       type: 'authenticated',
       user: {
-        id: decoded.id,
-        displayName: decoded.displayName,
+        username: decoded.username,
+        displayName: decoded.firstName + ' ' + decoded.lastName,
         role: decoded.role,
       },
     });
   }
 
-  const expiringRef = useRef(false);
-  async function expiredSession() {
-    if (expiringRef.current) {
-      return;
-    }
-
-    expiringRef.current = true;
-
-    // This ensures if deleteToken fails cancelQueries still gets called
-    try {
-      await queryClient.cancelQueries();
-      queryClient.clear();
-
-      await tokenStore.deleteToken();
-
-      dispatch({
-        type: 'expired',
-        expiredMessage: 'Your session has expired. Please sign in again.',
-      });
-    } catch {
-      dispatch({
-        type: 'error',
-        errorMessage:
-          'Your session has expired, but we could not sign you out. Please sign out.',
-      });
-    } finally {
-      expiringRef.current = false;
-    }
-  }
-
   async function signIn(username: string, password: string): Promise<void> {
     try {
       const token = await authGateway.login(username, password);
@@ -211,8 +214,9 @@ export function SessionProvider({ children }: PropsWithChildren) {
       const decoded = decodeJWT(token);
 
       if (
-        typeof decoded.id !== 'string' ||
-        typeof decoded.displayName !== 'string' ||
+        typeof decoded.firstName !== 'string' ||
+        typeof decoded.lastName !== 'string' ||
+        typeof decoded.username !== 'string' ||
         (decoded.role !== 'student' && decoded.role !== 'mentor')
       ) {
         throw new Error('Missing user claims');
@@ -223,8 +227,8 @@ export function SessionProvider({ children }: PropsWithChildren) {
       dispatch({
         type: 'authenticated',
         user: {
-          id: decoded.id,
-          displayName: decoded.displayName,
+          username: decoded.username,
+          displayName: decoded.firstName + ' ' + decoded.lastName,
           role: decoded.role,
         },
       });
@@ -257,7 +261,7 @@ export function SessionProvider({ children }: PropsWithChildren) {
   // On launch check if a user has a valid session
   useEffect(() => {
     restoreSession();
-  }, []);
+  }, [restoreSession]);
 
   return (
     <SessionContext.Provider
diff --git a/src/services/auth/AuthGateway.ts b/src/services/auth/AuthGateway.ts
index ae4e4a0..beaf196 100644
--- a/src/services/auth/AuthGateway.ts
+++ b/src/services/auth/AuthGateway.ts
@@ -4,8 +4,6 @@ import type { ApiClientInterface } from '@/types/apiClient.types';
 import { tokenStore } from '../storage/TokenStore';
 import { AuthGateway, LoginResponse } from '@/types/authGateway';
 
-
-
 export function createAuthGateway(client: ApiClientInterface): AuthGateway {
   return {
     async login(username, password) {
@@ -25,7 +23,7 @@ export function createAuthGateway(client: ApiClientInterface): AuthGateway {
       try {
         await tokenStore.deleteToken();
       } catch (error) {
-        if(error instanceof AppError) {
+        if (error instanceof AppError) {
           throw error;
         }
 
diff --git a/src/state/session.ts b/src/state/session.ts
index 6e59973..6787934 100644
--- a/src/state/session.ts
+++ b/src/state/session.ts
@@ -1,9 +1,7 @@
-import { readonly } from 'zod';
-
 export type UserRole = 'student' | 'mentor';
 
 export type SessionUser = {
-  readonly id: string;
+  readonly username: string;
   readonly displayName: string;
   readonly role: UserRole;
 };
@@ -26,7 +24,7 @@ export type SessionState =
   | {
       readonly status: 'error';
       readonly errorMessage: string;
-    }
+    };
 
 export type SessionAction =
   | {
@@ -52,7 +50,7 @@ export type SessionAction =
   | {
       readonly type: 'expired';
       readonly expiredMessage: string;
-    }
+    };
 
 export const initialSessionState: SessionState = {
   status: 'bootstrapping',
diff --git a/src/types/authGateway.ts b/src/types/authGateway.ts
index bf832e9..bcd7fcd 100644
--- a/src/types/authGateway.ts
+++ b/src/types/authGateway.ts
@@ -4,4 +4,4 @@ export interface AuthGateway {
   validate: (token: string) => Promise<boolean>;
 }
 
-export type LoginResponse = { token: string };
\ No newline at end of file
+export type LoginResponse = { token: string };
diff --git a/test/authentication.test.tsx b/test/authentication.test.tsx
index 8f309fd..fa808f0 100644
--- a/test/authentication.test.tsx
+++ b/test/authentication.test.tsx
@@ -18,7 +18,7 @@ import { SessionProvider, useSession } from '@/providers/SessionProvider';
 import { renderAnonymous } from './fixtures/renderAnonymous';
 
 const studentToken =
-  'eyJ0eXAiOiJKV1QifQ.eyJpZCI6IjEyMyIsImRpc3BsYXlOYW1lIjoiVGVzdCBTdHVkZW50Iiwicm9sZSI6InN0dWRlbnQifQ.fake';
+  'eyJ0eXAiOiJKV1QifQ.eyJ1c2VybmFtZSI6InRlc3Qtc3R1ZGVudCIsImZpcnN0TmFtZSI6IlRlc3QiLCJsYXN0TmFtZSI6IlN0dWRlbnQiLCJyb2xlIjoic3R1ZGVudCJ9.fake';
 
 function submitSignIn(username: string, password: string) {
   fireEvent.changeText(screen.getByTestId('username-input'), username);
diff --git a/test/session.test.ts b/test/session.test.ts
index f600561..2d8669a 100644
--- a/test/session.test.ts
+++ b/test/session.test.ts
@@ -5,7 +5,7 @@ import {
 } from '@/state/session';
 
 const student: SessionUser = {
-  id: 'test-student',
+  username: 'test-student',
   displayName: 'Test Student',
   role: 'student',
 };

From ef3f039fc16356620bfb3c331296c0b54e05edbd Mon Sep 17 00:00:00 2001
From: diego31anaya <diego31anaya@gmail.com>
Date: Sun, 11 Oct 2026 10:41:45 -0700
Subject: [PATCH 18/18] fix(Authentication): Added fakeApiClient to
 AuthGateway.ts and temporary AppErro to TokenStore.ts until API is merged.
 Other files updated their imports to these 2 for now.

---
 app/(app)/(tabs)/profile.tsx       |  3 +-
 app/(public)/sign-in.tsx           |  3 +-
 src/providers/SessionProvider.tsx  | 16 +++++-----
 src/services/auth/AuthGateway.ts   | 49 ++++++++++++++++++++++++++----
 src/services/storage/TokenStore.ts | 23 +++++++++++++-
 test/authentication.test.tsx       |  3 +-
 6 files changed, 78 insertions(+), 19 deletions(-)

diff --git a/app/(app)/(tabs)/profile.tsx b/app/(app)/(tabs)/profile.tsx
index 18116ec..c008fc7 100644
--- a/app/(app)/(tabs)/profile.tsx
+++ b/app/(app)/(tabs)/profile.tsx
@@ -17,9 +17,10 @@ import {
 import { useSession } from '@/providers/SessionProvider';
 import { useState } from 'react';
 import { InlineError } from '@/components/feedback/InlineError';
-import { AppError } from '@/services/api/apiError';
 import { ConnectionBanner } from '@/components/feedback/ConnectionBanner';
 import { Spinner } from '@/components/ui/Spinner';
+// Temporary AppError import until API is merged
+import { AppError } from '@/services/storage/TokenStore';
 
 type Badge = {
   id: string;
diff --git a/app/(public)/sign-in.tsx b/app/(public)/sign-in.tsx
index bdb7d36..a5584aa 100644
--- a/app/(public)/sign-in.tsx
+++ b/app/(public)/sign-in.tsx
@@ -32,7 +32,8 @@ import { Spinner } from '@/components/ui/Spinner';
 import { InlineError } from '@/components/feedback/InlineError';
 import { ConnectionBanner } from '@/components/feedback/ConnectionBanner';
 import { isNonEmptyString } from '@/utils/isNonEmptyString';
-import { AppError } from '@/services/api/apiError';
+// Temporary AppError import until API is merged
+import { AppError } from '@/services/storage/TokenStore';
 
 const chessPiecePattern = require('@/assets/images/chess-piece-pattern.png');
 
diff --git a/src/providers/SessionProvider.tsx b/src/providers/SessionProvider.tsx
index fbb7d1c..100a672 100644
--- a/src/providers/SessionProvider.tsx
+++ b/src/providers/SessionProvider.tsx
@@ -15,11 +15,15 @@ import {
   type UserRole,
 } from '@/state/session';
 
-import { tokenStore } from '@/services/storage/TokenStore';
+// Temporary AppError import until API is merged
+import { AppError, tokenStore } from '@/services/storage/TokenStore';
 
 import { useQueryClient } from '@tanstack/react-query';
-import { authGateway } from '@/services/auth/AuthGateway';
-import { AppError } from '@/services/api/apiError';
+import {
+  authGateway,
+  studentToken,
+  mentorToken,
+} from '@/services/auth/AuthGateway';
 import { decodeJWT } from '@/services/auth/decodeJWT';
 import type { AuthGateway } from '@/types/authGateway';
 
@@ -32,12 +36,6 @@ type SessionContextValue = {
   restoreSession: () => Promise<void>;
 };
 
-export const studentToken =
-  'eyJ0eXAiOiJKV1QifQ.eyJ1c2VybmFtZSI6Im1vY2stc3R1ZGVudCIsImZpcnN0TmFtZSI6Ik1vY2siLCJsYXN0TmFtZSI6IlN0dWRlbnQiLCJyb2xlIjoic3R1ZGVudCJ9.fake';
-
-export const mentorToken =
-  'eyJ0eXAiOiJKV1QifQ.eyJ1c2VybmFtZSI6Im1vY2stbWVudG9yIiwiZmlyc3ROYW1lIjoiTW9jayIsImxhc3ROYW1lIjoiTWVudG9yIiwicm9sZSI6Im1lbnRvciJ9.fake';
-
 const fakeAuthGateway: AuthGateway = {
   async login(username) {
     if (username === 'student') return studentToken;
diff --git a/src/services/auth/AuthGateway.ts b/src/services/auth/AuthGateway.ts
index beaf196..4858a16 100644
--- a/src/services/auth/AuthGateway.ts
+++ b/src/services/auth/AuthGateway.ts
@@ -1,10 +1,47 @@
-import { apiClient } from '@/services/api/apiClient';
-import { AppError } from '@/services/api/apiError';
-import type { ApiClientInterface } from '@/types/apiClient.types';
-import { tokenStore } from '../storage/TokenStore';
+// Temporary AppError import until API is merged
+import { AppError, tokenStore } from '../storage/TokenStore';
 import { AuthGateway, LoginResponse } from '@/types/authGateway';
 
-export function createAuthGateway(client: ApiClientInterface): AuthGateway {
+export const studentToken =
+  'eyJ0eXAiOiJKV1QifQ.eyJ1c2VybmFtZSI6Im1vY2stc3R1ZGVudCIsImZpcnN0TmFtZSI6Ik1vY2siLCJsYXN0TmFtZSI6IlN0dWRlbnQiLCJyb2xlIjoic3R1ZGVudCJ9.fake';
+
+export const mentorToken =
+  'eyJ0eXAiOiJKV1QifQ.eyJ1c2VybmFtZSI6Im1vY2stbWVudG9yIiwiZmlyc3ROYW1lIjoiTW9jayIsImxhc3ROYW1lIjoiTWVudG9yIiwicm9sZSI6Im1lbnRvciJ9.fake';
+
+// Fake apiClient until Brandons API client is merged.
+export const fakeApiClient = {
+  async post<T, B = unknown>(
+    endpoint: string,
+    body: B,
+    options?: { headers?: Record<string, string> },
+  ): Promise<T | null> {
+    if (!__DEV__) {
+      throw new AppError('UNKNOWN', 'Sign in is unavailable.');
+    }
+
+    if (endpoint === '/auth/login') {
+      const username = (body as { username?: string })?.username;
+      if (username === 'student') return { token: studentToken } as T;
+      if (username === 'mentor') return { token: mentorToken } as T;
+      throw new AppError('UNKNOWN', 'Invalid username or password.');
+    }
+
+    if (endpoint === '/auth/validate') {
+      const bearer = options?.headers?.Authorization;
+      if (
+        bearer === `Bearer ${studentToken}` ||
+        bearer === `Bearer ${mentorToken}`
+      ) {
+        return null; // Successful 200 with no response body
+      }
+      throw new AppError('SESSION_EXPIRED', 'Your session has expired.', 401);
+    }
+
+    throw new AppError('UNKNOWN', 'Unsupported authentication request.');
+  },
+};
+
+export function createAuthGateway(client: typeof fakeApiClient): AuthGateway {
   return {
     async login(username, password) {
       try {
@@ -51,4 +88,4 @@ export function createAuthGateway(client: ApiClientInterface): AuthGateway {
   };
 }
 
-export const authGateway = createAuthGateway(apiClient);
+export const authGateway = createAuthGateway(fakeApiClient);
diff --git a/src/services/storage/TokenStore.ts b/src/services/storage/TokenStore.ts
index 10026b3..5bc1ef0 100644
--- a/src/services/storage/TokenStore.ts
+++ b/src/services/storage/TokenStore.ts
@@ -1,5 +1,26 @@
 import * as SecureStore from 'expo-secure-store';
-import { AppError } from '../api/apiError';
+
+// Temporary AppError decloration here until Brandons API code is merged.
+export type AppErrorCode =
+  | 'NETWORK_ERROR'
+  | 'REQUEST_TIMEOUT'
+  | 'REQUEST_CANCEL'
+  | 'INVALID_RESPONSE'
+  | 'SESSION_EXPIRED'
+  | 'PERMISSION_DENIED'
+  | 'SERVER_ERROR'
+  | 'UNKNOWN';
+
+export class AppError extends Error {
+  constructor(
+    public readonly code: AppErrorCode,
+    message: string,
+    public readonly status?: number, // Pass in response.status
+  ) {
+    super(message);
+    this.name = 'AppError';
+  }
+}
 
 const TOKEN_KEY = 'jwt-token';
 
diff --git a/test/authentication.test.tsx b/test/authentication.test.tsx
index fa808f0..f9dd67a 100644
--- a/test/authentication.test.tsx
+++ b/test/authentication.test.tsx
@@ -10,12 +10,13 @@ import { render } from '@testing-library/react-native';
 import { QueryClientProvider } from '@tanstack/react-query';
 import { Button, Text, View } from 'react-native';
 
-import { AppError } from '@/services/api/apiError';
 import { authGateway } from '@/services/auth/AuthGateway';
 import { tokenStore } from '@/services/storage/TokenStore';
 import { createQueryClient } from '@/providers/QueryProvider';
 import { SessionProvider, useSession } from '@/providers/SessionProvider';
 import { renderAnonymous } from './fixtures/renderAnonymous';
+// Temporary AppError import until API is merged
+import { AppError } from '@/services/storage/TokenStore';
 
 const studentToken =
   'eyJ0eXAiOiJKV1QifQ.eyJ1c2VybmFtZSI6InRlc3Qtc3R1ZGVudCIsImZpcnN0TmFtZSI6IlRlc3QiLCJsYXN0TmFtZSI6IlN0dWRlbnQiLCJyb2xlIjoic3R1ZGVudCJ9.fake';