@djangocfg/api 2.1.10 → 2.1.15

package/src/auth/hooks/useLocalStorage.ts

@@ -0,0 +1,214 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import { authLogger } from '../utils/logger';
+
+/**
+ * Simple localStorage hook with better error handling
+ * @param key - Storage key
+ * @param initialValue - Default value if key doesn't exist
+ * @returns [value, setValue, removeValue] - Current value, setter function, and remove function
+ */
+export function useLocalStorage<T>(key: string, initialValue: T) {
+  // Get initial value from localStorage or use provided initialValue
+  const [storedValue, setStoredValue] = useState<T>(() => {
+    if (typeof window === 'undefined') {
+      return initialValue;
+    }
+
+    try {
+      const item = window.localStorage.getItem(key);
+      if (item === null) {
+        return initialValue;
+      }
+      
+      // Try to parse as JSON first, fallback to string
+      try {
+        return JSON.parse(item);
+      } catch {
+        // If JSON.parse fails, return as string
+        return item as T;
+      }
+    } catch (error) {
+      authLogger.error(`Error reading localStorage key "${key}":`, error);
+      return initialValue;
+    }
+  });
+
+  // Check data size and limit
+  const checkDataSize = (data: any): boolean => {
+    try {
+      const jsonString = JSON.stringify(data);
+      const sizeInBytes = new Blob([jsonString]).size;
+      const sizeInKB = sizeInBytes / 1024;
+      
+      // Limit to 1MB per item
+      if (sizeInKB > 1024) {
+        authLogger.warn(`Data size (${sizeInKB.toFixed(2)}KB) exceeds 1MB limit for key "${key}"`);
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      authLogger.error(`Error checking data size for key "${key}":`, error);
+      return false;
+    }
+  };
+
+  // Clear old data when localStorage is full
+  const clearOldData = () => {
+    try {
+      const keys = Object.keys(localStorage).filter(key => key && typeof key === 'string');
+      // Remove oldest items if we have more than 50 items
+      if (keys.length > 50) {
+        const itemsToRemove = Math.ceil(keys.length * 0.2);
+        for (let i = 0; i < itemsToRemove; i++) {
+          try {
+            const key = keys[i];
+            if (key) {
+              localStorage.removeItem(key);
+              localStorage.removeItem(`${key}_timestamp`);
+            }
+          } catch {
+            // Ignore errors when removing items
+          }
+        }
+      }
+    } catch (error) {
+      authLogger.error('Error clearing old localStorage data:', error);
+    }
+  };
+
+  // Force clear all data if quota is exceeded
+  const forceClearAll = () => {
+    try {
+      const keys = Object.keys(localStorage);
+      for (const key of keys) {
+        try {
+          localStorage.removeItem(key);
+        } catch {
+          // Ignore errors when removing items
+        }
+      }
+    } catch (error) {
+      authLogger.error('Error force clearing localStorage:', error);
+    }
+  };
+
+  // Update localStorage when value changes
+  const setValue = (value: T | ((val: T) => T)) => {
+    try {
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      
+      // Check data size before attempting to save
+      if (!checkDataSize(valueToStore)) {
+        authLogger.warn(`Data size too large for key "${key}", removing key`);
+        // Remove the key if data is too large
+        try {
+          window.localStorage.removeItem(key);
+          window.localStorage.removeItem(`${key}_timestamp`);
+        } catch {
+          // Ignore errors when removing
+        }
+        // Still update the state
+        setStoredValue(valueToStore);
+        return;
+      }
+      
+      setStoredValue(valueToStore);
+
+      if (typeof window !== 'undefined') {
+        // Try to set the value
+        try {
+          // For strings, store directly without JSON.stringify
+          if (typeof valueToStore === 'string') {
+            window.localStorage.setItem(key, valueToStore);
+          } else {
+            window.localStorage.setItem(key, JSON.stringify(valueToStore));
+          }
+          // Add timestamp for cleanup
+          window.localStorage.setItem(`${key}_timestamp`, Date.now().toString());
+        } catch (storageError: any) {
+          // If quota exceeded, clear old data and try again
+          if (storageError.name === 'QuotaExceededError' ||
+              storageError.code === 22 ||
+              storageError.message?.includes('quota')) {
+            authLogger.warn('localStorage quota exceeded, clearing old data...');
+            clearOldData();
+            
+            // Try again after clearing
+            try {
+              // For strings, store directly without JSON.stringify
+              if (typeof valueToStore === 'string') {
+                window.localStorage.setItem(key, valueToStore);
+              } else {
+                window.localStorage.setItem(key, JSON.stringify(valueToStore));
+              }
+              window.localStorage.setItem(`${key}_timestamp`, Date.now().toString());
+            } catch (retryError) {
+              authLogger.error(`Failed to set localStorage key "${key}" after clearing old data:`, retryError);
+              // If still fails, force clear all and try one more time
+              try {
+                forceClearAll();
+                // For strings, store directly without JSON.stringify
+                if (typeof valueToStore === 'string') {
+                  window.localStorage.setItem(key, valueToStore);
+                } else {
+                  window.localStorage.setItem(key, JSON.stringify(valueToStore));
+                }
+                window.localStorage.setItem(`${key}_timestamp`, Date.now().toString());
+              } catch (finalError) {
+                authLogger.error(`Failed to set localStorage key "${key}" after force clearing:`, finalError);
+                // If still fails, just update the state without localStorage
+                setStoredValue(valueToStore);
+              }
+            }
+          } else {
+            throw storageError;
+          }
+        }
+      }
+    } catch (error) {
+      authLogger.error(`Error setting localStorage key "${key}":`, error);
+      // Still update the state even if localStorage fails
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      setStoredValue(valueToStore);
+    }
+  };
+
+  // Remove value from localStorage
+  const removeValue = () => {
+    try {
+      setStoredValue(initialValue);
+      if (typeof window !== 'undefined') {
+        try {
+          window.localStorage.removeItem(key);
+          window.localStorage.removeItem(`${key}_timestamp`);
+        } catch (removeError: any) {
+          // If removal fails due to quota, try to clear some data first
+          if (removeError.name === 'QuotaExceededError' ||
+              removeError.code === 22 ||
+              removeError.message?.includes('quota')) {
+            authLogger.warn('localStorage quota exceeded during removal, clearing old data...');
+            clearOldData();
+            
+            try {
+              window.localStorage.removeItem(key);
+              window.localStorage.removeItem(`${key}_timestamp`);
+            } catch (retryError) {
+              authLogger.error(`Failed to remove localStorage key "${key}" after clearing:`, retryError);
+              // If still fails, force clear all
+              forceClearAll();
+            }
+          } else {
+            throw removeError;
+          }
+        }
+      }
+    } catch (error) {
+      authLogger.error(`Error removing localStorage key "${key}":`, error);
+    }
+  };
+
+  return [storedValue, setValue, removeValue] as const;
+}

package/src/auth/hooks/useProfileCache.ts

@@ -0,0 +1,146 @@
+"use client"
+
+/**
+ * Profile Cache Hook
+ *
+ * Provides localStorage-based caching for user profile with:
+ * - TTL (Time To Live) - default 1 hour
+ * - Version control for migrations
+ * - Automatic invalidation on expiry
+ */
+
+import type { User } from '../../';
+import { authLogger as profileLogger } from '../utils/logger';
+
+// Cache configuration
+const CACHE_KEY = 'user_profile_cache';
+const CACHE_VERSION = 1;
+const DEFAULT_TTL = 3600000; // 1 hour in milliseconds
+
+export interface ProfileCacheOptions {
+  /** Time to live in milliseconds (default: 1 hour) */
+  ttl?: number;
+}
+
+interface CachedProfile {
+  version: number;
+  data: User;
+  timestamp: number;
+  ttl: number;
+}
+
+/**
+ * Get cached profile from localStorage
+ * @returns User profile if valid cache exists, null otherwise
+ */
+export function getCachedProfile(): User | null {
+  try {
+    if (typeof window === 'undefined') return null;
+
+    const cached = localStorage.getItem(CACHE_KEY);
+    if (!cached) {
+      profileLogger.debug('No cached profile found');
+      return null;
+    }
+
+    const cachedData: CachedProfile = JSON.parse(cached);
+
+    // Version check
+    if (cachedData.version !== CACHE_VERSION) {
+      profileLogger.warn('Cache version mismatch, clearing cache');
+      clearProfileCache();
+      return null;
+    }
+
+    // TTL check
+    const now = Date.now();
+    const age = now - cachedData.timestamp;
+    if (age > cachedData.ttl) {
+      profileLogger.info('Cache expired, clearing');
+      clearProfileCache();
+      return null;
+    }
+
+    profileLogger.debug('Cache hit, age:', Math.round(age / 1000), 'seconds');
+    return cachedData.data;
+  } catch (error) {
+    profileLogger.error('Error reading cache:', error);
+    clearProfileCache();
+    return null;
+  }
+}
+
+/**
+ * Save profile to localStorage cache
+ * @param profile - User profile to cache
+ * @param options - Cache options (TTL)
+ */
+export function setCachedProfile(profile: User, options?: ProfileCacheOptions): void {
+  try {
+    if (typeof window === 'undefined') return;
+
+    const cachedData: CachedProfile = {
+      version: CACHE_VERSION,
+      data: profile,
+      timestamp: Date.now(),
+      ttl: options?.ttl || DEFAULT_TTL,
+    };
+
+    localStorage.setItem(CACHE_KEY, JSON.stringify(cachedData));
+    profileLogger.debug('Profile cached, TTL:', cachedData.ttl / 1000, 'seconds');
+  } catch (error) {
+    profileLogger.error('Error writing cache:', error);
+  }
+}
+
+/**
+ * Clear profile cache from localStorage
+ */
+export function clearProfileCache(): void {
+  try {
+    if (typeof window === 'undefined') return;
+    localStorage.removeItem(CACHE_KEY);
+    profileLogger.debug('Cache cleared');
+  } catch (error) {
+    profileLogger.error('Error clearing cache:', error);
+  }
+}
+
+/**
+ * Check if cached profile is valid (exists and not expired)
+ */
+export function hasValidCache(): boolean {
+  return getCachedProfile() !== null;
+}
+
+/**
+ * Get cache metadata (age, TTL, etc.)
+ */
+export function getCacheMetadata(): {
+  exists: boolean;
+  age?: number;
+  ttl?: number;
+  expiresIn?: number;
+} | null {
+  try {
+    if (typeof window === 'undefined') return null;
+
+    const cached = localStorage.getItem(CACHE_KEY);
+    if (!cached) return { exists: false };
+
+    const cachedData: CachedProfile = JSON.parse(cached);
+    const now = Date.now();
+    const age = now - cachedData.timestamp;
+    const expiresIn = cachedData.ttl - age;
+
+    return {
+      exists: true,
+      age,
+      ttl: cachedData.ttl,
+      expiresIn: Math.max(0, expiresIn),
+    };
+  } catch (error) {
+    profileLogger.error('Error reading metadata:', error);
+    return null;
+  }
+}

package/src/auth/hooks/useSessionStorage.ts

@@ -0,0 +1,189 @@
+'use client';
+
+import { useState } from 'react';
+import { authLogger } from '../utils/logger';
+
+/**
+ * Simple sessionStorage hook with better error handling
+ * @param key - Storage key
+ * @param initialValue - Default value if key doesn't exist
+ * @returns [value, setValue, removeValue] - Current value, setter function, and remove function
+ */
+export function useSessionStorage<T>(key: string, initialValue: T) {
+  // Get initial value from sessionStorage or use provided initialValue
+  const [storedValue, setStoredValue] = useState<T>(() => {
+    if (typeof window === 'undefined') {
+      return initialValue;
+    }
+
+    try {
+      const item = window.sessionStorage.getItem(key);
+      return item ? JSON.parse(item) : initialValue;
+    } catch (error) {
+      authLogger.error(`Error reading sessionStorage key "${key}":`, error);
+      return initialValue;
+    }
+  });
+
+  // Check data size and limit
+  const checkDataSize = (data: any): boolean => {
+    try {
+      const jsonString = JSON.stringify(data);
+      const sizeInBytes = new Blob([jsonString]).size;
+      const sizeInKB = sizeInBytes / 1024;
+      
+      // Limit to 1MB per item
+      if (sizeInKB > 1024) {
+        authLogger.warn(`Data size (${sizeInKB.toFixed(2)}KB) exceeds 1MB limit for key "${key}"`);
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      authLogger.error(`Error checking data size for key "${key}":`, error);
+      return false;
+    }
+  };
+
+  // Clear old data when sessionStorage is full
+  const clearOldData = () => {
+    try {
+      const keys = Object.keys(sessionStorage).filter(key => key && typeof key === 'string');
+      // Remove oldest items if we have more than 50 items
+      if (keys.length > 50) {
+        const itemsToRemove = Math.ceil(keys.length * 0.2);
+        for (let i = 0; i < itemsToRemove; i++) {
+          try {
+            const key = keys[i];
+            if (key) {
+              sessionStorage.removeItem(key);
+              sessionStorage.removeItem(`${key}_timestamp`);
+            }
+          } catch {
+            // Ignore errors when removing items
+          }
+        }
+      }
+    } catch (error) {
+      authLogger.error('Error clearing old sessionStorage data:', error);
+    }
+  };
+
+  // Force clear all data if quota is exceeded
+  const forceClearAll = () => {
+    try {
+      const keys = Object.keys(sessionStorage);
+      for (const key of keys) {
+        try {
+          sessionStorage.removeItem(key);
+        } catch {
+          // Ignore errors when removing items
+        }
+      }
+    } catch (error) {
+      authLogger.error('Error force clearing sessionStorage:', error);
+    }
+  };
+
+  // Update sessionStorage when value changes
+  const setValue = (value: T | ((val: T) => T)) => {
+    try {
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      
+      // Check data size before attempting to save
+      if (!checkDataSize(valueToStore)) {
+        authLogger.warn(`Data size too large for key "${key}", removing key`);
+        // Remove the key if data is too large
+        try {
+          window.sessionStorage.removeItem(key);
+          window.sessionStorage.removeItem(`${key}_timestamp`);
+        } catch {
+          // Ignore errors when removing
+        }
+        // Still update the state
+        setStoredValue(valueToStore);
+        return;
+      }
+      
+      setStoredValue(valueToStore);
+
+      if (typeof window !== 'undefined') {
+        // Try to set the value
+        try {
+          window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
+          // Add timestamp for cleanup
+          window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
+        } catch (storageError: any) {
+          // If quota exceeded, clear old data and try again
+          if (storageError.name === 'QuotaExceededError' ||
+              storageError.code === 22 ||
+              storageError.message?.includes('quota')) {
+            authLogger.warn('sessionStorage quota exceeded, clearing old data...');
+            clearOldData();
+            
+            // Try again after clearing
+            try {
+              window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
+              window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
+            } catch (retryError) {
+              authLogger.error(`Failed to set sessionStorage key "${key}" after clearing old data:`, retryError);
+              // If still fails, force clear all and try one more time
+              try {
+                forceClearAll();
+                window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
+                window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
+              } catch (finalError) {
+                authLogger.error(`Failed to set sessionStorage key "${key}" after force clearing:`, finalError);
+                // If still fails, just update the state without sessionStorage
+                setStoredValue(valueToStore);
+              }
+            }
+          } else {
+            throw storageError;
+          }
+        }
+      }
+    } catch (error) {
+      authLogger.error(`Error setting sessionStorage key "${key}":`, error);
+      // Still update the state even if sessionStorage fails
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      setStoredValue(valueToStore);
+    }
+  };
+
+  // Remove value from sessionStorage
+  const removeValue = () => {
+    try {
+      setStoredValue(initialValue);
+      if (typeof window !== 'undefined') {
+        try {
+          window.sessionStorage.removeItem(key);
+          window.sessionStorage.removeItem(`${key}_timestamp`);
+        } catch (removeError: any) {
+          // If removal fails due to quota, try to clear some data first
+          if (removeError.name === 'QuotaExceededError' ||
+              removeError.code === 22 ||
+              removeError.message?.includes('quota')) {
+            authLogger.warn('sessionStorage quota exceeded during removal, clearing old data...');
+            clearOldData();
+            
+            try {
+              window.sessionStorage.removeItem(key);
+              window.sessionStorage.removeItem(`${key}_timestamp`);
+            } catch (retryError) {
+              authLogger.error(`Failed to remove sessionStorage key "${key}" after clearing:`, retryError);
+              // If still fails, force clear all
+              forceClearAll();
+            }
+          } else {
+            throw removeError;
+          }
+        }
+      }
+    } catch (error) {
+      authLogger.error(`Error removing sessionStorage key "${key}":`, error);
+    }
+  };
+
+  return [storedValue, setValue, removeValue] as const;
+}

package/src/auth/index.ts

@@ -0,0 +1,34 @@
+/**
+ * @djangocfg/api/auth
+ *
+ * Authentication module with contexts, hooks and utilities.
+ * Use this entry point in client components.
+ *
+ * @example
+ * ```tsx
+ * 'use client';
+ * import { AuthProvider, useAuth } from '@djangocfg/api/auth';
+ *
+ * export function MyApp({ children }) {
+ *   return (
+ *     <AuthProvider>
+ *       {children}
+ *     </AuthProvider>
+ *   );
+ * }
+ *
+ * export function Profile() {
+ *   const { user, logout } = useAuth();
+ *   return <div>{user?.email}</div>;
+ * }
+ * ```
+ */
+
+// Contexts
+export * from './context';
+
+// Hooks
+export * from './hooks';
+
+// Utils (validation, errors, analytics)
+export * from './utils';

package/src/auth/middlewares/index.ts

@@ -0,0 +1 @@
+export { proxyMiddleware, proxyMiddlewareConfig } from './proxy'; 

package/src/auth/middlewares/proxy.ts

@@ -0,0 +1,32 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+/**
+ * Proxy middleware for media and API endpoints
+ * Use this in your middleware.ts file
+ */
+export function proxyMiddleware(request: NextRequest) {
+  const { pathname, search } = request.nextUrl;
+  const apiUrl = process.env.NEXT_PUBLIC_API_URL;
+
+  // Proxy /media/* - Images and static files
+  if (pathname.startsWith('/media/')) {
+    const targetUrl = `${apiUrl}${pathname}${search}`;
+    return NextResponse.rewrite(targetUrl, { request: { headers: request.headers } });
+  }
+
+  // Proxy /api/* - API endpoints
+  if (pathname.startsWith('/api/')) {
+    const targetUrl = `${apiUrl}${pathname}${search}`;
+    return NextResponse.rewrite(targetUrl, { request: { headers: request.headers } });
+  }
+
+  return NextResponse.next();
+}
+
+/**
+ * Recommended matcher config for proxy middleware
+ * Add this to your middleware.ts config
+ */
+export const proxyMiddlewareConfig = {
+  matcher: ['/media/:path*', '/api/:path*'],
+};

package/src/auth/server.ts

@@ -0,0 +1,19 @@
+/**
+ * @djangocfg/api/auth/server
+ *
+ * Server-side authentication utilities.
+ * Use this entry point in server components, API routes, and middleware.
+ *
+ * @example
+ * ```typescript
+ * // middleware.ts
+ * import { proxyMiddleware } from '@djangocfg/api/auth/server';
+ *
+ * export function middleware(request: NextRequest) {
+ *   return proxyMiddleware(request);
+ * }
+ * ```
+ */
+
+// Middlewares
+export * from './middlewares';

package/src/auth/utils/analytics.ts

@@ -0,0 +1,62 @@
+/**
+ * Analytics stub for @djangocfg/api/auth
+ * Provides minimal analytics interface without external dependencies
+ *
+ * If you need full analytics, install @djangocfg/layouts and use its Analytics module
+ */
+
+export enum AnalyticsEvent {
+  AUTH_OTP_REQUEST = 'auth_otp_request',
+  AUTH_LOGIN_SUCCESS = 'auth_login_success',
+  AUTH_OTP_VERIFY_FAIL = 'auth_otp_verify_fail',
+  AUTH_SESSION_EXPIRED = 'auth_session_expired',
+  AUTH_TOKEN_REFRESH = 'auth_token_refresh',
+  AUTH_TOKEN_REFRESH_FAIL = 'auth_token_refresh_fail',
+  AUTH_LOGOUT = 'auth_logout',
+  AUTH_OAUTH_START = 'auth_oauth_start',
+  AUTH_OAUTH_FAIL = 'auth_oauth_fail',
+}
+
+export enum AnalyticsCategory {
+  AUTH = 'auth',
+}
+
+export type AnalyticsEventType = `${AnalyticsEvent}`;
+export type AnalyticsCategoryType = `${AnalyticsCategory}`;
+
+interface AnalyticsEventParams {
+  category?: AnalyticsCategoryType;
+  label?: string;
+  value?: number;
+  [key: string]: any;
+}
+
+/**
+ * Minimal analytics implementation
+ * Logs to console in development, silent in production
+ */
+export const Analytics = {
+  /**
+   * Track an analytics event
+   */
+  event(eventName: AnalyticsEventType, params?: AnalyticsEventParams) {
+    if (process.env.NODE_ENV === 'development') {
+      console.log('[Analytics]', eventName, params);
+    }
+
+    // You can extend this to send to your analytics service
+    // Example: window.gtag?.('event', eventName, params);
+  },
+
+  /**
+   * Set user ID for tracking
+   */
+  setUser(userId: string) {
+    if (process.env.NODE_ENV === 'development') {
+      console.log('[Analytics] Set user:', userId);
+    }
+
+    // You can extend this to send to your analytics service
+    // Example: window.gtag?.('set', { user_id: userId });
+  },
+};