From d6685f156df03b277e812d3ede2d278801c2b9cc Mon Sep 17 00:00:00 2001
From: shafi54 <108669266+shafi-aviz@users.noreply.github.com>
Date: Sun, 25 Oct 2026 21:35:38 +0530
Subject: [PATCH] enh
---
apps/user-ui/JEST-TEST-CASES.md | 11 ++-
apps/user-ui/app/(drawer)/_layout.tsx | 2 +-
apps/user-ui/src/contexts/AuthContext.tsx | 88 ++++++++++-------
apps/user-ui/src/hooks/useRegion.ts | 30 ++++--
apps/user-ui/src/lib/region-cache.ts | 44 +++++++++
apps/user-ui/src/store/regionStore.ts | 73 +++++++++++---
apps/user-ui/src/trpc-client.ts | 10 +-
apps/user-ui/tests/app/layouts.test.tsx | 4 +-
apps/user-ui/tests/helpers/reset.ts | 4 +
apps/user-ui/tests/lib/auth.test.tsx | 49 +++++++--
apps/user-ui/tests/lib/route-network.test.tsx | 15 +++
apps/user-ui/tests/lib/use-region.test.tsx | 49 +++++++++
apps/web-ui/src/lib/auth-context.tsx | 35 ++++++-
apps/web-ui/src/lib/trpc-client.ts | 29 ++++++
change-log.txt | 99 +++++++++++++++++++
15 files changed, 460 insertions(+), 82 deletions(-)
diff --git a/apps/user-ui/JEST-TEST-CASES.md b/apps/user-ui/JEST-TEST-CASES.md
index e907193..9b7df3d 100644
--- a/apps/user-ui/JEST-TEST-CASES.md
+++ b/apps/user-ui/JEST-TEST-CASES.md
@@ -154,7 +154,7 @@ Use these names in the cases below so the expected values stay consistent.
| APP-03 | edge | auth settled, signed out | still redirects home; auth walls are per-page |
| APP-04 | edge | auth layout loading | spinner, no stack |
| APP-05 | happy | auth layout loaded | auth stack renders |
-| APP-06 | edge | drawer layout loading | pink loading spinner |
+| APP-06 | edge | drawer layout loading | brand loading spinner (visible on white) |
| APP-07 | happy | drawer layout loaded | five tabs: Home, Offers, center 1 Hr Delivery, Stores, Me |
| APP-08 | edge | `hideTabsNav` has one true key | tab bar style is `display: none` |
| APP-09 | edge | all hide keys false | tab bar visible |
@@ -1498,6 +1498,8 @@ Covered by HOME-81..98, plus:
| REGION-29 | edge | live resolution differs from cache | region/bound switch to the live answer |
| REGION-30 | edge | live resolution succeeds | persisted to StorageServiceCasual |
| REGION-31 | edge | live resolution null, region adopted from cache | region cleared for the chooser |
+| REGION-32 | edge | persisted region/bound in SecureStore | hydrates before the launch decision; no “Finding your region” spinner |
+| REGION-33 | edge | setRegion / clearRegion | selection persisted / removed from SecureStore |
| LOCSTORE-01 | happy | start once | one permission/fix; second start no-op |
| LOCSTORE-02 | error | denied | status denied, coords null |
| LOCSTORE-03 | edge | services off | status services-off |
@@ -1513,9 +1515,9 @@ Covered by HOME-81..98, plus:
| ID | Type | Case and setup | Assertion |
| --- | --- | --- | --- |
| AUTH-01 | edge | no token/userId | signed out, not loading |
-| AUTH-02 | edge | token+userId | authenticated, loading until getSelfData |
+| AUTH-02 | edge | token+userId | authenticated and not loading (no block on getSelfData) |
| AUTH-03 | happy | selfData | user/userDetails populated |
-| AUTH-04 | error | getSelfData fails | signed out; `deleteAuthToken` not called (current) |
+| AUTH-04 | error | getSelfData UNAUTHORIZED | full logout; token removed |
| AUTH-05 | happy | loginWithToken | token/userId saved; authenticated; redirect handler |
| AUTH-06 | error | save token fails | loading false; throws |
| AUTH-07 | happy | login | login mutation, token save, refetch |
@@ -1529,6 +1531,8 @@ Covered by HOME-81..98, plus:
| AUTH-15 | edge | redirect older than 24h | replace `/` |
| AUTH-16 | edge | no redirect state | `router.back()` |
| AUTH-17 | edge | corrupt redirect JSON | replace `/` |
+| AUTH-18 | error | getSelfData fails (offline/5xx) | trusted session kept; token kept |
+| AUTH-19 | edge | FORCE_LOGOUT_EVENT (401 from any endpoint) | session cleared; token removed |
| ROUTE-01 | edge | useAuthenticatedRoute loading | no redirect |
| ROUTE-02 | edge | authenticated | no redirect |
| ROUTE-03 | edge | unauthenticated | stores target/query/timestamp; push login |
@@ -1542,6 +1546,7 @@ Covered by HOME-81..98, plus:
| TRPC-04 | edge | headers | bearer token when present |
| TRPC-05 | edge | timeout | aborts request |
| TRPC-06 | edge | upstream abort | forwarded |
+| TRPC-07 | edge | 401 tRPC envelope (`error.data.code`) | emits force-logout |
| HIDE-01 | edge | focus with key | hideTabsNav key true |
| HIDE-02 | edge | default key | `default` |
| HIDE-03 | edge | blur | false |
diff --git a/apps/user-ui/app/(drawer)/_layout.tsx b/apps/user-ui/app/(drawer)/_layout.tsx
index 3b3fc9c..17b3080 100755
--- a/apps/user-ui/app/(drawer)/_layout.tsx
+++ b/apps/user-ui/app/(drawer)/_layout.tsx
@@ -27,7 +27,7 @@ export default function Layout() {
if (isLoading) {
return (
-
+
);
}
diff --git a/apps/user-ui/src/contexts/AuthContext.tsx b/apps/user-ui/src/contexts/AuthContext.tsx
index 7f230ba..904af4d 100644
--- a/apps/user-ui/src/contexts/AuthContext.tsx
+++ b/apps/user-ui/src/contexts/AuthContext.tsx
@@ -1,15 +1,28 @@
-import React, { createContext, useContext, useState, useEffect } from 'react';
+import React, { createContext, useContext, useState, useEffect, useCallback } from 'react';
import { getAuthToken, saveAuthToken, deleteAuthToken, saveUserId, getUserId } from '../../hooks/useJWT';
import { getCurrentUserId } from '@/utils/getCurrentUserId';
import { useRegister } from '@/src/api-hooks/auth.api';
import { AuthState, AuthContextType, LoginCredentials, RegisterData, User, UserDetails } from '@/src/types/auth';
import { trpc } from '@/src/trpc-client';
import { StorageServiceCasual } from 'common-ui';
+import { FORCE_LOGOUT_EVENT } from 'common-ui/src/lib/const-strs';
import { useQueryClient } from '@tanstack/react-query';
import { useRouter } from 'expo-router';
+import { DeviceEventEmitter } from 'react-native';
import constants from '@/src/constants';
import type { AuthRedirectOptions, ReactParentComponent } from '@packages/shared';
+/**
+ * Only a credential rejection proves the stored token is dead. Offline, a
+ * timeout or a 5xx must never sign the user out: the stored credentials are
+ * trusted until the backend actually says no.
+ */
+const isCredentialError = (error: unknown): boolean => {
+ const trpcError = error as { data?: { code?: string }; shape?: { data?: { code?: string } } } | null;
+ const code = trpcError?.data?.code ?? trpcError?.shape?.data?.code;
+ return code === 'UNAUTHORIZED' || code === 'FORBIDDEN';
+};
+
export interface RedirectState extends AuthRedirectOptions {
targetUrl: string;
queryParams: Record;
@@ -33,6 +46,23 @@ export const AuthProvider: React.FC = ({ children }) => {
const loginMutation = trpc.user.auth.login.useMutation();
const registerMutation = useRegister();
+ // Drop the session everywhere: stored token, cached queries and state.
+ const clearSession = useCallback(async (): Promise => {
+ try {
+ await deleteAuthToken();
+ } catch {
+ // Still clear local state even if deleting the token fails.
+ }
+ queryClient.clear();
+ setAuthState({
+ user: null,
+ userDetails: null,
+ isAuthenticated: false,
+ isLoading: false,
+ token: null,
+ });
+ }, [queryClient]);
+
// Initialize auth state on app startup
useEffect(() => {
const initializeAuth = async () => {
@@ -41,7 +71,8 @@ export const AuthProvider: React.FC = ({ children }) => {
const userId = await getCurrentUserId();
if (token && userId) {
- // Use existing token, only fetch user data
+ // Trust the stored credentials: render the app now and let the
+ // background getSelfData read confirm (or reject) them.
setAuthState({
user: {
id: userId,
@@ -53,7 +84,7 @@ export const AuthProvider: React.FC = ({ children }) => {
},
userDetails: null,
isAuthenticated: true,
- isLoading: true, // Keep loading while fetching user data
+ isLoading: false,
token,
});
} else {
@@ -102,18 +133,22 @@ export const AuthProvider: React.FC = ({ children }) => {
userDetails: user,
isLoading: false,
}));
- } else if (selfDataError && authState.isAuthenticated) {
- // If token is invalid, clear auth state
- // deleteAuthToken();
- setAuthState({
- user: null,
- userDetails: null,
- isAuthenticated: false,
- isLoading: false,
- token: null,
- });
+ } else if (selfDataError && authState.isAuthenticated && isCredentialError(selfDataError)) {
+ // The backend rejected the stored token: drop the session.
+ void clearSession();
}
- }, [selfData, selfDataError, authState.isAuthenticated]);
+ // Any other failure (offline, timeout, 5xx) keeps the trusted session; the
+ // screen that needs the data shows its own error/retry.
+ }, [selfData, selfDataError, authState.isAuthenticated, clearSession]);
+
+ // src/trpc-client.ts emits this whenever the API answers 401 UNAUTHORIZED, so
+ // a revoked token is dropped even when the failing call is not getSelfData.
+ useEffect(() => {
+ const subscription = DeviceEventEmitter.addListener(FORCE_LOGOUT_EVENT, () => {
+ void clearSession();
+ });
+ return () => subscription.remove();
+ }, [clearSession]);
// Helper function to handle redirect after successful login
const handlePostLoginRedirect = async () => {
@@ -257,29 +292,8 @@ export const AuthProvider: React.FC = ({ children }) => {
}
};
- const logout = async (): Promise => {
- try {
- await deleteAuthToken();
- queryClient.clear();
- setAuthState({
- user: null,
- userDetails: null,
- isAuthenticated: false,
- isLoading: false,
- token: null,
- });
- } catch (error) {
- // Still clear local state even if deleteJWT fails
- queryClient.clear();
- setAuthState({
- user: null,
- userDetails: null,
- isAuthenticated: false,
- isLoading: false,
- token: null,
- });
- }
- };
+ // Manual logout and forced logout (rejected credentials) are the same thing.
+ const logout = clearSession;
const updateUser = (userData: Partial): void => {
setAuthState(prev => ({
diff --git a/apps/user-ui/src/hooks/useRegion.ts b/apps/user-ui/src/hooks/useRegion.ts
index 31365f1..47e5657 100644
--- a/apps/user-ui/src/hooks/useRegion.ts
+++ b/apps/user-ui/src/hooks/useRegion.ts
@@ -67,7 +67,7 @@ export interface UseRegionResult {
bound: RegionBoundSummary | null
/** Monotonic marker bumped on every region change; use it to ignore stale responses. */
regionGeneration: number
- /** Always true: the region store is in-memory (not persisted). */
+ /** True once the persisted region/bound has been read (or found empty). */
hydrated: boolean
/** Latest device coordinates, if the launch fix succeeded. */
coords: { latitude: number; longitude: number } | null
@@ -107,15 +107,22 @@ export function useRegion(): UseRegionResult {
const regionGeneration = useRegionStore((state) => state.regionGeneration)
const setRegion = useRegionStore((state) => state.setRegion)
const clearRegion = useRegionStore((state) => state.clearRegion)
+ // The persisted selection hydrates asynchronously (SecureStore). Until it has
+ // been read the gate keeps its neutral spinner, so a warm launch paints with
+ // the previous region instead of "Finding your region".
+ const hydrated = useRegionStore((state) => state.hydrated)
+ const hydrate = useRegionStore((state) => state.hydrate)
const coords = useLocationStore((state) => state.coords)
const locationStatus = useLocationStore((state) => state.status)
const startTracking = useLocationStore((state) => state.start)
const refreshTracking = useLocationStore((state) => state.refresh)
- // The region store is in-memory (not persisted), so there is nothing to
- // hydrate before we can decide.
- const hydrated = true
+ // Every consumer calls this; the store makes it single-flight.
+ useEffect(() => {
+ void hydrate()
+ }, [hydrate])
+
// True once the launch location check has a definitive outcome.
const [startupResolved, setStartupResolved] = useState(false)
@@ -267,13 +274,20 @@ export function useRegion(): UseRegionResult {
const boundId = storedBoundId ?? activeBoundId
- // Take the single launch fix — even when a region is already saved, so a
- // device that has moved to another region is detected on startup.
+ // Take the single launch fix immediately — even when a region is already
+ // saved, so a device that has moved to another region is detected on startup.
+ // It runs in parallel with the SecureStore read.
+ useEffect(() => {
+ startTracking()
+ }, [startTracking])
+
+ // The launch baseline is the region the app opened with. It is recorded only
+ // after hydration, so a restored selection counts as launch state (and may be
+ // switched by the decision) rather than as a manual pick.
useEffect(() => {
if (!hydrated) return
if (startupLaunchRegionId === undefined) startupLaunchRegionId = regionId
- startTracking()
- }, [hydrated, regionId, startTracking])
+ }, [hydrated, regionId])
// Stable, rounded input so GPS jitter doesn't churn the query key.
const lat = coords ? Math.round(coords.latitude * 1e5) / 1e5 : 0
diff --git a/apps/user-ui/src/lib/region-cache.ts b/apps/user-ui/src/lib/region-cache.ts
index 43ad04f..ddc22b4 100644
--- a/apps/user-ui/src/lib/region-cache.ts
+++ b/apps/user-ui/src/lib/region-cache.ts
@@ -32,6 +32,18 @@ export interface CachedLocationResolution {
result: ResolvedRegion | null
}
+/**
+ * The browsing region + bound selected at the end of the last session. Hydrated
+ * before the first paint so startup can render the app and read the regional
+ * CDN files immediately; the launch decision still re-resolves the location and
+ * corrects (or clears) this selection when the device/address says otherwise.
+ */
+export interface CachedRegionSelection {
+ regionId: number
+ region: RegionSummary
+ boundId: number | null
+}
+
/**
* Small, user-scoped snapshots of the responses that decide where the app
* starts:
@@ -45,11 +57,13 @@ export interface CachedLocationResolution {
// SecureStore only accepts alphanumeric, ".", "-" and "_" in keys.
export const REGION_LIST_CACHE_KEY = 'region_cache.list_regions.v1'
export const LOCATION_RESOLUTION_CACHE_KEY = 'region_cache.location_resolution.v1'
+export const REGION_SELECTION_CACHE_KEY = 'region_cache.selection.v1'
export const userAddressesCacheKey = (userId: number) =>
`region_cache.user_addresses.v1.${userId}`
let lastWrittenRegions: string | null = null
let lastWrittenResolution: string | null = null
+let lastWrittenSelection: string | null = null
const lastWrittenAddresses = new Map()
function parseJson(raw: string | null): unknown {
@@ -150,3 +164,33 @@ export async function writeCachedLocationResolution(
const stored = await StorageServiceCasual.setItem(LOCATION_RESOLUTION_CACHE_KEY, serialized)
if (stored) lastWrittenResolution = serialized
}
+
+function isCachedRegionSelection(value: unknown): value is CachedRegionSelection {
+ if (value == null || typeof value !== 'object') return false
+ const candidate = value as Partial
+ if (typeof candidate.regionId !== 'number') return false
+ const region = candidate.region as Partial | undefined
+ if (region == null || typeof region !== 'object') return false
+ if (region.id !== candidate.regionId || typeof region.name !== 'string') return false
+ if (candidate.boundId !== null && !isFiniteNumber(candidate.boundId)) return false
+ return true
+}
+
+export async function readCachedRegionSelection(): Promise {
+ const parsed = parseJson(await StorageServiceCasual.getItem(REGION_SELECTION_CACHE_KEY))
+ return isCachedRegionSelection(parsed) ? parsed : null
+}
+
+export async function writeCachedRegionSelection(
+ selection: CachedRegionSelection
+): Promise {
+ const serialized = JSON.stringify(selection)
+ if (serialized === lastWrittenSelection) return
+ const stored = await StorageServiceCasual.setItem(REGION_SELECTION_CACHE_KEY, serialized)
+ if (stored) lastWrittenSelection = serialized
+}
+
+export async function clearCachedRegionSelection(): Promise {
+ lastWrittenSelection = null
+ await StorageServiceCasual.removeItem(REGION_SELECTION_CACHE_KEY)
+}
diff --git a/apps/user-ui/src/store/regionStore.ts b/apps/user-ui/src/store/regionStore.ts
index 749ca36..843bd3c 100644
--- a/apps/user-ui/src/store/regionStore.ts
+++ b/apps/user-ui/src/store/regionStore.ts
@@ -1,14 +1,19 @@
import { create } from 'zustand'
import type { RegionSummary } from '@packages/shared'
+import {
+ clearCachedRegionSelection,
+ readCachedRegionSelection,
+ writeCachedRegionSelection,
+} from '@/src/lib/region-cache'
// Browsing region — the region the user is currently shopping in.
//
-// Deliberately NOT persisted: at each launch the region is re-derived from the
-// device location, or from the user's default / chosen address. A persisted
-// region would let the app show a stale region (e.g. the last one) whenever the
-// location is unavailable, instead of asking the user to grant location or add
-// an address. `regionGeneration` is a monotonic marker bumped on every change so
-// stale regional responses can be ignored.
+// The selection (region + bound) is persisted so a launch can render the app
+// and start the regional CDN reads without waiting for the device fix, auth or
+// the network. It is NOT trusted blindly: `useRegion` still resolves the launch
+// location / default address and switches (or clears) the region when the live
+// answer differs. `regionGeneration` is a monotonic marker bumped on every real
+// change so stale regional responses can be ignored.
interface RegionStore {
selectedRegionId: number | null
selectedRegion: RegionSummary | null
@@ -19,16 +24,50 @@ interface RegionStore {
*/
selectedBoundId: number | null
regionGeneration: number
+ /** True once the persisted selection has been read (or found empty). */
+ hydrated: boolean
+ /**
+ * Read the persisted selection once. Idempotent and safe to call from every
+ * consumer; `hydrated` flips even when there is nothing stored.
+ */
+ hydrate: () => Promise
setRegion: (region: RegionSummary, boundId?: number | null) => void
clearRegion: () => void
}
-export const useRegionStore = create((set) => ({
+// Single-flight: useRegion is consumed by several components and they all call
+// hydrate() on mount.
+let hydration: Promise | null = null
+
+export const useRegionStore = create((set, get) => ({
selectedRegionId: null,
selectedRegion: null,
selectedBoundId: null,
regionGeneration: 0,
- setRegion: (region, boundId = null) =>
+ hydrated: false,
+
+ hydrate: () => {
+ if (hydration) return hydration
+ hydration = (async () => {
+ try {
+ const cached = await readCachedRegionSelection()
+ // A region chosen while the read was in flight wins.
+ if (cached && get().selectedRegionId == null) {
+ set({
+ selectedRegionId: cached.regionId,
+ selectedRegion: cached.region,
+ selectedBoundId: cached.boundId,
+ })
+ }
+ } finally {
+ set({ hydrated: true })
+ }
+ })()
+ return hydration
+ },
+
+ setRegion: (region, boundId = null) => {
+ let changed = false
set((state) => {
// No-op when nothing actually changed: keeps regionGeneration stable
// and prevents effect loops that re-apply the same region.
@@ -40,14 +79,21 @@ export const useRegionStore = create((set) => ({
) {
return state
}
+ changed = true
return {
selectedRegionId: region.id,
selectedRegion: region,
selectedBoundId: boundId,
regionGeneration: state.regionGeneration + 1,
}
- }),
- clearRegion: () =>
+ })
+ if (changed) {
+ void writeCachedRegionSelection({ regionId: region.id, region, boundId })
+ }
+ },
+
+ clearRegion: () => {
+ let changed = false
set((state) => {
if (
state.selectedRegionId == null &&
@@ -56,11 +102,16 @@ export const useRegionStore = create((set) => ({
) {
return state
}
+ changed = true
return {
selectedRegionId: null,
selectedRegion: null,
selectedBoundId: null,
regionGeneration: state.regionGeneration + 1,
}
- }),
+ })
+ if (changed) {
+ void clearCachedRegionSelection()
+ }
+ },
}))
diff --git a/apps/user-ui/src/trpc-client.ts b/apps/user-ui/src/trpc-client.ts
index 30949f0..e83cb41 100644
--- a/apps/user-ui/src/trpc-client.ts
+++ b/apps/user-ui/src/trpc-client.ts
@@ -40,11 +40,11 @@ export const trpcClient = createTRPCProxyClient({
const data = await response
.clone()
.json()
- .catch(() => ({}));
- let code = "";
- if (data[0]?.error || data?.error) {
- code = data[0]?.error?.message || data?.error?.message;
- }
+ .catch(() => null);
+ const entry = Array.isArray(data) ? data[0] : data;
+ // tRPC puts the code on error.data.code; a plain handler may only send
+ // a message. Accept both so a revoked token always forces a logout.
+ const code = entry?.error?.data?.code ?? entry?.error?.message;
if (code === "UNAUTHORIZED") {
DeviceEventEmitter.emit(FORCE_LOGOUT_EVENT);
}
diff --git a/apps/user-ui/tests/app/layouts.test.tsx b/apps/user-ui/tests/app/layouts.test.tsx
index 578b55c..0873c5b 100644
--- a/apps/user-ui/tests/app/layouts.test.tsx
+++ b/apps/user-ui/tests/app/layouts.test.tsx
@@ -92,12 +92,12 @@ describe('app entry + route layouts (APP-01..APP-24)', () => {
expect(view.UNSAFE_getByType(Stack)).toBeTruthy()
})
- it('APP-06: drawer layout while loading shows the pink spinner', () => {
+ it('APP-06: drawer layout while loading shows the brand spinner', () => {
authState({ isLoading: true })
const view = renderWithProviders(, { auth: false })
const spinner = view.UNSAFE_getByType(ActivityIndicator)
- expect(spinner.props.color).toBe(theme.colors.pink2)
+ expect(spinner.props.color).toBe(theme.colors.brand500)
})
it('APP-07: loaded drawer layout declares the five tabs', () => {
diff --git a/apps/user-ui/tests/helpers/reset.ts b/apps/user-ui/tests/helpers/reset.ts
index c347dfe..dd0cc74 100644
--- a/apps/user-ui/tests/helpers/reset.ts
+++ b/apps/user-ui/tests/helpers/reset.ts
@@ -47,6 +47,10 @@ export function resetStores() {
selectedRegion: null,
selectedBoundId: null,
regionGeneration: 0,
+ // Most cases exercise the launch decision with an empty store; they do not
+ // test the SecureStore hydration, so start settled (the persistence tests
+ // flip this back to false).
+ hydrated: true,
})
useSlotStore.setState({ slotId: undefined, storeId: undefined })
useFlashNavigationStore.setState({ shouldNavigateToCart: false })
diff --git a/apps/user-ui/tests/lib/auth.test.tsx b/apps/user-ui/tests/lib/auth.test.tsx
index 9bbf9ba..c6302e2 100644
--- a/apps/user-ui/tests/lib/auth.test.tsx
+++ b/apps/user-ui/tests/lib/auth.test.tsx
@@ -8,9 +8,10 @@
* is recorded rather than navigated.
*/
import * as React from 'react'
-import { Text } from 'react-native'
+import { Text, DeviceEventEmitter } from 'react-native'
import { act, waitFor } from '@testing-library/react-native'
import { StorageService } from 'common-ui'
+import { FORCE_LOGOUT_EVENT } from 'common-ui/src/lib/const-strs'
import { useAuth } from '@/src/contexts/AuthContext'
import { getAuthToken, getUserId } from '@/hooks/useJWT'
import constants from '@/src/constants'
@@ -61,12 +62,12 @@ describe('AuthContext', () => {
expect(ctx.user).toBeNull()
})
- it('AUTH-02: is authenticated but still loading while getSelfData is pending', async () => {
+ it('AUTH-02: trusts the stored token and does not block on getSelfData', async () => {
setProcedure('user.user.getSelfData', { mode: 'pending' })
renderWithProviders(, { auth: 'in' })
await waitFor(() => expect(ctx.isAuthenticated).toBe(true))
- expect(ctx.isLoading).toBe(true)
+ expect(ctx.isLoading).toBe(false)
expect(ctx.token).toBe(TEST_JWT)
})
@@ -79,20 +80,20 @@ describe('AuthContext', () => {
expect(ctx.userDetails).toEqual(AUTH_USER_FULL)
})
- it('AUTH-04: signs out when getSelfData fails but keeps the stored token', async () => {
+ it('AUTH-04: logs out when the backend rejects the stored token', async () => {
setProcedure('user.user.getSelfData', {
mode: 'error',
error: new Error('unauthorized'),
+ errorCode: 'UNAUTHORIZED',
})
renderWithProviders(, { auth: 'in' })
- // `isAuthenticated` starts false, so wait for the bootstrap + self read to
- // settle (the signed-in state is too short-lived for a poll to catch), then
- // assert the failure signed the user out.
- await waitFor(() => expect(ctx.isLoading).toBe(false))
+ // The token is present until the rejection lands, so this waits for the
+ // effect instead of racing the initial signed-out render.
+ await waitFor(() => expect(__snapshot().authToken).toBeUndefined())
expect(ctx.isAuthenticated).toBe(false)
- // Current behaviour: deleteAuthToken() is commented out.
- expect(__snapshot().authToken).toBe(TEST_JWT)
+ expect(ctx.isLoading).toBe(false)
+ expect(ctx.user).toBeNull()
})
it('AUTH-05: loginWithToken stores token/userId and runs the redirect handler', async () => {
@@ -284,4 +285,32 @@ describe('AuthContext', () => {
await waitFor(() => expect(router.replace).toHaveBeenCalledWith('/'))
})
+
+ it('AUTH-18: a non-credential getSelfData failure keeps the trusted session', async () => {
+ // Offline / timeout / 5xx must not wipe the credentials.
+ setProcedure('user.user.getSelfData', {
+ mode: 'error',
+ error: new Error('network down'),
+ errorCode: 'INTERNAL_SERVER_ERROR',
+ })
+ renderWithProviders(, { auth: 'in' })
+
+ await waitFor(() => expect(ctx.isLoading).toBe(false))
+ expect(ctx.isAuthenticated).toBe(true)
+ expect(ctx.user).not.toBeNull()
+ expect(__snapshot().authToken).toBe(TEST_JWT)
+ })
+
+ it('AUTH-19: a force-logout event (401 from any endpoint) clears the session', async () => {
+ renderWithProviders(, { auth: 'in' })
+ await waitFor(() => expect(ctx.isAuthenticated).toBe(true))
+
+ act(() => {
+ DeviceEventEmitter.emit(FORCE_LOGOUT_EVENT)
+ })
+
+ await waitFor(() => expect(__snapshot().authToken).toBeUndefined())
+ expect(ctx.isAuthenticated).toBe(false)
+ expect(ctx.token).toBeNull()
+ })
})
diff --git a/apps/user-ui/tests/lib/route-network.test.tsx b/apps/user-ui/tests/lib/route-network.test.tsx
index 8162274..a8fa24a 100644
--- a/apps/user-ui/tests/lib/route-network.test.tsx
+++ b/apps/user-ui/tests/lib/route-network.test.tsx
@@ -256,6 +256,21 @@ describe('trpc client link', () => {
await pending
})
+
+ it('TRPC-07: emits force-logout on a 401 tRPC envelope (error.data.code)', async () => {
+ const emitSpy = jest.spyOn(DeviceEventEmitter, 'emit')
+ ;(global as any).fetch = jest.fn(async () =>
+ makeResponse(401, [
+ { error: { message: 'Unauthorized', data: { code: 'UNAUTHORIZED', httpStatus: 401 } } },
+ ])
+ )
+
+ await realTrpcClient.common.healthCheck.query().catch(() => undefined)
+ await flush()
+
+ expect(emitSpy).toHaveBeenCalledWith(FORCE_LOGOUT_EVENT)
+ emitSpy.mockRestore()
+ })
})
/* -------------------------------------------------------------------------- */
diff --git a/apps/user-ui/tests/lib/use-region.test.tsx b/apps/user-ui/tests/lib/use-region.test.tsx
index 55aac72..53e167b 100644
--- a/apps/user-ui/tests/lib/use-region.test.tsx
+++ b/apps/user-ui/tests/lib/use-region.test.tsx
@@ -827,6 +827,55 @@ describe('useRegion', () => {
}
})
})
+
+ it('REGION-32: a persisted region/bound is hydrated before the launch decision', async () => {
+ await withFreshModules(async (ctx) => {
+ const { REGION_1 } = ctx.fixtures
+ ctx.auth.__setAuthState({ isAuthenticated: false, isLoading: false })
+ ctx.locationMock.__configure({ permission: 'denied' })
+ // Opt out of the reset helper's settled store: this case starts cold and
+ // must be hydrated from SecureStore.
+ ctx.regionStore.setState({ hydrated: false })
+ ctx.secure.__set(
+ ctx.regionCache.REGION_SELECTION_CACHE_KEY,
+ JSON.stringify({ regionId: REGION_1.id, region: REGION_1, boundId: 7 })
+ )
+
+ const { result, view } = ctx.renderRegion()
+
+ // Before the read lands the gate keeps its neutral state; the labelled
+ // "Finding your region" spinner is not used because the store reports
+ // itself as not hydrated yet.
+ expect(result.current.hydrated).toBe(false)
+
+ await ctx.testUtils.flush(4)
+
+ expect(result.current.hydrated).toBe(true)
+ expect(result.current.regionId).toBe(REGION_1.id)
+ expect(result.current.boundId).toBe(7)
+ expect(result.current.isResolvingRegion).toBe(false)
+ view.unmount()
+ })
+ })
+
+ it('REGION-33: setRegion persists the selection and clearRegion removes it', async () => {
+ await withFreshModules(async (ctx) => {
+ const { REGION_1 } = ctx.fixtures
+
+ ctx.regionStore.getState().setRegion(REGION_1, 7)
+ await ctx.testUtils.flush(2)
+
+ const stored = ctx.secure.__snapshot()[ctx.regionCache.REGION_SELECTION_CACHE_KEY]
+ expect(JSON.parse(stored as string)).toMatchObject({ regionId: REGION_1.id, boundId: 7 })
+
+ ctx.regionStore.getState().clearRegion()
+ await ctx.testUtils.flush(2)
+
+ expect(
+ ctx.secure.__snapshot()[ctx.regionCache.REGION_SELECTION_CACHE_KEY]
+ ).toBeUndefined()
+ })
+ })
})
diff --git a/apps/web-ui/src/lib/auth-context.tsx b/apps/web-ui/src/lib/auth-context.tsx
index b0ed0d7..7dd9833 100644
--- a/apps/web-ui/src/lib/auth-context.tsx
+++ b/apps/web-ui/src/lib/auth-context.tsx
@@ -1,8 +1,20 @@
import React, { createContext, useContext, useState, useEffect, useCallback } from 'react'
-import { trpc } from './trpc-client'
+import { trpc, setUnauthorizedHandler } from './trpc-client'
import { useNavigate } from '@tanstack/react-router'
import type { User as SharedUser, AuthStateCore } from '@packages/shared'
+/**
+ * Only a credential rejection proves the stored token is dead. Offline, a
+ * timeout or a 5xx must never sign the user out.
+ */
+const isCredentialError = (error: unknown): boolean => {
+ const trpcError = error as
+ | { data?: { code?: string }; shape?: { data?: { code?: string } } }
+ | null
+ const code = trpcError?.data?.code ?? trpcError?.shape?.data?.code
+ return code === 'UNAUTHORIZED' || code === 'FORBIDDEN'
+}
+
// Auth user — serialized view of the shared User (optional name, no createdAt)
type User = Pick &
Partial> & {
@@ -41,10 +53,12 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
const storedToken = localStorage.getItem('auth_token')
const storedUserId = localStorage.getItem('user_id')
if (storedToken && storedUserId) {
+ // Trust the stored credentials: render now, let getSelfData confirm them.
setState((prev) => ({
...prev,
token: storedToken,
isAuthenticated: true,
+ isLoading: false,
}))
} else {
setState((prev) => ({ ...prev, isLoading: false }))
@@ -52,7 +66,7 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
}, [])
// Fetch user data when token is available
- const { data: selfData } = trpc.user.user.getSelfData.useQuery(undefined, {
+ const { data: selfData, error: selfDataError } = trpc.user.user.getSelfData.useQuery(undefined, {
enabled: !!state.token && state.isAuthenticated,
retry: 1,
})
@@ -65,10 +79,8 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
userDetails: selfData.data.user,
isLoading: false,
}))
- } else if (selfData === undefined && state.token) {
- // Token might be invalid
}
- }, [selfData, state.token])
+ }, [selfData])
const login = useCallback((token: string, user: User) => {
localStorage.setItem('auth_token', token)
@@ -103,6 +115,19 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
navigate({ to: '/login' })
}, [navigate])
+ // A rejected token drops the session; any other failure keeps it.
+ useEffect(() => {
+ if (selfDataError && state.isAuthenticated && isCredentialError(selfDataError)) {
+ logout()
+ }
+ }, [selfDataError, state.isAuthenticated, logout])
+
+ // Any endpoint that answers 401 UNAUTHORIZED drops the session.
+ useEffect(() => {
+ setUnauthorizedHandler(logout)
+ return () => setUnauthorizedHandler(null)
+ }, [logout])
+
const updateUser = useCallback((user: User) => {
setState((prev) => ({ ...prev, user }))
}, [])
diff --git a/apps/web-ui/src/lib/trpc-client.ts b/apps/web-ui/src/lib/trpc-client.ts
index 5874f24..7c05923 100644
--- a/apps/web-ui/src/lib/trpc-client.ts
+++ b/apps/web-ui/src/lib/trpc-client.ts
@@ -9,11 +9,40 @@ export const BASE_API_URL =
export const trpc = createTRPCReact()
+type UnauthorizedHandler = () => void
+
+let unauthorizedHandler: UnauthorizedHandler | null = null
+
+/** Registered by the auth provider; called when the API answers 401 UNAUTHORIZED. */
+export function setUnauthorizedHandler(handler: UnauthorizedHandler | null) {
+ unauthorizedHandler = handler
+}
+
+/**
+ * Mirrors the user app's FORCE_LOGOUT_EVENT: a token the backend rejects must
+ * drop the session, even when the failing call was not getSelfData.
+ */
+async function fetchWithCredentialCheck(input: RequestInfo | URL, init?: RequestInit) {
+ const response = await fetch(input, init)
+ if (response.status === 401) {
+ const data = await response
+ .clone()
+ .json()
+ .catch(() => null)
+ const entry = Array.isArray(data) ? data[0] : data
+ // tRPC puts the code on error.data.code; a plain handler may only send a message.
+ const code = entry?.error?.data?.code ?? entry?.error?.message
+ if (code === 'UNAUTHORIZED') unauthorizedHandler?.()
+ }
+ return response
+}
+
export function getTrpcClient() {
return createTRPCClient({
links: [
httpBatchLink({
url: `${BASE_API_URL}/api/trpc`,
+ fetch: fetchWithCredentialCheck,
headers: async () => {
try {
const token = localStorage.getItem('auth_token')
diff --git a/change-log.txt b/change-log.txt
index b94bc3e..b3ce148 100644
--- a/change-log.txt
+++ b/change-log.txt
@@ -10235,3 +10235,102 @@ Re-validated the fixed file two ways:
removed, 2026-02-10 00:00 is kept, old coupon_usage/complaints/user_incidents rows survive with
NULL order refs, FK check clean.
2. Pre-0006 local dump copy: orders 2548 -> 2438 (-110), no orphan rows, FK check clean.
+
+[2026-10-25 20:55 IST] Persisted the browsing region + bound so startup can render (and read the
+regional CDN files) before the device fix / auth / network settle. essentialConsts was already
+persisted per bound in `useGetEssentialConsts`; with the bound known at hydration its snapshot and
+cache URLs are now available immediately.
+
+--- apps/user-ui/src/lib/region-cache.ts
+Added REGION_SELECTION_CACHE_KEY ('region_cache.selection.v1'), CachedRegionSelection,
+readCachedRegionSelection / writeCachedRegionSelection (dedup) / clearCachedRegionSelection, with
+validation that the stored region matches its id and the bound is number|null.
+
+--- apps/user-ui/src/store/regionStore.ts
++ hydrated: boolean, hydrate(): Promise
++ hydration is single-flight; skips if a region was chosen while the read was in flight
++ setRegion() writes the selection, clearRegion() removes it
+Changed the header comment: the selection is persisted now, but still reconciled against the live
+location/default address at launch (not trusted blindly).
+
+--- apps/user-ui/src/hooks/useRegion.ts
+hydrated now comes from the store (was hardcoded true) and every consumer calls hydrate() once.
+The launch baseline (startupLaunchRegionId) is set after hydration, so the restored selection is
+treated as launch state, not as a manual pick, and reconciliation still runs.
+
+--- apps/user-ui/tests/helpers/reset.ts
+Reset keeps hydrated: true so existing cases behave as before (they do not test hydration).
+
+--- apps/user-ui/tests/lib/use-region.test.tsx
+REGION-32 persisted selection hydrates before the launch decision (no spinner).
+REGION-33 setRegion persists / clearRegion removes the stored selection.
+
+--- apps/user-ui/JEST-TEST-CASES.md
+Rows REGION-32/33.
+The GPS launch fix now starts in parallel with the SecureStore read (only the launch baseline
+waits for hydration), and essentialConsts keeps its existing per-bound SecureStore snapshot:
+with the bound hydrated, `useGetEssentialConsts` serves that snapshot as placeholder data, so
+`essentialUrls` are available without the network and products/availability/stores/slots start
+fetching as soon as the screens mount (the wrappers above the region gate already mount the hook,
+so the read starts before the gate opens).
+Typecheck: `apps/user-ui` project clean.
+
+[2026-10-25 21:14 IST] Fixed the invisible drawer auth spinner. `theme.colors.pink2` is '#fff0f6'
+on `bg-white`, so the (drawer) auth gate rendered as a plain white screen with no visible
+indicator whenever the drawer mounted while auth was still validating (deep link / restored
+route). Use brand500 (always visible, matches LocationTestWrapper).
+
+--- apps/user-ui/app/(drawer)/_layout.tsx
+-
++
+
+--- apps/user-ui/tests/app/layouts.test.tsx
+- it('APP-06: drawer layout while loading shows the pink spinner', () => {
++ it('APP-06: drawer layout while loading shows the brand spinner', () => {
+- expect(spinner.props.color).toBe(theme.colors.pink2)
++ expect(spinner.props.color).toBe(theme.colors.brand500)
+
+--- apps/user-ui/JEST-TEST-CASES.md
+-| APP-06 | edge | drawer layout loading | pink loading spinner |
++| APP-06 | edge | drawer layout loading | brand loading spinner (visible on white) |
+
+No web-ui counterpart change: apps/web-ui gates auth via ProtectedRoute, which already renders a
+border-brand-500 spinner (visible), so there is no invisible-spinner equivalent to mirror.
+
+[2026-10-25 21:38 IST] Startup no longer blocks on getSelfData. Stored token+userId are trusted
+immediately (isLoading false), the app renders, and the background selfData read confirms them.
+Only a backend rejection (UNAUTHORIZED/FORBIDDEN) clears the session; offline/timeout/5xx keeps the
+trusted session. user-ui also subscribes to FORCE_LOGOUT_EVENT (the 401 handler in trpc-client
+already emitted it, but nothing listened, so a revoked token only surfaced on the next selfData
+read). The 401 handler now also checks error.data.code, which is where tRPC actually puts
+UNAUTHORIZED.
+
+--- apps/user-ui/src/contexts/AuthContext.tsx
+import useCallback; DeviceEventEmitter; FORCE_LOGOUT_EVENT
++ isCredentialError(error): data.code UNAUTHORIZED/FORBIDDEN
++ clearSession(): deleteAuthToken (best effort) + queryClient.clear() + reset state; logout = clearSession
+initializeAuth: token+userId -> isLoading:false (was true; comment "keep loading while fetching user")
+selfData effect: success -> user/userDetails; credential error -> clearSession(); other errors -> keep
+ the session (no logout on network failure)
++ useEffect FORCE_LOGOUT_EVENT -> clearSession()
+
+--- apps/user-ui/src/trpc-client.ts
+401 handler: read error.data.code (tRPC envelope) with the old error.message as fallback
+
+--- apps/user-ui/tests/lib/auth.test.tsx
+AUTH-02: authenticated and NOT loading while getSelfData is pending
+AUTH-04: UNAUTHORIZED selfData -> full logout (token removed)
++ AUTH-18 non-auth selfData failure keeps the trusted session
++ AUTH-19 FORCE_LOGOUT_EVENT clears the session
+
+--- apps/user-ui/tests/lib/route-network.test.tsx
++ TRPC-07 401 with a tRPC envelope (error.data.code = UNAUTHORIZED) emits force-logout
+
+--- apps/user-ui/JEST-TEST-CASES.md
+AUTH-02/04 rows updated; AUTH-18/19 added; TRPC-07 added.
+
+--- apps/web-ui/src/lib/auth-context.tsx
+Mirror: stored token -> isLoading:false; selfData error with UNAUTHORIZED -> logout (/login).
+
+--- apps/web-ui/src/lib/trpc-client.ts
+Mirror of the RN event: setUnauthorizedHandler() invoked when the API answers 401 UNAUTHORIZED.