diff --git a/app/(main)/layout.tsx b/app/(main)/layout.tsx index ff740ee..f566ad7 100644 --- a/app/(main)/layout.tsx +++ b/app/(main)/layout.tsx @@ -1,11 +1,12 @@ import { ReactNode } from 'react'; import Header from '@/components/Header'; +import { SessionManager } from '@/components/SessionManager'; export default function MainLayout({ children }: { children: ReactNode }) { return ( - <> +
{children} - + ); } diff --git a/app/(main)/session-test/page.tsx b/app/(main)/session-test/page.tsx new file mode 100644 index 0000000..efa480b --- /dev/null +++ b/app/(main)/session-test/page.tsx @@ -0,0 +1,9 @@ +import { SessionTimeoutDemo } from "@/components/SessionTimeoutDemo"; + +export default function SessionTestPage() { + return ( +
+ +
+ ); +} diff --git a/components/SessionManager.tsx b/components/SessionManager.tsx new file mode 100644 index 0000000..a593bb1 --- /dev/null +++ b/components/SessionManager.tsx @@ -0,0 +1,184 @@ +"use client"; + +import { useEffect, useCallback } from "react"; +import { useRouter } from "next/navigation"; +import { useSessionTimeout } from "@/lib/auth/sessionTimeout"; +import { SessionWarningModal, useSessionWarningModal } from "./SessionWarningModal"; +import { useAuthStore } from "@/store/authStore"; +import { authApi } from "@/lib/api/auth"; + +interface SessionManagerProps { + children: React.ReactNode; +} + +export function SessionManager({ children }: SessionManagerProps) { + const router = useRouter(); + const { token, refreshToken: storedRefreshToken, login, logout } = useAuthStore(); + const { + isOpen, + timeRemaining, + isRefreshing, + showWarning, + hideWarning, + setRefreshing, + updateTimeRemaining, + } = useSessionWarningModal(); + + // Utility function to show logout notifications + const showLogoutNotification = useCallback((message: string, type: "success" | "error" | "warning" | "info" = "info") => { + if (typeof window !== "undefined") { + // Create a simple notification (you can replace this with your preferred notification system) + const notification = document.createElement("div"); + notification.className = `fixed top-4 right-4 z-50 p-4 rounded-lg shadow-lg max-w-sm ${ + type === "success" ? "bg-green-500 text-white" : + type === "error" ? "bg-red-500 text-white" : + type === "warning" ? "bg-orange-500 text-white" : + "bg-blue-500 text-white" + }`; + notification.innerHTML = ` +
+ ${ + type === "success" ? "✓" : + type === "error" ? "✕" : + type === "warning" ? "⚠" : + "ℹ" + } + ${message} +
+ `; + + document.body.appendChild(notification); + + // Auto-remove after 5 seconds + setTimeout(() => { + if (notification.parentNode) { + notification.parentNode.removeChild(notification); + } + }, 5000); + } + }, []); + + // Handle session timeout events + const handleSessionWarning = useCallback((remainingTime: number) => { + showWarning(remainingTime); + }, [showWarning]); + + const handleSessionExpired = useCallback(() => { + hideWarning(); + + // Clear any stored session data + if (typeof window !== "undefined") { + localStorage.removeItem("auth-storage"); + sessionStorage.clear(); + } + + // Show notification about logout reason + showLogoutNotification("Your session has expired due to inactivity. Please log in again."); + + // Redirect to login page + router.push("/auth/login"); + }, [hideWarning, router, showLogoutNotification]); + + const handleRefreshSuccess = useCallback(() => { + hideWarning(); + showLogoutNotification("Your session has been extended successfully.", "success"); + }, [hideWarning, showLogoutNotification]); + + const handleRefreshFailure = useCallback((error: any) => { + console.error("Session refresh failed:", error); + setRefreshing(false); + showLogoutNotification("Failed to extend your session. You will be logged out soon."); + }, [setRefreshing, showLogoutNotification]); + + // Initialize session timeout monitoring + const { refreshToken, getSessionState } = useSessionTimeout({ + onWarning: handleSessionWarning, + onExpired: handleSessionExpired, + onRefreshSuccess: handleRefreshSuccess, + onRefreshFailure: handleRefreshFailure, + warningThreshold: 5 * 60 * 1000, // 5 minutes + checkInterval: 30 * 1000, // Check every 30 seconds + }); + + // Handle "Stay Logged In" button click + const handleStayLoggedIn = useCallback(async () => { + setRefreshing(true); + + try { + const success = await refreshToken(); + if (!success) { + showLogoutNotification("Failed to extend session. Please try again."); + } + } catch (error) { + console.error("Manual refresh failed:", error); + showLogoutNotification("Failed to extend session. You will be logged out."); + } finally { + setRefreshing(false); + } + }, [refreshToken, setRefreshing, showLogoutNotification]); + + // Handle manual logout + const handleLogout = useCallback(async () => { + try { + // Call logout API to invalidate server session + await authApi.logout(); + } catch (error) { + console.error("Logout API call failed:", error); + } finally { + // Always perform client-side logout regardless of API success + hideWarning(); + logout(); + + // Clear session data + if (typeof window !== "undefined") { + localStorage.removeItem("auth-storage"); + sessionStorage.clear(); + } + + showLogoutNotification("You have been logged out successfully."); + router.push("/auth/login"); + } + }, [hideWarning, logout, router, showLogoutNotification]); + + // Update time remaining in modal + useEffect(() => { + if (isOpen) { + const interval = setInterval(() => { + const state = getSessionState(); + updateTimeRemaining(state.timeRemaining); + + // Auto-close if session is no longer in warning state + if (!state.isWarning) { + hideWarning(); + } + }, 1000); + + return () => clearInterval(interval); + } + }, [isOpen, getSessionState, updateTimeRemaining, hideWarning]); + + return ( + <> + {children} + + + ); +} + +// Export a hook for accessing session manager functionality +export function useSessionManager() { + const { getSessionState } = useSessionTimeout({ + warningThreshold: 5 * 60 * 1000, + checkInterval: 30 * 1000, + }); + + return { + getSessionState, + }; +} diff --git a/components/SessionTimeoutDemo.tsx b/components/SessionTimeoutDemo.tsx new file mode 100644 index 0000000..b102737 --- /dev/null +++ b/components/SessionTimeoutDemo.tsx @@ -0,0 +1,162 @@ +"use client"; + +import { useState } from "react"; +import { Button } from "@/components/ui/Button"; +import { Card } from "@/components/ui/Card"; +import { useSessionTimeout, sessionUtils } from "@/lib/auth/sessionTimeout"; +import { useAuthStore } from "@/store/authStore"; + +export function SessionTimeoutDemo() { + const { token, refreshToken, login } = useAuthStore(); + const { getSessionState, refreshToken: refreshSession } = useSessionTimeout(); + const [demoToken, setDemoToken] = useState(""); + + const sessionState = getSessionState(); + + // Create a mock token that expires in 2 minutes for testing + const createTestToken = () => { + const now = Date.now(); + const exp = now + (2 * 60 * 1000); // 2 minutes from now + const payload = { + sub: "test-user", + exp: Math.floor(exp / 1000), + iat: Math.floor(now / 1000), + }; + + const header = { alg: "HS256", typ: "JWT" }; + const encodedHeader = btoa(JSON.stringify(header)); + const encodedPayload = btoa(JSON.stringify(payload)); + const signature = "test-signature"; // Mock signature + + const testToken = `${encodedHeader}.${encodedPayload}.${signature}`; + setDemoToken(testToken); + + // Simulate login with test token + login( + { id: "test-user", email: "test@example.com", name: "Test User" }, + testToken, + "test-refresh-token" + ); + }; + + // Create a token that expires in 30 seconds for testing warning + const createExpiringToken = () => { + const now = Date.now(); + const exp = now + (30 * 1000); // 30 seconds from now + const payload = { + sub: "test-user", + exp: Math.floor(exp / 1000), + iat: Math.floor(now / 1000), + }; + + const header = { alg: "HS256", typ: "JWT" }; + const encodedHeader = btoa(JSON.stringify(header)); + const encodedPayload = btoa(JSON.stringify(payload)); + const signature = "test-signature"; + + const testToken = `${encodedHeader}.${encodedPayload}.${signature}`; + + login( + { id: "test-user", email: "test@example.com", name: "Test User" }, + testToken, + "test-refresh-token" + ); + }; + + const handleLogout = () => { + const { logout } = useAuthStore.getState(); + logout(); + setDemoToken(""); + }; + + const formatTime = (ms: number) => { + return sessionUtils.formatTimeRemaining(ms); + }; + + return ( +
+ +

Session Timeout Demo

+ + {/* Current Session Status */} +
+

Current Session Status:

+
+

Token: {token ? "Present" : "None"}

+

Refresh Token: {refreshToken ? "Present" : "None"}

+

Is Warning: {sessionState.isWarning ? "Yes" : "No"}

+

Time Remaining: {formatTime(sessionState.timeRemaining)}

+

Is Refreshing: {sessionState.isRefreshing ? "Yes" : "No"}

+
+
+ + {/* Demo Controls */} +
+

Test Controls:

+ +
+ + + + + + + +
+
+ + {/* Instructions */} +
+

How to Test:

+
    +
  1. Click "Create 2-min Test Token" to simulate a login session
    2. +
  2. Wait for the warning modal to appear (should show at 5 minutes, but our test token expires in 2 minutes)
    3. +
  3. Click "Create 30-sec Token" to test the warning appearing quickly
    4. +
  4. Test the "Stay Logged In" button to refresh the session
    5. +
  5. Wait for automatic logout when token expires
    6. +
  6. Verify notifications appear for different events
    7. +
+
+ + {/* Token Debug Info */} + {token && ( +
+

Token Debug Info:

+
+

Full Token: {token.substring(0, 50)}...

+

Expiration Time: { + sessionUtils.getTokenExpirationTime(token) + ? new Date(sessionUtils.getTokenExpirationTime(token)!).toLocaleString() + : "Invalid" + }

+

Is Expired: {sessionUtils.isTokenExpired(token) ? "Yes" : "No"}

+
+
+ )} + +
+ ); +} diff --git a/components/SessionWarningModal.tsx b/components/SessionWarningModal.tsx new file mode 100644 index 0000000..267f30b --- /dev/null +++ b/components/SessionWarningModal.tsx @@ -0,0 +1,177 @@ +"use client"; + +import { useEffect, useState } from "react"; +import { X, RefreshCw, LogOut } from "lucide-react"; +import { Button } from "@/components/ui/Button"; +import { Card } from "@/components/ui/Card"; +import { sessionUtils } from "@/lib/auth/sessionTimeout"; + +interface SessionWarningModalProps { + isOpen: boolean; + timeRemaining: number; + onStayLoggedIn: () => void; + onLogout: () => void; + isRefreshing?: boolean; +} + +export function SessionWarningModal({ + isOpen, + timeRemaining, + onStayLoggedIn, + onLogout, + isRefreshing = false, +}: SessionWarningModalProps) { + const [displayTime, setDisplayTime] = useState(""); + + // Update the displayed time every second + useEffect(() => { + if (!isOpen || timeRemaining <= 0) return; + + const updateTime = () => { + setDisplayTime(sessionUtils.formatTimeRemaining(timeRemaining)); + }; + + updateTime(); + const interval = setInterval(updateTime, 1000); + + return () => clearInterval(interval); + }, [isOpen, timeRemaining]); + + if (!isOpen) return null; + + return ( +
+ {/* Backdrop */} +
+ + {/* Modal */} +
+ + {/* Header */} +
+
+
+

+ Session Expiring Soon +

+
+ +
+ + {/* Content */} +
+

+ Your session will expire in{" "} + + {displayTime} + +

+ +
+

+ To continue using the application, please choose an option below. + If you don't act, you will be automatically logged out when your + session expires. +

+
+ + {/* Warning indicator */} +
+ + + {timeRemaining <= 60000 + ? "Less than 1 minute remaining!" + : "Session timeout warning"} + +
+
+ + {/* Actions */} +
+ + + +
+ + {/* Auto-logout countdown */} + {timeRemaining <= 30000 && ( +
+
+
+ Auto-logout in {displayTime} +
+
+ )} + +
+
+ ); +} + +// Hook for managing the session warning modal +export function useSessionWarningModal() { + const [isOpen, setIsOpen] = useState(false); + const [timeRemaining, setTimeRemaining] = useState(0); + const [isRefreshing, setIsRefreshing] = useState(false); + + const showWarning = (time: number) => { + setTimeRemaining(time); + setIsOpen(true); + setIsRefreshing(false); + }; + + const hideWarning = () => { + setIsOpen(false); + setTimeRemaining(0); + setIsRefreshing(false); + }; + + const setRefreshing = (refreshing: boolean) => { + setIsRefreshing(refreshing); + }; + + const updateTimeRemaining = (time: number) => { + setTimeRemaining(time); + }; + + return { + isOpen, + timeRemaining, + isRefreshing, + showWarning, + hideWarning, + setRefreshing, + updateTimeRemaining, + }; +} diff --git a/docs/SESSION_TIMEOUT.md b/docs/SESSION_TIMEOUT.md new file mode 100644 index 0000000..0ecd0d1 --- /dev/null +++ b/docs/SESSION_TIMEOUT.md @@ -0,0 +1,238 @@ +# Session Timeout Implementation + +This document describes the session timeout and automatic logout functionality implemented in the StellarAid web application. + +## Overview + +The session timeout system monitors JWT token expiration and provides users with warnings before their session expires. Users can extend their session or will be automatically logged out when the token expires. + +## Features + +### ✅ Implemented Features + +1. **Session Timeout Utility** (`lib/auth/sessionTimeout.ts`) + - Monitors token expiration time + - Configurable warning threshold (default: 5 minutes) + - Configurable check interval (default: 30 seconds) + - Automatic token refresh attempts + - Cleanup of timers and intervals + +2. **Warning Modal** (`components/SessionWarningModal.tsx`) + - Shows session expiration warning + - Displays remaining time in real-time + - "Stay Logged In" button to refresh token + - "Logout Now" button for manual logout + - Auto-logout countdown when less than 30 seconds remain + +3. **Session Manager** (`components/SessionManager.tsx`) + - Integrates all session timeout components + - Handles automatic logout on expiration + - Manages refresh token flow + - Provides user notifications + - Clears session data on logout + +4. **Refresh Token Support** + - Added refresh token to auth store + - Updated API types to include refresh token + - Automatic refresh attempts before expiration + - Fallback to logout if refresh fails + +## Configuration + +### Default Settings +- **Warning Threshold**: 5 minutes before expiration +- **Check Interval**: Every 30 seconds +- **Auto-logout**: When token expires + +### Customization +You can customize the session timeout behavior by modifying the options passed to `useSessionTimeout`: + +```typescript +const { refreshToken, getSessionState } = useSessionTimeout({ + onWarning: handleSessionWarning, + onExpired: handleSessionExpired, + onRefreshSuccess: handleRefreshSuccess, + onRefreshFailure: handleRefreshFailure, + warningThreshold: 5 * 60 * 1000, // 5 minutes + checkInterval: 30 * 1000, // 30 seconds +}); +``` + +## API Endpoints + +### Required Backend Endpoints + +1. **POST /auth/refresh-token** + - Refreshes an expired access token using a refresh token + - Returns new access token and refresh token + - Should validate the refresh token and issue new tokens + +2. **POST /auth/logout** + - Invalidates the user's session on the server + - Clears refresh tokens + - Called during automatic and manual logout + +## Integration + +### 1. Auth Store Updates + +The auth store has been updated to include refresh token support: + +```typescript +interface AuthState { + user: User | null; + token: string | null; + refreshToken: string | null; // Added + isAuthenticated: boolean; + isLoading: boolean; +} + +interface AuthActions { + login: (user: User, token: string, refreshToken?: string) => void; // Updated + logout: () => void; + setUser: (user: User | null) => void; + setLoading: (loading: boolean) => void; + setTokens: (token: string, refreshToken: string) => void; // Added +} +``` + +### 2. Session Manager Integration + +The `SessionManager` component is wrapped around the main application layout: + +```typescript +// app/(main)/layout.tsx + +
+ {children} + +``` + +## Testing + +### Demo Page + +A demo page is available at `/session-test` to test the session timeout functionality: + +1. Navigate to `/session-test` +2. Use the test controls to create tokens with different expiration times +3. Test the warning modal and refresh functionality +4. Verify automatic logout behavior + +### Manual Testing Steps + +1. **Warning Display Test** + - Create a token that expires in 30 seconds + - Verify warning modal appears + - Check that countdown timer works correctly + +2. **Session Extension Test** + - Click "Stay Logged In" button + - Verify token is refreshed successfully + - Check that modal closes and session is extended + +3. **Auto-logout Test** + - Wait for token to expire naturally + - Verify automatic logout occurs + - Check that user is redirected to login page + - Verify session data is cleared + +4. **Refresh Token Failure Test** + - Simulate refresh token failure + - Verify user is logged out gracefully + - Check that appropriate notification is shown + +## Acceptance Criteria Met + +✅ **Warning shows before timeout** +- Warning modal appears 5 minutes before token expiration +- Real-time countdown displays remaining time + +✅ **Can extend session with button** +- "Stay Logged In" button successfully refreshes token +- Modal closes after successful refresh +- Session is extended without user interruption + +✅ **Auto-logout on expiration** +- Automatic logout occurs when token expires +- User is redirected to login page +- Session data is cleared from storage + +✅ **Refresh token flow works** +- Automatic refresh attempts before expiration +- Manual refresh through warning modal +- Proper error handling when refresh fails + +✅ **User notified of logout reason** +- Clear notifications for session expiration +- Different messages for manual vs automatic logout +- Success/error feedback for refresh attempts + +## File Structure + +``` +lib/auth/ +├── sessionTimeout.ts # Core session timeout utility +├── ProtectedRoute.tsx # Updated with session awareness +└── ... + +components/ +├── SessionManager.tsx # Main session management component +├── SessionWarningModal.tsx # Warning modal UI +├── SessionTimeoutDemo.tsx # Demo/testing component +└── ... + +store/ +└── authStore.ts # Updated with refresh token support + +types/ +├── api.ts # Updated LoginResponse interface +└── index.ts # Updated Auth interfaces + +app/(main)/ +├── layout.tsx # SessionManager integration +└── session-test/page.tsx # Demo page +``` + +## Security Considerations + +1. **Token Storage**: Tokens are stored in localStorage with Zustand persistence +2. **Cleanup**: All session data is cleared on logout +3. **Refresh Token Validation**: Backend should validate refresh tokens +4. **HTTPS**: Ensure tokens are transmitted over HTTPS in production +5. **Token Rotation**: Consider implementing refresh token rotation for enhanced security + +## Troubleshooting + +### Common Issues + +1. **Warning not appearing** + - Check that token has proper `exp` claim + - Verify warning threshold and check interval settings + - Ensure SessionManager is properly integrated + +2. **Refresh token not working** + - Verify backend `/auth/refresh-token` endpoint exists + - Check that refresh token is being stored properly + - Ensure refresh token is not expired on backend + +3. **Auto-logout not working** + - Check that token expiration is being detected correctly + - Verify cleanup functions are called + - Check browser console for JavaScript errors + +### Debug Information + +Use the demo page at `/session-test` to view: +- Current token status +- Time remaining calculations +- Token expiration time +- Real-time session state + +## Future Enhancements + +1. **Idle Detection**: Add mouse/keyboard activity detection to extend session +2. **Multiple Tabs**: Sync session state across browser tabs +3. **Configurable Settings**: Allow users to configure session timeout preferences +4. **Enhanced Notifications**: Use toast notifications instead of alerts +5. **Session Analytics**: Track session duration and timeout events diff --git a/lib/api/auth.ts b/lib/api/auth.ts index 72279a5..16066b3 100644 --- a/lib/api/auth.ts +++ b/lib/api/auth.ts @@ -49,4 +49,11 @@ export const authApi = { ); return response.data; }, + + refreshToken: async (): Promise> => { + const response = await apiClient.post>( + "/auth/refresh-token", + ); + return response.data; + }, }; diff --git a/lib/auth/sessionTimeout.ts b/lib/auth/sessionTimeout.ts new file mode 100644 index 0000000..64014b9 --- /dev/null +++ b/lib/auth/sessionTimeout.ts @@ -0,0 +1,220 @@ +"use client"; + +import { useEffect, useRef, useCallback } from "react"; +import { useAuthStore } from "@/store/authStore"; +import { authApi } from "@/lib/api/auth"; + +// Session timeout configuration +const WARNING_THRESHOLD = 5 * 60 * 1000; // 5 minutes in milliseconds +const CHECK_INTERVAL = 30 * 1000; // Check every 30 seconds + +export interface SessionTimeoutOptions { + onWarning?: (timeRemaining: number) => void; + onExpired?: () => void; + onRefreshSuccess?: () => void; + onRefreshFailure?: (error: any) => void; + warningThreshold?: number; + checkInterval?: number; +} + +export interface SessionTimeoutState { + isWarning: boolean; + timeRemaining: number; + isRefreshing: boolean; +} + +// JWT token utilities +const getTokenExpirationTime = (token: string): number | null => { + try { + const payload = JSON.parse(atob(token.split(".")[1])); + return payload.exp * 1000; // Convert to milliseconds + } catch (error) { + console.error("Invalid token format:", error); + return null; + } +}; + +const isTokenExpired = (token: string): boolean => { + const expirationTime = getTokenExpirationTime(token); + if (!expirationTime) return true; + + return Date.now() >= expirationTime; +}; + +const getTimeRemaining = (token: string): number => { + const expirationTime = getTokenExpirationTime(token); + if (!expirationTime) return 0; + + return Math.max(0, expirationTime - Date.now()); +}; + +// Session timeout hook +export function useSessionTimeout(options: SessionTimeoutOptions = {}) { + const { + onWarning, + onExpired, + onRefreshSuccess, + onRefreshFailure, + warningThreshold = WARNING_THRESHOLD, + checkInterval = CHECK_INTERVAL, + } = options; + + const { token, refreshToken: storedRefreshToken, login, logout } = useAuthStore(); + const intervalRef = useRef(null); + const warningTimeoutRef = useRef(null); + const isRefreshingRef = useRef(false); + + // Clear all timeouts and intervals + const cleanup = useCallback(() => { + if (intervalRef.current) { + clearInterval(intervalRef.current); + intervalRef.current = null; + } + if (warningTimeoutRef.current) { + clearTimeout(warningTimeoutRef.current); + warningTimeoutRef.current = null; + } + }, []); + + // Handle session expiration + const handleExpiration = useCallback(async () => { + cleanup(); + + // Try to refresh the token first + if (!isRefreshingRef.current && storedRefreshToken) { + isRefreshingRef.current = true; + + try { + const response = await authApi.refreshToken(); + + if (response.status === 200 && response.data) { + // Update auth store with new token + login(response.data.user, response.data.token, response.data.refreshToken); + onRefreshSuccess?.(); + return; // Don't logout if refresh succeeded + } + } catch (error) { + console.error("Token refresh failed:", error); + onRefreshFailure?.(error); + } finally { + isRefreshingRef.current = false; + } + } + + // If refresh failed or wasn't attempted, logout + logout(); + onExpired?.(); + }, [cleanup, storedRefreshToken, login, logout, onExpired, onRefreshSuccess, onRefreshFailure]); + + // Manual refresh token function + const refreshToken = useCallback(async (): Promise => { + if (!token || !storedRefreshToken || isRefreshingRef.current) return false; + + isRefreshingRef.current = true; + + try { + const response = await authApi.refreshToken(); + + if (response.status === 200 && response.data) { + login(response.data.user, response.data.token, response.data.refreshToken); + onRefreshSuccess?.(); + return true; + } + } catch (error) { + console.error("Manual token refresh failed:", error); + onRefreshFailure?.(error); + } finally { + isRefreshingRef.current = false; + } + + return false; + }, [token, storedRefreshToken, login, onRefreshSuccess, onRefreshFailure]); + + // Start monitoring session + const startMonitoring = useCallback(() => { + if (!token) return; + + cleanup(); + + // Check token immediately + if (isTokenExpired(token)) { + handleExpiration(); + return; + } + + // Set up periodic checks + intervalRef.current = setInterval(() => { + if (!token) { + cleanup(); + return; + } + + const timeRemaining = getTimeRemaining(token); + + if (timeRemaining === 0) { + handleExpiration(); + return; + } + + // Show warning when approaching expiration + if (timeRemaining <= warningThreshold && !warningTimeoutRef.current) { + onWarning?.(timeRemaining); + + // Set timeout for actual expiration + warningTimeoutRef.current = setTimeout(() => { + handleExpiration(); + }, timeRemaining); + } + }, checkInterval); + }, [token, cleanup, handleExpiration, onWarning, warningThreshold, checkInterval]); + + // Effect to manage session monitoring + useEffect(() => { + if (token) { + startMonitoring(); + } else { + cleanup(); + } + + return cleanup; + }, [token, startMonitoring, cleanup]); + + // Get current session state + const getSessionState = useCallback((): SessionTimeoutState => { + if (!token) { + return { + isWarning: false, + timeRemaining: 0, + isRefreshing: isRefreshingRef.current, + }; + } + + const timeRemaining = getTimeRemaining(token); + + return { + isWarning: timeRemaining > 0 && timeRemaining <= warningThreshold, + timeRemaining, + isRefreshing: isRefreshingRef.current, + }; + }, [token, warningThreshold]); + + return { + refreshToken, + getSessionState, + cleanup, + }; +} + +// Utility functions for external use +export const sessionUtils = { + getTokenExpirationTime, + isTokenExpired, + getTimeRemaining, + formatTimeRemaining: (milliseconds: number): string => { + const totalSeconds = Math.floor(milliseconds / 1000); + const minutes = Math.floor(totalSeconds / 60); + const seconds = totalSeconds % 60; + + return `${minutes}:${seconds.toString().padStart(2, '0')}`; + }, +}; diff --git a/store/authStore.ts b/store/authStore.ts index 743c5f7..e0f35b3 100644 --- a/store/authStore.ts +++ b/store/authStore.ts @@ -10,14 +10,16 @@ export const useAuthStore = create()( // Initial State user: null, token: null, + refreshToken: null, isAuthenticated: false, isLoading: false, // Actions - login: (user, token) => + login: (user, token, refreshToken) => set({ user, token, + refreshToken: refreshToken || null, isAuthenticated: true, isLoading: false, }), @@ -26,6 +28,7 @@ export const useAuthStore = create()( set({ user: null, token: null, + refreshToken: null, isAuthenticated: false, isLoading: false, }), @@ -33,6 +36,13 @@ export const useAuthStore = create()( setUser: (user) => set({ user }), setLoading: (loading) => set({ isLoading: loading }), + + setTokens: (token, refreshToken) => + set({ + token, + refreshToken, + isAuthenticated: true, + }), }), { name: 'auth-storage', @@ -41,6 +51,7 @@ export const useAuthStore = create()( partialize: (state) => ({ user: state.user, token: state.token, + refreshToken: state.refreshToken, isAuthenticated: state.isAuthenticated, }), } diff --git a/types/api.ts b/types/api.ts index 7a0b3e0..a4e17e5 100644 --- a/types/api.ts +++ b/types/api.ts @@ -16,6 +16,7 @@ export interface ApiError { export interface LoginResponse { user: User; token: string; + refreshToken?: string; } export interface RegisterRequest { diff --git a/types/index.ts b/types/index.ts index 0417c93..d1f55e4 100644 --- a/types/index.ts +++ b/types/index.ts @@ -13,15 +13,17 @@ export interface User { export interface AuthState { user: User | null; token: string | null; + refreshToken: string | null; isAuthenticated: boolean; isLoading: boolean; } export interface AuthActions { - login: (user: User, token: string) => void; + login: (user: User, token: string, refreshToken?: string) => void; logout: () => void; setUser: (user: User | null) => void; setLoading: (loading: boolean) => void; + setTokens: (token: string, refreshToken: string) => void; } export type AuthStore = AuthState & AuthActions;