mirror of
https://github.com/Memo-2023/mana-monorepo.git
synced 2026-05-17 18:29:39 +02:00
style: auto-format codebase with Prettier
Applied formatting to 1487+ files using pnpm format:write - TypeScript/JavaScript files - Svelte components - Astro pages - JSON configs - Markdown docs 13 files still need manual review (Astro JSX comments)
This commit is contained in:
Wuesteon
parent
0241f5554c
commit
d36b321d9d
3952 changed files with 661498 additions and 739751 deletions
File diff suppressed because it is too large
Load diff
|
|
@ -4,157 +4,157 @@ import type { DecodedToken, UserData } from '../types';
|
|||
* Decode a JWT token payload
|
||||
*/
|
||||
export function decodeToken(token: string): DecodedToken | null {
|
||||
try {
|
||||
const parts = token.split('.');
|
||||
if (parts.length !== 3) {
|
||||
return null;
|
||||
}
|
||||
try {
|
||||
const parts = token.split('.');
|
||||
if (parts.length !== 3) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const base64Url = parts[1];
|
||||
const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
|
||||
const base64Url = parts[1];
|
||||
const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
|
||||
|
||||
// Add padding if needed
|
||||
const padding = base64.length % 4;
|
||||
const paddedBase64 = padding ? base64 + '='.repeat(4 - padding) : base64;
|
||||
// Add padding if needed
|
||||
const padding = base64.length % 4;
|
||||
const paddedBase64 = padding ? base64 + '='.repeat(4 - padding) : base64;
|
||||
|
||||
// Decode base64 - atob is available in browsers, Node.js 16+, and React Native
|
||||
const payload: DecodedToken = JSON.parse(atob(paddedBase64));
|
||||
// Decode base64 - atob is available in browsers, Node.js 16+, and React Native
|
||||
const payload: DecodedToken = JSON.parse(atob(paddedBase64));
|
||||
|
||||
return payload;
|
||||
} catch (error) {
|
||||
console.error('Error decoding JWT token:', error);
|
||||
return null;
|
||||
}
|
||||
return payload;
|
||||
} catch (error) {
|
||||
console.error('Error decoding JWT token:', error);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a token is valid locally (not expired)
|
||||
*/
|
||||
export function isTokenValidLocally(token: string, bufferSeconds: number = 10): boolean {
|
||||
try {
|
||||
const payload = decodeToken(token);
|
||||
if (!payload || !payload.exp) {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
const payload = decodeToken(token);
|
||||
if (!payload || !payload.exp) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const bufferTime = bufferSeconds * 1000;
|
||||
const expiryTime = payload.exp * 1000;
|
||||
const currentTime = Date.now();
|
||||
const bufferTime = bufferSeconds * 1000;
|
||||
const expiryTime = payload.exp * 1000;
|
||||
const currentTime = Date.now();
|
||||
|
||||
return currentTime < expiryTime - bufferTime;
|
||||
} catch (error) {
|
||||
console.debug('Error validating token locally:', error);
|
||||
return false;
|
||||
}
|
||||
return currentTime < expiryTime - bufferTime;
|
||||
} catch (error) {
|
||||
console.debug('Error validating token locally:', error);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a token is expired
|
||||
*/
|
||||
export function isTokenExpired(token: string): boolean {
|
||||
return !isTokenValidLocally(token, 0);
|
||||
return !isTokenValidLocally(token, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract user data from a JWT token
|
||||
*/
|
||||
export function getUserFromToken(token: string, storedEmail?: string): UserData | null {
|
||||
try {
|
||||
const payload = decodeToken(token);
|
||||
if (!payload) {
|
||||
return null;
|
||||
}
|
||||
try {
|
||||
const payload = decodeToken(token);
|
||||
if (!payload) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// Get email from various sources
|
||||
let email = payload.email || '';
|
||||
if (!email && payload.user_metadata?.email) {
|
||||
email = payload.user_metadata.email;
|
||||
}
|
||||
if (!email && storedEmail) {
|
||||
email = storedEmail;
|
||||
}
|
||||
// Get email from various sources
|
||||
let email = payload.email || '';
|
||||
if (!email && payload.user_metadata?.email) {
|
||||
email = payload.user_metadata.email;
|
||||
}
|
||||
if (!email && storedEmail) {
|
||||
email = storedEmail;
|
||||
}
|
||||
|
||||
return {
|
||||
id: payload.sub,
|
||||
email: email || 'user@example.com',
|
||||
role: payload.role || 'user',
|
||||
};
|
||||
} catch (error) {
|
||||
console.error('Error extracting user from token:', error);
|
||||
return null;
|
||||
}
|
||||
return {
|
||||
id: payload.sub,
|
||||
email: email || 'user@example.com',
|
||||
role: payload.role || 'user',
|
||||
};
|
||||
} catch (error) {
|
||||
console.error('Error extracting user from token:', error);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get token expiration time in milliseconds
|
||||
*/
|
||||
export function getTokenExpirationTime(token: string): number | null {
|
||||
const payload = decodeToken(token);
|
||||
if (!payload || !payload.exp) {
|
||||
return null;
|
||||
}
|
||||
return payload.exp * 1000;
|
||||
const payload = decodeToken(token);
|
||||
if (!payload || !payload.exp) {
|
||||
return null;
|
||||
}
|
||||
return payload.exp * 1000;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get time until token expiration in milliseconds
|
||||
*/
|
||||
export function getTimeUntilExpiration(token: string): number {
|
||||
const expirationTime = getTokenExpirationTime(token);
|
||||
if (!expirationTime) {
|
||||
return 0;
|
||||
}
|
||||
return Math.max(0, expirationTime - Date.now());
|
||||
const expirationTime = getTokenExpirationTime(token);
|
||||
if (!expirationTime) {
|
||||
return 0;
|
||||
}
|
||||
return Math.max(0, expirationTime - Date.now());
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if user is B2B based on JWT claims
|
||||
*/
|
||||
export function isB2BUser(token: string): boolean {
|
||||
const payload = decodeToken(token);
|
||||
if (!payload) {
|
||||
return false;
|
||||
}
|
||||
const payload = decodeToken(token);
|
||||
if (!payload) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Handle different types for is_b2b
|
||||
return payload.is_b2b === true || payload.is_b2b === 'true' || payload.is_b2b === 1;
|
||||
// Handle different types for is_b2b
|
||||
return payload.is_b2b === true || payload.is_b2b === 'true' || payload.is_b2b === 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get B2B information from JWT claims
|
||||
*/
|
||||
export function getB2BInfo(token: string): {
|
||||
disableRevenueCat: boolean;
|
||||
organizationId?: string;
|
||||
plan?: string;
|
||||
role?: string;
|
||||
disableRevenueCat: boolean;
|
||||
organizationId?: string;
|
||||
plan?: string;
|
||||
role?: string;
|
||||
} | null {
|
||||
const payload = decodeToken(token);
|
||||
if (!payload?.app_settings?.b2b) {
|
||||
return null;
|
||||
}
|
||||
const payload = decodeToken(token);
|
||||
if (!payload?.app_settings?.b2b) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const b2bSettings = payload.app_settings.b2b;
|
||||
return {
|
||||
disableRevenueCat: !!b2bSettings.disableRevenueCat,
|
||||
organizationId: b2bSettings.organizationId,
|
||||
plan: b2bSettings.plan,
|
||||
role: b2bSettings.role,
|
||||
};
|
||||
const b2bSettings = payload.app_settings.b2b;
|
||||
return {
|
||||
disableRevenueCat: !!b2bSettings.disableRevenueCat,
|
||||
organizationId: b2bSettings.organizationId,
|
||||
plan: b2bSettings.plan,
|
||||
role: b2bSettings.role,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if RevenueCat should be disabled for this token
|
||||
*/
|
||||
export function shouldDisableRevenueCat(token: string): boolean {
|
||||
const b2bInfo = getB2BInfo(token);
|
||||
return b2bInfo?.disableRevenueCat ?? false;
|
||||
const b2bInfo = getB2BInfo(token);
|
||||
return b2bInfo?.disableRevenueCat ?? false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get app settings from JWT claims
|
||||
*/
|
||||
export function getAppSettings(token: string): Record<string, unknown> | null {
|
||||
const payload = decodeToken(token);
|
||||
return payload?.app_settings || null;
|
||||
const payload = decodeToken(token);
|
||||
return payload?.app_settings || null;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
import type {
|
||||
TokenState,
|
||||
TokenStateObserver,
|
||||
QueuedRequest,
|
||||
InternalTokenRefreshResult,
|
||||
TokenState,
|
||||
TokenStateObserver,
|
||||
QueuedRequest,
|
||||
InternalTokenRefreshResult,
|
||||
} from '../types';
|
||||
import { TokenState as TokenStateEnum } from '../types';
|
||||
import { isDeviceConnected, hasStableConnection } from '../adapters/network';
|
||||
|
|
@ -12,450 +12,459 @@ import type { AuthService } from './authService';
|
|||
* Configuration for the token manager
|
||||
*/
|
||||
export interface TokenManagerConfig {
|
||||
maxQueueSize?: number;
|
||||
queueTimeoutMs?: number;
|
||||
maxRefreshAttempts?: number;
|
||||
refreshCooldownMs?: number;
|
||||
maxQueueSize?: number;
|
||||
queueTimeoutMs?: number;
|
||||
maxRefreshAttempts?: number;
|
||||
refreshCooldownMs?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a token manager instance
|
||||
*/
|
||||
export function createTokenManager(authService: AuthService, config?: TokenManagerConfig) {
|
||||
// Configuration
|
||||
const MAX_QUEUE_SIZE = config?.maxQueueSize ?? 50;
|
||||
const QUEUE_TIMEOUT_MS = config?.queueTimeoutMs ?? 30000;
|
||||
const MAX_REFRESH_ATTEMPTS = config?.maxRefreshAttempts ?? 3;
|
||||
const REFRESH_COOLDOWN_MS = config?.refreshCooldownMs ?? 5000;
|
||||
|
||||
// State
|
||||
let state: TokenState = TokenStateEnum.IDLE;
|
||||
let refreshPromise: Promise<InternalTokenRefreshResult> | null = null;
|
||||
let requestQueue: QueuedRequest[] = [];
|
||||
const observers = new Set<TokenStateObserver>();
|
||||
let refreshAttempts = 0;
|
||||
let lastRefreshTime = 0;
|
||||
|
||||
// Internal functions
|
||||
function notifyObservers(newState: TokenState, token?: string): void {
|
||||
observers.forEach((observer) => {
|
||||
try {
|
||||
observer(newState, token);
|
||||
} catch (error) {
|
||||
console.debug('Error in token state observer:', error);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function setState(newState: TokenState, token?: string): void {
|
||||
if (state !== newState) {
|
||||
console.debug(`TokenManager: State transition ${state} -> ${newState}`);
|
||||
state = newState;
|
||||
notifyObservers(newState, token);
|
||||
}
|
||||
}
|
||||
|
||||
function removeFromQueue(requestId: string): void {
|
||||
const index = requestQueue.findIndex((item) => item.id === requestId);
|
||||
if (index !== -1) {
|
||||
requestQueue.splice(index, 1);
|
||||
}
|
||||
}
|
||||
|
||||
function isRecoverableError(error: unknown): boolean {
|
||||
if (!(error instanceof Error)) return false;
|
||||
|
||||
const networkErrors = [
|
||||
'network', 'Network', 'fetch', 'connection', 'timeout',
|
||||
'Failed to fetch', 'NetworkError', 'TypeError', 'ERR_NETWORK',
|
||||
'ERR_INTERNET_DISCONNECTED', 'ECONNREFUSED', 'ENOTFOUND',
|
||||
'ETIMEDOUT', 'Unable to resolve host', 'Request failed',
|
||||
];
|
||||
|
||||
const authErrors = [
|
||||
'401', '403', 'Unauthorized', 'Forbidden', 'Invalid token',
|
||||
'Token expired', 'jwt expired', 'jwt malformed',
|
||||
];
|
||||
|
||||
const errorString = `${error.message} ${error.name}`.toLowerCase();
|
||||
|
||||
const isNetworkError = networkErrors.some((keyword) =>
|
||||
errorString.includes(keyword.toLowerCase())
|
||||
);
|
||||
|
||||
const isAuthError = authErrors.some((keyword) =>
|
||||
errorString.includes(keyword.toLowerCase())
|
||||
);
|
||||
|
||||
return isNetworkError && !isAuthError;
|
||||
}
|
||||
|
||||
async function handleRefreshFailure(): Promise<void> {
|
||||
console.debug('TokenManager: Handling permanent refresh failure');
|
||||
try {
|
||||
await authService.clearAuthStorage();
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
} catch (error) {
|
||||
console.debug('Error in handleRefreshFailure:', error);
|
||||
}
|
||||
}
|
||||
|
||||
async function performTokenRefresh(): Promise<InternalTokenRefreshResult> {
|
||||
try {
|
||||
console.debug('TokenManager: Starting token refresh');
|
||||
|
||||
const isOnline = await isDeviceConnected();
|
||||
if (!isOnline) {
|
||||
console.debug('TokenManager: Device offline, skipping refresh');
|
||||
const currentToken = await authService.getAppToken();
|
||||
if (currentToken) {
|
||||
setState(TokenStateEnum.EXPIRED_OFFLINE, currentToken);
|
||||
}
|
||||
return { success: false, error: 'offline', shouldPreserveAuth: true };
|
||||
}
|
||||
|
||||
const isStable = await hasStableConnection();
|
||||
if (!isStable) {
|
||||
console.debug('TokenManager: Connection not stable yet, will retry');
|
||||
return { success: false, error: 'unstable_connection' };
|
||||
}
|
||||
|
||||
const refreshToken = await authService.getRefreshToken();
|
||||
if (!refreshToken) {
|
||||
throw new Error('No refresh token available');
|
||||
}
|
||||
|
||||
const refreshResult = await authService.refreshTokens(refreshToken);
|
||||
const { appToken } = refreshResult;
|
||||
|
||||
console.debug('TokenManager: Token refresh successful');
|
||||
return { success: true, token: appToken };
|
||||
} catch (error) {
|
||||
console.debug('TokenManager: Token refresh failed:', error);
|
||||
|
||||
const isRecoverable = isRecoverableError(error);
|
||||
if (!isRecoverable) {
|
||||
await handleRefreshFailure();
|
||||
}
|
||||
|
||||
return {
|
||||
success: false,
|
||||
error: error instanceof Error ? error.message : 'Unknown refresh error',
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
async function performTokenRefreshWithRetry(): Promise<InternalTokenRefreshResult> {
|
||||
const retryDelays = [0, 1000, 2000, 5000];
|
||||
let lastError: unknown = null;
|
||||
|
||||
for (let attempt = 0; attempt < retryDelays.length; attempt++) {
|
||||
try {
|
||||
if (retryDelays[attempt] > 0) {
|
||||
console.debug(
|
||||
`TokenManager: Retrying token refresh in ${retryDelays[attempt]}ms (attempt ${attempt + 1}/${retryDelays.length})`
|
||||
);
|
||||
await new Promise((resolve) => setTimeout(resolve, retryDelays[attempt]));
|
||||
}
|
||||
|
||||
const result = await performTokenRefresh();
|
||||
|
||||
if (result.success) {
|
||||
return result;
|
||||
}
|
||||
|
||||
// Non-retryable errors
|
||||
if (
|
||||
result.error === 'invalid_token' ||
|
||||
result.error === 'token_expired' ||
|
||||
result.error?.includes('Device ID has changed')
|
||||
) {
|
||||
return result;
|
||||
}
|
||||
|
||||
if (result.error === 'offline') {
|
||||
return { success: false, error: 'offline', shouldPreserveAuth: true };
|
||||
}
|
||||
|
||||
if (result.error === 'unstable_connection') {
|
||||
await new Promise((resolve) => setTimeout(resolve, 2000));
|
||||
}
|
||||
|
||||
lastError = new Error(result.error || 'Token refresh failed');
|
||||
|
||||
if (attempt === retryDelays.length - 1) break;
|
||||
} catch (error) {
|
||||
lastError = error;
|
||||
const isRecoverable = isRecoverableError(error);
|
||||
|
||||
if (!isRecoverable || attempt === retryDelays.length - 1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
success: false,
|
||||
error: lastError instanceof Error ? lastError.message : 'All retry attempts failed',
|
||||
};
|
||||
}
|
||||
|
||||
async function processQueuedRequests(token: string): Promise<void> {
|
||||
console.debug(`TokenManager: Processing ${requestQueue.length} queued requests`);
|
||||
|
||||
const requests = [...requestQueue];
|
||||
requestQueue = [];
|
||||
|
||||
for (const request of requests) {
|
||||
try {
|
||||
const response = await retryRequestWithToken(request.input, request.init, token);
|
||||
request.resolve(response);
|
||||
} catch (error) {
|
||||
request.reject(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async function rejectQueuedRequests(error: string): Promise<void> {
|
||||
console.debug(`TokenManager: Rejecting ${requestQueue.length} queued requests`);
|
||||
|
||||
const requests = [...requestQueue];
|
||||
requestQueue = [];
|
||||
|
||||
for (const request of requests) {
|
||||
request.reject(new Error(error));
|
||||
}
|
||||
}
|
||||
|
||||
async function retryRequestWithToken(
|
||||
input: RequestInfo | URL,
|
||||
init: RequestInit | undefined,
|
||||
token: string
|
||||
): Promise<Response> {
|
||||
const headers = new Headers(init?.headers || {});
|
||||
headers.set('Authorization', `Bearer ${token}`);
|
||||
|
||||
return fetch(input, {
|
||||
...init,
|
||||
headers,
|
||||
});
|
||||
}
|
||||
|
||||
// Public API
|
||||
const manager = {
|
||||
/**
|
||||
* Subscribe to token state changes
|
||||
*/
|
||||
subscribe(observer: TokenStateObserver): () => void {
|
||||
observers.add(observer);
|
||||
return () => observers.delete(observer);
|
||||
},
|
||||
|
||||
/**
|
||||
* Get current token state
|
||||
*/
|
||||
getState(): TokenState {
|
||||
return state;
|
||||
},
|
||||
|
||||
/**
|
||||
* Get a valid token, refreshing if necessary
|
||||
*/
|
||||
async getValidToken(): Promise<string | null> {
|
||||
const currentToken = await authService.getAppToken();
|
||||
|
||||
if (currentToken && authService.isTokenValidLocally(currentToken)) {
|
||||
setState(TokenStateEnum.VALID, currentToken);
|
||||
return currentToken;
|
||||
}
|
||||
|
||||
if (!currentToken) {
|
||||
console.debug('TokenManager: No token available, skipping refresh');
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
return null;
|
||||
}
|
||||
|
||||
const isOnline = await isDeviceConnected();
|
||||
if (!isOnline) {
|
||||
console.debug('TokenManager: Token expired while offline');
|
||||
setState(TokenStateEnum.EXPIRED_OFFLINE, currentToken);
|
||||
return currentToken;
|
||||
}
|
||||
|
||||
const refreshResult = await manager.refreshToken();
|
||||
if (refreshResult.success && refreshResult.token) {
|
||||
return refreshResult.token;
|
||||
}
|
||||
|
||||
if (refreshResult.shouldPreserveAuth) {
|
||||
setState(TokenStateEnum.EXPIRED_OFFLINE, currentToken);
|
||||
return currentToken;
|
||||
}
|
||||
|
||||
return null;
|
||||
},
|
||||
|
||||
/**
|
||||
* Handle 401 response
|
||||
*/
|
||||
async handle401Response(
|
||||
input: RequestInfo | URL,
|
||||
init?: RequestInit
|
||||
): Promise<Response> {
|
||||
if (state === TokenStateEnum.REFRESHING && refreshPromise) {
|
||||
return manager.queueRequest(input, init);
|
||||
}
|
||||
|
||||
const refreshResult = await manager.refreshToken();
|
||||
|
||||
if (refreshResult.success && refreshResult.token) {
|
||||
return retryRequestWithToken(input, init, refreshResult.token);
|
||||
}
|
||||
|
||||
throw new Error(refreshResult.error || 'Token refresh failed');
|
||||
},
|
||||
|
||||
/**
|
||||
* Queue a request during token refresh
|
||||
*/
|
||||
async queueRequest(
|
||||
input: RequestInfo | URL,
|
||||
init?: RequestInit
|
||||
): Promise<Response> {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (requestQueue.length >= MAX_QUEUE_SIZE) {
|
||||
reject(new Error('Request queue full'));
|
||||
return;
|
||||
}
|
||||
|
||||
const queueItem: QueuedRequest = {
|
||||
id: Math.random().toString(36).substring(2, 11),
|
||||
input,
|
||||
init,
|
||||
resolve,
|
||||
reject,
|
||||
timestamp: Date.now(),
|
||||
};
|
||||
|
||||
requestQueue.push(queueItem);
|
||||
|
||||
setTimeout(() => {
|
||||
removeFromQueue(queueItem.id);
|
||||
reject(new Error('Queued request timeout'));
|
||||
}, QUEUE_TIMEOUT_MS);
|
||||
});
|
||||
},
|
||||
|
||||
/**
|
||||
* Refresh the authentication token
|
||||
*/
|
||||
async refreshToken(): Promise<InternalTokenRefreshResult> {
|
||||
const now = Date.now();
|
||||
if (now - lastRefreshTime < REFRESH_COOLDOWN_MS) {
|
||||
return { success: false, error: 'Refresh cooldown active' };
|
||||
}
|
||||
|
||||
if (refreshAttempts >= MAX_REFRESH_ATTEMPTS) {
|
||||
await handleRefreshFailure();
|
||||
return { success: false, error: 'Max refresh attempts reached' };
|
||||
}
|
||||
|
||||
if (refreshPromise) {
|
||||
return refreshPromise;
|
||||
}
|
||||
|
||||
setState(TokenStateEnum.REFRESHING);
|
||||
lastRefreshTime = now;
|
||||
|
||||
refreshPromise = performTokenRefreshWithRetry();
|
||||
|
||||
try {
|
||||
const result = await refreshPromise;
|
||||
|
||||
if (result.success) {
|
||||
refreshAttempts = 0;
|
||||
setState(TokenStateEnum.VALID, result.token);
|
||||
await processQueuedRequests(result.token!);
|
||||
} else {
|
||||
refreshAttempts++;
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
await rejectQueuedRequests(result.error || 'Token refresh failed');
|
||||
}
|
||||
|
||||
return result;
|
||||
} finally {
|
||||
refreshPromise = null;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Reset the token manager state
|
||||
*/
|
||||
reset(): void {
|
||||
state = TokenStateEnum.IDLE;
|
||||
refreshPromise = null;
|
||||
refreshAttempts = 0;
|
||||
lastRefreshTime = 0;
|
||||
|
||||
const requests = [...requestQueue];
|
||||
requestQueue = [];
|
||||
|
||||
for (const request of requests) {
|
||||
request.reject(new Error('Token manager reset'));
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Clear tokens and reset state
|
||||
*/
|
||||
async clearTokens(): Promise<void> {
|
||||
try {
|
||||
await authService.clearAuthStorage();
|
||||
manager.reset();
|
||||
} catch (error) {
|
||||
console.debug('Error clearing tokens:', error);
|
||||
manager.reset();
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Get queue status for debugging
|
||||
*/
|
||||
getQueueStatus(): { size: number; state: TokenState; refreshAttempts: number } {
|
||||
return {
|
||||
size: requestQueue.length,
|
||||
state,
|
||||
refreshAttempts,
|
||||
};
|
||||
},
|
||||
|
||||
/**
|
||||
* Check initial token state
|
||||
*/
|
||||
async checkInitialState(): Promise<void> {
|
||||
try {
|
||||
const token = await authService.getAppToken();
|
||||
if (!token) {
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
return;
|
||||
}
|
||||
|
||||
if (authService.isTokenValidLocally(token)) {
|
||||
setState(TokenStateEnum.VALID, token);
|
||||
} else {
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
}
|
||||
} catch (error) {
|
||||
console.debug('Error checking initial token state:', error);
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
// Initialize
|
||||
manager.checkInitialState();
|
||||
|
||||
return manager;
|
||||
// Configuration
|
||||
const MAX_QUEUE_SIZE = config?.maxQueueSize ?? 50;
|
||||
const QUEUE_TIMEOUT_MS = config?.queueTimeoutMs ?? 30000;
|
||||
const MAX_REFRESH_ATTEMPTS = config?.maxRefreshAttempts ?? 3;
|
||||
const REFRESH_COOLDOWN_MS = config?.refreshCooldownMs ?? 5000;
|
||||
|
||||
// State
|
||||
let state: TokenState = TokenStateEnum.IDLE;
|
||||
let refreshPromise: Promise<InternalTokenRefreshResult> | null = null;
|
||||
let requestQueue: QueuedRequest[] = [];
|
||||
const observers = new Set<TokenStateObserver>();
|
||||
let refreshAttempts = 0;
|
||||
let lastRefreshTime = 0;
|
||||
|
||||
// Internal functions
|
||||
function notifyObservers(newState: TokenState, token?: string): void {
|
||||
observers.forEach((observer) => {
|
||||
try {
|
||||
observer(newState, token);
|
||||
} catch (error) {
|
||||
console.debug('Error in token state observer:', error);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function setState(newState: TokenState, token?: string): void {
|
||||
if (state !== newState) {
|
||||
console.debug(`TokenManager: State transition ${state} -> ${newState}`);
|
||||
state = newState;
|
||||
notifyObservers(newState, token);
|
||||
}
|
||||
}
|
||||
|
||||
function removeFromQueue(requestId: string): void {
|
||||
const index = requestQueue.findIndex((item) => item.id === requestId);
|
||||
if (index !== -1) {
|
||||
requestQueue.splice(index, 1);
|
||||
}
|
||||
}
|
||||
|
||||
function isRecoverableError(error: unknown): boolean {
|
||||
if (!(error instanceof Error)) return false;
|
||||
|
||||
const networkErrors = [
|
||||
'network',
|
||||
'Network',
|
||||
'fetch',
|
||||
'connection',
|
||||
'timeout',
|
||||
'Failed to fetch',
|
||||
'NetworkError',
|
||||
'TypeError',
|
||||
'ERR_NETWORK',
|
||||
'ERR_INTERNET_DISCONNECTED',
|
||||
'ECONNREFUSED',
|
||||
'ENOTFOUND',
|
||||
'ETIMEDOUT',
|
||||
'Unable to resolve host',
|
||||
'Request failed',
|
||||
];
|
||||
|
||||
const authErrors = [
|
||||
'401',
|
||||
'403',
|
||||
'Unauthorized',
|
||||
'Forbidden',
|
||||
'Invalid token',
|
||||
'Token expired',
|
||||
'jwt expired',
|
||||
'jwt malformed',
|
||||
];
|
||||
|
||||
const errorString = `${error.message} ${error.name}`.toLowerCase();
|
||||
|
||||
const isNetworkError = networkErrors.some((keyword) =>
|
||||
errorString.includes(keyword.toLowerCase())
|
||||
);
|
||||
|
||||
const isAuthError = authErrors.some((keyword) => errorString.includes(keyword.toLowerCase()));
|
||||
|
||||
return isNetworkError && !isAuthError;
|
||||
}
|
||||
|
||||
async function handleRefreshFailure(): Promise<void> {
|
||||
console.debug('TokenManager: Handling permanent refresh failure');
|
||||
try {
|
||||
await authService.clearAuthStorage();
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
} catch (error) {
|
||||
console.debug('Error in handleRefreshFailure:', error);
|
||||
}
|
||||
}
|
||||
|
||||
async function performTokenRefresh(): Promise<InternalTokenRefreshResult> {
|
||||
try {
|
||||
console.debug('TokenManager: Starting token refresh');
|
||||
|
||||
const isOnline = await isDeviceConnected();
|
||||
if (!isOnline) {
|
||||
console.debug('TokenManager: Device offline, skipping refresh');
|
||||
const currentToken = await authService.getAppToken();
|
||||
if (currentToken) {
|
||||
setState(TokenStateEnum.EXPIRED_OFFLINE, currentToken);
|
||||
}
|
||||
return { success: false, error: 'offline', shouldPreserveAuth: true };
|
||||
}
|
||||
|
||||
const isStable = await hasStableConnection();
|
||||
if (!isStable) {
|
||||
console.debug('TokenManager: Connection not stable yet, will retry');
|
||||
return { success: false, error: 'unstable_connection' };
|
||||
}
|
||||
|
||||
const refreshToken = await authService.getRefreshToken();
|
||||
if (!refreshToken) {
|
||||
throw new Error('No refresh token available');
|
||||
}
|
||||
|
||||
const refreshResult = await authService.refreshTokens(refreshToken);
|
||||
const { appToken } = refreshResult;
|
||||
|
||||
console.debug('TokenManager: Token refresh successful');
|
||||
return { success: true, token: appToken };
|
||||
} catch (error) {
|
||||
console.debug('TokenManager: Token refresh failed:', error);
|
||||
|
||||
const isRecoverable = isRecoverableError(error);
|
||||
if (!isRecoverable) {
|
||||
await handleRefreshFailure();
|
||||
}
|
||||
|
||||
return {
|
||||
success: false,
|
||||
error: error instanceof Error ? error.message : 'Unknown refresh error',
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
async function performTokenRefreshWithRetry(): Promise<InternalTokenRefreshResult> {
|
||||
const retryDelays = [0, 1000, 2000, 5000];
|
||||
let lastError: unknown = null;
|
||||
|
||||
for (let attempt = 0; attempt < retryDelays.length; attempt++) {
|
||||
try {
|
||||
if (retryDelays[attempt] > 0) {
|
||||
console.debug(
|
||||
`TokenManager: Retrying token refresh in ${retryDelays[attempt]}ms (attempt ${attempt + 1}/${retryDelays.length})`
|
||||
);
|
||||
await new Promise((resolve) => setTimeout(resolve, retryDelays[attempt]));
|
||||
}
|
||||
|
||||
const result = await performTokenRefresh();
|
||||
|
||||
if (result.success) {
|
||||
return result;
|
||||
}
|
||||
|
||||
// Non-retryable errors
|
||||
if (
|
||||
result.error === 'invalid_token' ||
|
||||
result.error === 'token_expired' ||
|
||||
result.error?.includes('Device ID has changed')
|
||||
) {
|
||||
return result;
|
||||
}
|
||||
|
||||
if (result.error === 'offline') {
|
||||
return { success: false, error: 'offline', shouldPreserveAuth: true };
|
||||
}
|
||||
|
||||
if (result.error === 'unstable_connection') {
|
||||
await new Promise((resolve) => setTimeout(resolve, 2000));
|
||||
}
|
||||
|
||||
lastError = new Error(result.error || 'Token refresh failed');
|
||||
|
||||
if (attempt === retryDelays.length - 1) break;
|
||||
} catch (error) {
|
||||
lastError = error;
|
||||
const isRecoverable = isRecoverableError(error);
|
||||
|
||||
if (!isRecoverable || attempt === retryDelays.length - 1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
success: false,
|
||||
error: lastError instanceof Error ? lastError.message : 'All retry attempts failed',
|
||||
};
|
||||
}
|
||||
|
||||
async function processQueuedRequests(token: string): Promise<void> {
|
||||
console.debug(`TokenManager: Processing ${requestQueue.length} queued requests`);
|
||||
|
||||
const requests = [...requestQueue];
|
||||
requestQueue = [];
|
||||
|
||||
for (const request of requests) {
|
||||
try {
|
||||
const response = await retryRequestWithToken(request.input, request.init, token);
|
||||
request.resolve(response);
|
||||
} catch (error) {
|
||||
request.reject(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async function rejectQueuedRequests(error: string): Promise<void> {
|
||||
console.debug(`TokenManager: Rejecting ${requestQueue.length} queued requests`);
|
||||
|
||||
const requests = [...requestQueue];
|
||||
requestQueue = [];
|
||||
|
||||
for (const request of requests) {
|
||||
request.reject(new Error(error));
|
||||
}
|
||||
}
|
||||
|
||||
async function retryRequestWithToken(
|
||||
input: RequestInfo | URL,
|
||||
init: RequestInit | undefined,
|
||||
token: string
|
||||
): Promise<Response> {
|
||||
const headers = new Headers(init?.headers || {});
|
||||
headers.set('Authorization', `Bearer ${token}`);
|
||||
|
||||
return fetch(input, {
|
||||
...init,
|
||||
headers,
|
||||
});
|
||||
}
|
||||
|
||||
// Public API
|
||||
const manager = {
|
||||
/**
|
||||
* Subscribe to token state changes
|
||||
*/
|
||||
subscribe(observer: TokenStateObserver): () => void {
|
||||
observers.add(observer);
|
||||
return () => observers.delete(observer);
|
||||
},
|
||||
|
||||
/**
|
||||
* Get current token state
|
||||
*/
|
||||
getState(): TokenState {
|
||||
return state;
|
||||
},
|
||||
|
||||
/**
|
||||
* Get a valid token, refreshing if necessary
|
||||
*/
|
||||
async getValidToken(): Promise<string | null> {
|
||||
const currentToken = await authService.getAppToken();
|
||||
|
||||
if (currentToken && authService.isTokenValidLocally(currentToken)) {
|
||||
setState(TokenStateEnum.VALID, currentToken);
|
||||
return currentToken;
|
||||
}
|
||||
|
||||
if (!currentToken) {
|
||||
console.debug('TokenManager: No token available, skipping refresh');
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
return null;
|
||||
}
|
||||
|
||||
const isOnline = await isDeviceConnected();
|
||||
if (!isOnline) {
|
||||
console.debug('TokenManager: Token expired while offline');
|
||||
setState(TokenStateEnum.EXPIRED_OFFLINE, currentToken);
|
||||
return currentToken;
|
||||
}
|
||||
|
||||
const refreshResult = await manager.refreshToken();
|
||||
if (refreshResult.success && refreshResult.token) {
|
||||
return refreshResult.token;
|
||||
}
|
||||
|
||||
if (refreshResult.shouldPreserveAuth) {
|
||||
setState(TokenStateEnum.EXPIRED_OFFLINE, currentToken);
|
||||
return currentToken;
|
||||
}
|
||||
|
||||
return null;
|
||||
},
|
||||
|
||||
/**
|
||||
* Handle 401 response
|
||||
*/
|
||||
async handle401Response(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
|
||||
if (state === TokenStateEnum.REFRESHING && refreshPromise) {
|
||||
return manager.queueRequest(input, init);
|
||||
}
|
||||
|
||||
const refreshResult = await manager.refreshToken();
|
||||
|
||||
if (refreshResult.success && refreshResult.token) {
|
||||
return retryRequestWithToken(input, init, refreshResult.token);
|
||||
}
|
||||
|
||||
throw new Error(refreshResult.error || 'Token refresh failed');
|
||||
},
|
||||
|
||||
/**
|
||||
* Queue a request during token refresh
|
||||
*/
|
||||
async queueRequest(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (requestQueue.length >= MAX_QUEUE_SIZE) {
|
||||
reject(new Error('Request queue full'));
|
||||
return;
|
||||
}
|
||||
|
||||
const queueItem: QueuedRequest = {
|
||||
id: Math.random().toString(36).substring(2, 11),
|
||||
input,
|
||||
init,
|
||||
resolve,
|
||||
reject,
|
||||
timestamp: Date.now(),
|
||||
};
|
||||
|
||||
requestQueue.push(queueItem);
|
||||
|
||||
setTimeout(() => {
|
||||
removeFromQueue(queueItem.id);
|
||||
reject(new Error('Queued request timeout'));
|
||||
}, QUEUE_TIMEOUT_MS);
|
||||
});
|
||||
},
|
||||
|
||||
/**
|
||||
* Refresh the authentication token
|
||||
*/
|
||||
async refreshToken(): Promise<InternalTokenRefreshResult> {
|
||||
const now = Date.now();
|
||||
if (now - lastRefreshTime < REFRESH_COOLDOWN_MS) {
|
||||
return { success: false, error: 'Refresh cooldown active' };
|
||||
}
|
||||
|
||||
if (refreshAttempts >= MAX_REFRESH_ATTEMPTS) {
|
||||
await handleRefreshFailure();
|
||||
return { success: false, error: 'Max refresh attempts reached' };
|
||||
}
|
||||
|
||||
if (refreshPromise) {
|
||||
return refreshPromise;
|
||||
}
|
||||
|
||||
setState(TokenStateEnum.REFRESHING);
|
||||
lastRefreshTime = now;
|
||||
|
||||
refreshPromise = performTokenRefreshWithRetry();
|
||||
|
||||
try {
|
||||
const result = await refreshPromise;
|
||||
|
||||
if (result.success) {
|
||||
refreshAttempts = 0;
|
||||
setState(TokenStateEnum.VALID, result.token);
|
||||
await processQueuedRequests(result.token!);
|
||||
} else {
|
||||
refreshAttempts++;
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
await rejectQueuedRequests(result.error || 'Token refresh failed');
|
||||
}
|
||||
|
||||
return result;
|
||||
} finally {
|
||||
refreshPromise = null;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Reset the token manager state
|
||||
*/
|
||||
reset(): void {
|
||||
state = TokenStateEnum.IDLE;
|
||||
refreshPromise = null;
|
||||
refreshAttempts = 0;
|
||||
lastRefreshTime = 0;
|
||||
|
||||
const requests = [...requestQueue];
|
||||
requestQueue = [];
|
||||
|
||||
for (const request of requests) {
|
||||
request.reject(new Error('Token manager reset'));
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Clear tokens and reset state
|
||||
*/
|
||||
async clearTokens(): Promise<void> {
|
||||
try {
|
||||
await authService.clearAuthStorage();
|
||||
manager.reset();
|
||||
} catch (error) {
|
||||
console.debug('Error clearing tokens:', error);
|
||||
manager.reset();
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Get queue status for debugging
|
||||
*/
|
||||
getQueueStatus(): { size: number; state: TokenState; refreshAttempts: number } {
|
||||
return {
|
||||
size: requestQueue.length,
|
||||
state,
|
||||
refreshAttempts,
|
||||
};
|
||||
},
|
||||
|
||||
/**
|
||||
* Check initial token state
|
||||
*/
|
||||
async checkInitialState(): Promise<void> {
|
||||
try {
|
||||
const token = await authService.getAppToken();
|
||||
if (!token) {
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
return;
|
||||
}
|
||||
|
||||
if (authService.isTokenValidLocally(token)) {
|
||||
setState(TokenStateEnum.VALID, token);
|
||||
} else {
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
}
|
||||
} catch (error) {
|
||||
console.debug('Error checking initial token state:', error);
|
||||
setState(TokenStateEnum.EXPIRED);
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
// Initialize
|
||||
manager.checkInitialState();
|
||||
|
||||
return manager;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue