@oxyhq/services 5.26.4 → 6.0.0

package/src/utils/sessionUtils.ts

@@ -1,206 +0,0 @@
-/**
- * Session management utilities
- * 
- * Provides consistent session normalization, deduplication, and sorting
- * to ensure sessions are always displayed in a predictable order.
- */
-
-import type { ClientSession } from '../models/session';
-
-/**
- * Normalize a session to ensure all required fields are present
- */
-export function normalizeSession(session: Partial<ClientSession> & { sessionId: string }): ClientSession {
-  const now = new Date().toISOString();
-  return {
-    sessionId: session.sessionId,
-    deviceId: session.deviceId || '',
-    expiresAt: session.expiresAt || now,
-    lastActive: session.lastActive || now,
-    userId: session.userId || '',
-  };
-}
-
-/**
- * Compare two sessions for equality
- */
-export function sessionsEqual(a: ClientSession, b: ClientSession): boolean {
-  return a.sessionId === b.sessionId;
-}
-
-/**
- * Sort sessions by lastActive (most recent first), then by sessionId for stability
- */
-export function sortSessions(sessions: ClientSession[]): ClientSession[] {
-  return [...sessions].sort((a, b) => {
-    // Sort by lastActive descending (most recent first)
-    const timeA = new Date(a.lastActive).getTime();
-    const timeB = new Date(b.lastActive).getTime();
-    if (timeA !== timeB) {
-      return timeB - timeA; // Descending order
-    }
-    // If lastActive is the same, sort by sessionId for stability
-    return a.sessionId.localeCompare(b.sessionId);
-  });
-}
-
-/**
- * Deduplicate sessions by sessionId, keeping the most recent version
- */
-export function deduplicateSessions(sessions: ClientSession[]): ClientSession[] {
-  const sessionMap = new Map<string, ClientSession>();
-  
-  for (const session of sessions) {
-    const existing = sessionMap.get(session.sessionId);
-    if (!existing) {
-      sessionMap.set(session.sessionId, session);
-    } else {
-      // Keep the one with more recent lastActive
-      const existingTime = new Date(existing.lastActive).getTime();
-      const currentTime = new Date(session.lastActive).getTime();
-      if (currentTime > existingTime) {
-        sessionMap.set(session.sessionId, session);
-      }
-    }
-  }
-  
-  return Array.from(sessionMap.values());
-}
-
-/**
- * Deduplicate sessions by userId, keeping only one session per user
- * Priority: 1) Active session (if provided), 2) Most recent session
- * This prevents showing duplicate accounts for the same user
- */
-export function deduplicateSessionsByUserId(
-  sessions: ClientSession[],
-  activeSessionId?: string | null
-): ClientSession[] {
-  if (!sessions.length) return [];
-  
-  const userSessionMap = new Map<string, ClientSession>();
-  
-  for (const session of sessions) {
-    if (!session.userId) continue; // Skip sessions without userId
-    
-    const existing = userSessionMap.get(session.userId);
-    if (!existing) {
-      userSessionMap.set(session.userId, session);
-    } else {
-      // Prioritize active session
-      const isCurrentActive = activeSessionId && session.sessionId === activeSessionId;
-      const isExistingActive = activeSessionId && existing.sessionId === activeSessionId;
-      
-      if (isCurrentActive && !isExistingActive) {
-        userSessionMap.set(session.userId, session);
-      } else if (!isCurrentActive && isExistingActive) {
-        // Keep existing (active) session
-        continue;
-      } else {
-        // Neither is active, keep the one with more recent lastActive
-        const existingTime = new Date(existing.lastActive).getTime();
-        const currentTime = new Date(session.lastActive).getTime();
-        if (currentTime > existingTime) {
-          userSessionMap.set(session.userId, session);
-        }
-      }
-    }
-  }
-  
-  return Array.from(userSessionMap.values());
-}
-
-/**
- * Normalize, deduplicate, and sort sessions
- * This ensures consistent session ordering across the application
- * 
- * @param sessions - Array of sessions to normalize
- * @param activeSessionId - Optional active session ID to prioritize
- * @param deduplicateByUserId - If true, deduplicate by userId (one account per user). Default: true
- */
-export function normalizeAndSortSessions(
-  sessions: ClientSession[],
-  activeSessionId?: string | null,
-  deduplicateByUserId: boolean = true
-): ClientSession[] {
-  if (!sessions.length) return [];
-  
-  // Normalize all sessions
-  const normalized = sessions.map(normalizeSession);
-  
-  // First deduplicate by sessionId (exact duplicates)
-  const deduplicatedBySessionId = deduplicateSessions(normalized);
-  
-  // Then deduplicate by userId if requested (one account per user)
-  const finalSessions = deduplicateByUserId
-    ? deduplicateSessionsByUserId(deduplicatedBySessionId, activeSessionId)
-    : deduplicatedBySessionId;
-  
-  // Sort consistently
-  return sortSessions(finalSessions);
-}
-
-/**
- * Merge two session arrays, prioritizing newer data
- * Returns normalized, deduplicated, and sorted sessions
- * 
- * @param existing - Existing sessions array
- * @param incoming - New sessions to merge in
- * @param activeSessionId - Optional active session ID to prioritize
- * @param deduplicateByUserId - If true, deduplicate by userId (one account per user). Default: true
- */
-export function mergeSessions(
-  existing: ClientSession[],
-  incoming: ClientSession[],
-  activeSessionId?: string | null,
-  deduplicateByUserId: boolean = true
-): ClientSession[] {
-  if (!existing.length && !incoming.length) return [];
-  if (!existing.length) return normalizeAndSortSessions(incoming, activeSessionId, deduplicateByUserId);
-  if (!incoming.length) return normalizeAndSortSessions(existing, activeSessionId, deduplicateByUserId);
-  
-  // Normalize both arrays
-  const normalizedExisting = existing.map(normalizeSession);
-  const normalizedIncoming = incoming.map(normalizeSession);
-  
-  // Create a map with existing sessions (by sessionId)
-  const sessionMap = new Map<string, ClientSession>();
-  
-  // Add existing sessions first
-  for (const session of normalizedExisting) {
-    sessionMap.set(session.sessionId, session);
-  }
-  
-  // Merge incoming sessions - backend data always replaces existing
-  for (const session of normalizedIncoming) {
-    sessionMap.set(session.sessionId, session);
-  }
-  
-  // Convert to array
-  const merged = Array.from(sessionMap.values());
-  
-  // Apply userId deduplication if requested
-  const finalSessions = deduplicateByUserId
-    ? deduplicateSessionsByUserId(merged, activeSessionId)
-    : merged;
-  
-  // Sort consistently
-  return sortSessions(finalSessions);
-}
-
-/**
- * Check if two session arrays are equal (same sessionIds in same order)
- */
-export function sessionsArraysEqual(a: ClientSession[], b: ClientSession[]): boolean {
-  if (a.length !== b.length) {
-    return false;
-  }
-  
-  const sortedA = sortSessions(a);
-  const sortedB = sortSessions(b);
-  
-  return sortedA.every((session, index) => 
-    sessionsEqual(session, sortedB[index])
-  );
-}
-

package/src/utils/validationUtils.ts

@@ -1,174 +0,0 @@
-/**
- * Validation utilities for common data validation patterns
- */
-
-/**
- * Email validation regex
- */
-export const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-
-/**
- * Username validation regex (alphanumeric, underscores, and hyphens, 3-30 chars)
- */
-export const USERNAME_REGEX = /^[a-zA-Z0-9_-]{3,30}$/;
-
-/**
- * Password validation regex (at least 8 chars, 1 uppercase, 1 lowercase, 1 number)
- */
-// At least 8 characters (tests expect len>=8 without complexity requirements)
-export const PASSWORD_REGEX = /^.{8,}$/;
-
-/**
- * Validate email format
- */
-export function isValidEmail(email: string): boolean {
-  return EMAIL_REGEX.test(email);
-}
-
-/**
- * Validate username format
- */
-export function isValidUsername(username: string): boolean {
-  return USERNAME_REGEX.test(username);
-}
-
-/**
- * Validate password strength
- */
-export function isValidPassword(password: string): boolean {
-  return PASSWORD_REGEX.test(password);
-}
-
-/**
- * Validate required string
- */
-export function isRequiredString(value: unknown): boolean {
-  return typeof value === 'string' && value.trim().length > 0;
-}
-
-/**
- * Validate required number
- */
-export function isRequiredNumber(value: unknown): boolean {
-  return typeof value === 'number' && !Number.isNaN(value);
-}
-
-/**
- * Validate required boolean
- */
-export function isRequiredBoolean(value: unknown): boolean {
-  return typeof value === 'boolean';
-}
-
-/**
- * Validate array
- */
-export function isValidArray(value: unknown): boolean {
-  return Array.isArray(value);
-}
-
-/**
- * Validate object
- */
-export function isValidObject(value: unknown): boolean {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-/**
- * Validate UUID format
- */
-export function isValidUUID(uuid: string): boolean {
-  const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-  return UUID_REGEX.test(uuid);
-}
-
-/**
- * Validate URL format
- */
-export function isValidURL(url: string): boolean {
-  try {
-    new URL(url);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Validate date string
- */
-export function isValidDate(dateString: string): boolean {
-  const date = new Date(dateString);
-  return !Number.isNaN(date.getTime());
-}
-
-/**
- * Validate file size (in bytes)
- */
-export function isValidFileSize(size: number, maxSize: number): boolean {
-  return size > 0 && size <= maxSize;
-}
-
-/**
- * Validate file type
- */
-export function isValidFileType(filename: string, allowedTypes: string[]): boolean {
-  const extension = filename.split('.').pop()?.toLowerCase();
-  return extension ? allowedTypes.includes(extension) : false;
-}
-
-/**
- * Sanitize string input
- */
-export function sanitizeString(input: string): string {
-  // Remove HTML tags entirely and trim whitespace
-  return input.trim().replace(/<[^>]*>/g, '');
-}
-
-/**
- * Sanitize HTML input
- */
-export function sanitizeHTML(input: string): string {
-  return input
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#x27;');
-}
-
-/**
- * Validate MongoDB ObjectId format
- * Note: This is a basic format check. For full validation, use mongoose.Types.ObjectId.isValid()
- * This function works in environments where mongoose may not be available (e.g., client-side)
- */
-export function isValidObjectId(id: string): boolean {
-  if (typeof id !== 'string') {
-    return false;
-  }
-  // MongoDB ObjectId is 24 hex characters
-  const OBJECT_ID_REGEX = /^[0-9a-fA-F]{24}$/;
-  return OBJECT_ID_REGEX.test(id);
-}
-
-/**
- * Validate and sanitize user input
- */
-export function validateAndSanitizeUserInput(input: unknown, type: 'string' | 'email' | 'username'): string | null {
-  if (typeof input !== 'string') {
-    return null;
-  }
-
-  const sanitized = sanitizeString(input);
-  
-  switch (type) {
-    case 'email':
-      return isValidEmail(sanitized) ? sanitized : null;
-    case 'username':
-      return isValidUsername(sanitized) ? sanitized : null;
-    case 'string':
-      return isRequiredString(sanitized) ? sanitized : null;
-    default:
-      return null;
-  }
-}