@oxyhq/auth 1.0.0

package/src/utils/sessionHelpers.ts

@@ -0,0 +1,151 @@
+import type { ClientSession } from '@oxyhq/core';
+
+interface DeviceSession {
+  sessionId: string;
+  deviceId?: string;
+  deviceName?: string;
+  expiresAt?: string;
+  lastActive?: string;
+  user?: { id?: string; _id?: { toString(): string } };
+  userId?: string;
+  isCurrent?: boolean;
+}
+
+/**
+ * Service type for session helpers.
+ * Uses 'any' to work around TypeScript mixin composition type inference issues.
+ * The OxyServices class has these methods but TypeScript can't see them due to the mixin pattern.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type OxyServicesAny = any;
+
+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: OxyServicesAny,
+  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);
+    }
+
+    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: OxyServicesAny,
+  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/utils/storageHelpers.ts

@@ -0,0 +1,130 @@
+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;
+}
+
+/**
+ * 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`,
+});
+
+