@oxyhq/services 5.14.0 → 5.15.0

package/src/ui/utils/sessionHelpers.ts

@@ -0,0 +1,146 @@
+import type { OxyServices } from '../../core';
+import type { ClientSession } from '../../models/session';
+
+interface DeviceSession {
+  sessionId: string;
+  deviceId?: string;
+  deviceName?: string;
+  expiresAt?: string;
+  lastActive?: string;
+  user?: { id?: string; _id?: { toString(): string } };
+  userId?: string;
+  isCurrent?: boolean;
+}
+
+export interface FetchSessionsWithFallbackOptions {
+  fallbackDeviceId?: string;
+  fallbackUserId?: string;
+  logger?: (message: string, error?: unknown) => void;
+}
+
+export interface ValidateSessionBatchOptions {
+  useHeaderValidation?: boolean;
+  maxConcurrency?: number;
+}
+
+export interface SessionValidationResult {
+  sessionId: string;
+  valid: boolean;
+  user?: unknown;
+  raw?: unknown;
+  error?: unknown;
+}
+
+/**
+ * Normalize backend session payloads into `ClientSession` objects.
+ *
+ * @param sessions - Raw session array returned from the API
+ * @param fallbackDeviceId - Device identifier to use when missing from payload
+ * @param fallbackUserId - User identifier to use when missing from payload
+ */
+export const mapSessionsToClient = (
+  sessions: DeviceSession[],
+  fallbackDeviceId?: string,
+  fallbackUserId?: string,
+): ClientSession[] => {
+  const now = new Date();
+
+  return sessions.map((session) => ({
+    sessionId: session.sessionId,
+    deviceId: session.deviceId || fallbackDeviceId || '',
+    expiresAt: session.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+    lastActive: session.lastActive || now.toISOString(),
+    userId:
+      session.user?.id ||
+      session.userId ||
+      (session.user?._id ? session.user._id.toString() : undefined) ||
+      fallbackUserId ||
+      '',
+    isCurrent: Boolean(session.isCurrent),
+  }));
+};
+
+/**
+ * Fetch device sessions with fallback to the legacy session endpoint when needed.
+ *
+ * @param oxyServices - Oxy service instance
+ * @param sessionId - Session identifier to fetch
+ * @param options - Optional fallback options
+ */
+export const fetchSessionsWithFallback = async (
+  oxyServices: Pick<OxyServices, 'getDeviceSessions' | 'getSessionsBySessionId'>,
+  sessionId: string,
+  {
+    fallbackDeviceId,
+    fallbackUserId,
+    logger,
+  }: FetchSessionsWithFallbackOptions = {},
+): Promise<ClientSession[]> => {
+  try {
+    const deviceSessions = await oxyServices.getDeviceSessions(sessionId);
+    return mapSessionsToClient(deviceSessions, fallbackDeviceId, fallbackUserId);
+  } catch (error) {
+    if (__DEV__ && logger) {
+      logger('Failed to get device sessions, falling back to user sessions', error);
+    } else if (__DEV__) {
+      console.warn('Failed to get device sessions, falling back to user sessions:', error);
+    }
+
+    const userSessions = await oxyServices.getSessionsBySessionId(sessionId);
+    return mapSessionsToClient(userSessions, fallbackDeviceId, fallbackUserId);
+  }
+};
+
+/**
+ * Validate multiple sessions concurrently with configurable concurrency.
+ *
+ * @param oxyServices - Oxy service instance
+ * @param sessionIds - Session identifiers to validate
+ * @param options - Validation options
+ */
+export const validateSessionBatch = async (
+  oxyServices: Pick<OxyServices, 'validateSession'>,
+  sessionIds: string[],
+  { useHeaderValidation = true, maxConcurrency = 5 }: ValidateSessionBatchOptions = {},
+): Promise<SessionValidationResult[]> => {
+  if (!sessionIds.length) {
+    return [];
+  }
+
+  const uniqueSessionIds = Array.from(new Set(sessionIds));
+  const safeConcurrency = Math.max(1, Math.min(maxConcurrency, uniqueSessionIds.length));
+  const results: SessionValidationResult[] = [];
+  let index = 0;
+
+  const worker = async () => {
+    while (index < uniqueSessionIds.length) {
+      const currentIndex = index;
+      index += 1;
+      const sessionId = uniqueSessionIds[currentIndex];
+
+      try {
+        const validation = await oxyServices.validateSession(sessionId, { useHeaderValidation });
+        const valid = Boolean(validation?.valid);
+
+        results.push({
+          sessionId,
+          valid,
+          user: validation?.user,
+          raw: validation,
+        });
+      } catch (error) {
+        results.push({
+          sessionId,
+          valid: false,
+          error,
+        });
+      }
+    }
+  };
+
+  await Promise.all(Array.from({ length: safeConcurrency }, worker));
+
+  return results;
+};
+
+

package/src/ui/utils/storageHelpers.ts

@@ -0,0 +1,134 @@
+export interface StorageInterface {
+  getItem: (key: string) => Promise<string | null>;
+  setItem: (key: string, value: string) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+  clear: () => Promise<void>;
+}
+
+export interface SessionStorageKeys {
+  activeSessionId: string;
+  sessionIds: string;
+  language: string;
+}
+
+export interface CreateStorageOptions {
+  prefix?: string;
+}
+
+/**
+ * Create an in-memory storage implementation used as a safe fallback.
+ */
+const MEMORY_STORAGE = (): StorageInterface => {
+  const store = new Map<string, string>();
+
+  return {
+    async getItem(key: string) {
+      return store.has(key) ? store.get(key)! : null;
+    },
+    async setItem(key: string, value: string) {
+      store.set(key, value);
+    },
+    async removeItem(key: string) {
+      store.delete(key);
+    },
+    async clear() {
+      store.clear();
+    },
+  };
+};
+
+/**
+ * Create a web storage implementation backed by `localStorage`.
+ * Falls back to in-memory storage when unavailable.
+ */
+const createWebStorage = (): StorageInterface => {
+  if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+    return MEMORY_STORAGE();
+  }
+
+  return {
+    async getItem(key: string) {
+      try {
+        return window.localStorage.getItem(key);
+      } catch {
+        return null;
+      }
+    },
+    async setItem(key: string, value: string) {
+      try {
+        window.localStorage.setItem(key, value);
+      } catch {
+        // Ignore quota or access issues for now.
+      }
+    },
+    async removeItem(key: string) {
+      try {
+        window.localStorage.removeItem(key);
+      } catch {
+        // Ignore failures.
+      }
+    },
+    async clear() {
+      try {
+        window.localStorage.clear();
+      } catch {
+        // Ignore failures.
+      }
+    },
+  };
+};
+
+let asyncStorageInstance: StorageInterface | null = null;
+
+/**
+ * Lazily import React Native AsyncStorage implementation.
+ */
+const createNativeStorage = async (): Promise<StorageInterface> => {
+  if (asyncStorageInstance) {
+    return asyncStorageInstance;
+  }
+
+  try {
+    const asyncStorageModule = await import('@react-native-async-storage/async-storage');
+    asyncStorageInstance = asyncStorageModule.default as unknown as StorageInterface;
+    return asyncStorageInstance;
+  } catch (error) {
+    if (__DEV__) {
+      console.error('Failed to import AsyncStorage:', error);
+    }
+    throw new Error('AsyncStorage is required in React Native environment');
+  }
+};
+
+/**
+ * Detect whether the current runtime is React Native.
+ */
+export const isReactNative = (): boolean =>
+  typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+
+/**
+ * Create a platform-appropriate storage implementation.
+ * Defaults to in-memory storage when no platform storage is available.
+ */
+export const createPlatformStorage = async (): Promise<StorageInterface> => {
+  if (isReactNative()) {
+    return createNativeStorage();
+  }
+
+  return createWebStorage();
+};
+
+export const STORAGE_KEY_PREFIX = 'oxy_session';
+
+/**
+ * Produce strongly typed storage key names for the supplied prefix.
+ *
+ * @param prefix - Storage key prefix
+ */
+export const getStorageKeys = (prefix: string = STORAGE_KEY_PREFIX): SessionStorageKeys => ({
+  activeSessionId: `${prefix}_active_session_id`,
+  sessionIds: `${prefix}_session_ids`,
+  language: `${prefix}_language`,
+});
+
+

package/src/ui/utils/themeUtils.ts

@@ -0,0 +1,43 @@
+/**
+ * Theme utility functions
+ */
+
+/**
+ * Normalizes a theme value to ensure it's always 'light' | 'dark'
+ * @param theme - Theme value (may be 'light' | 'dark' | string | undefined)
+ * @returns Normalized 'light' | 'dark' theme (defaults to 'light')
+ */
+export const normalizeTheme = (theme?: string | null): 'light' | 'dark' => 
+    theme === 'light' || theme === 'dark' ? theme : 'light';
+
+/**
+ * Normalizes a color scheme value to ensure it's always 'light' or 'dark'
+ * Handles null/undefined cases with proper fallback chain
+ * 
+ * @param colorScheme - The color scheme from useColorScheme() hook (may be null/undefined)
+ * @param theme - Optional theme prop as fallback
+ * @returns Normalized 'light' | 'dark' color scheme
+ * 
+ * @example
+ * ```ts
+ * const colorScheme = normalizeColorScheme(useColorScheme(), theme);
+ * ```
+ */
+export const normalizeColorScheme = (
+    colorScheme?: string | null,
+    theme?: string
+): 'light' | 'dark' => {
+    // First try the colorScheme from hook
+    if (colorScheme === 'light' || colorScheme === 'dark') {
+        return colorScheme;
+    }
+    
+    // Fallback to theme prop
+    if (theme === 'light' || theme === 'dark') {
+        return theme;
+    }
+    
+    // Default to light
+    return 'light';
+};
+

package/src/ui/utils/user-utils.ts

@@ -0,0 +1,58 @@
+/**
+ * User display name and date formatting utilities
+ */
+
+/**
+ * Formats a date string to a readable format (e.g., "Feb 21, 2025")
+ */
+export const formatDate = (dateString: string | undefined | null | Date): string => {
+  if (!dateString) return '';
+  
+  try {
+    const date = dateString instanceof Date ? dateString : new Date(dateString);
+    if (isNaN(date.getTime())) return '';
+    
+    return date.toLocaleDateString('en-US', {
+      month: 'short',
+      day: 'numeric',
+      year: 'numeric',
+    });
+  } catch {
+    return '';
+  }
+};
+
+/**
+ * Gets a display name from user data
+ */
+export const getDisplayName = (user: { name?: { full?: string; first?: string; last?: string }; username?: string } | null | undefined): string => {
+  if (!user) return 'User';
+  
+  const fullName = user.name?.full;
+  if (fullName) return fullName;
+  
+  const firstLast = [user.name?.first, user.name?.last].filter(Boolean).join(' ').trim();
+  if (firstLast) return firstLast;
+  
+  return user.username || 'User';
+};
+
+/**
+ * Gets a short display name (first name or username)
+ */
+export const getShortDisplayName = (user: { name?: { first?: string; full?: string }; username?: string } | null | undefined): string => {
+  if (!user) return 'User';
+  
+  const firstName = user.name?.first || user.name?.full?.split(' ')[0];
+  if (firstName) return firstName;
+  
+  return user.username || 'User';
+};
+
+
+
+
+
+
+
+

package/src/utils/errorUtils.ts

@@ -57,9 +57,17 @@ export function createApiError(
  * Handle common HTTP errors and convert to ApiError
  */
 export function handleHttpError(error: unknown): ApiError {
-  // If it's already an ApiError, return it
+  // If it's already an ApiError, ensure it has a non-empty message
   if (error && typeof error === 'object' && 'code' in error && 'status' in error) {
-    return error as ApiError;
+    const apiError = error as ApiError;
+    // Ensure message is not empty
+    if (!apiError.message || !apiError.message.trim()) {
+      return {
+        ...apiError,
+        message: apiError.message || 'An error occurred',
+      };
+    }
+    return apiError;
   }
 
   // Handle AbortError (timeout or cancelled requests)
@@ -135,9 +143,11 @@ export function handleHttpError(error: unknown): ApiError {
     );
   }
 
-  // Handle other errors
+  // Handle other errors - ensure we always return a non-empty message
+  const errorString = error ? String(error) : '';
+  const message = errorString.trim() || 'Unknown error occurred';
   return createApiError(
-    String(error) || 'Unknown error occurred',
+    message,
     ErrorCodes.INTERNAL_ERROR,
     500
   );