@oxyhq/services 5.16.40 → 5.16.41

package/src/core/identity-session/SessionManager.ts

@@ -0,0 +1,500 @@
+/**
+ * Session Manager
+ * 
+ * Manages user sessions (Native + Web)
+ * Handles session creation, storage, refresh, and invalidation.
+ */
+
+import { jwtDecode } from 'jwt-decode';
+import type { PlatformAdapter } from '../../adapters';
+import type { Session, Identity } from './types';
+import { DeviceManager } from './DeviceManager';
+import { RefreshManager } from './RefreshManager';
+import {
+  createIdentitySessionError,
+  IdentitySessionErrorCodes,
+} from './errors';
+
+const SESSION_STORAGE_KEY = 'oxy_sessions';
+const ACTIVE_SESSION_ID_KEY = 'oxy_active_session_id';
+const TOKEN_STORAGE_KEY = 'oxy_tokens';
+
+interface AccessTokenPayload {
+  userId: string;      // MongoDB ObjectId
+  sessionId: string;    // Session UUID
+  deviceId: string;    // Device identifier
+  type: 'access';
+  iat?: number;
+  exp?: number;
+}
+
+interface TokenStore {
+  accessToken: string | null;
+  refreshToken: string | null;
+}
+
+/**
+ * Session Manager Class
+ */
+export class SessionManager {
+  private adapter: PlatformAdapter;
+  private deviceManager: DeviceManager;
+  private refreshManager: RefreshManager;
+  private baseURL: string | null = null;
+  private cachedSessions: Session[] | null = null;
+  private cachedActiveSessionId: string | null = null;
+  private tokenStore: TokenStore = {
+    accessToken: null,
+    refreshToken: null,
+  };
+
+  constructor(
+    adapter: PlatformAdapter,
+    deviceManager: DeviceManager,
+    refreshManager: RefreshManager,
+    baseURL?: string
+  ) {
+    this.adapter = adapter;
+    this.deviceManager = deviceManager;
+    this.refreshManager = refreshManager;
+    this.baseURL = baseURL || null;
+    
+    if (baseURL) {
+      this.refreshManager.setBaseURL(baseURL);
+    }
+  }
+
+  /**
+   * Set base URL for API requests
+   */
+  setBaseURL(baseURL: string): void {
+    this.baseURL = baseURL;
+    this.refreshManager.setBaseURL(baseURL);
+  }
+
+  /**
+   * Invalidate cached sessions
+   */
+  invalidateCache(): void {
+    this.cachedSessions = null;
+    this.cachedActiveSessionId = null;
+  }
+
+  /**
+   * Load tokens from storage
+   */
+  private async loadTokens(): Promise<void> {
+    try {
+      const stored = await this.adapter.storage.get(TOKEN_STORAGE_KEY);
+      if (stored) {
+        this.tokenStore = JSON.parse(stored);
+      }
+    } catch (error) {
+      console.warn('[SessionManager] Failed to load tokens:', error);
+    }
+  }
+
+  /**
+   * Save tokens to storage
+   */
+  private async saveTokens(): Promise<void> {
+    try {
+      await this.adapter.storage.set(TOKEN_STORAGE_KEY, JSON.stringify(this.tokenStore));
+    } catch (error) {
+      console.warn('[SessionManager] Failed to save tokens:', error);
+    }
+  }
+
+  /**
+   * Get access token
+   */
+  getAccessToken(): string | null {
+    return this.tokenStore.accessToken;
+  }
+
+  /**
+   * Get refresh token
+   */
+  getRefreshToken(): string | null {
+    return this.tokenStore.refreshToken;
+  }
+
+  /**
+   * Set tokens
+   */
+  async setTokens(accessToken: string, refreshToken?: string): Promise<void> {
+    this.tokenStore.accessToken = accessToken;
+    if (refreshToken) {
+      this.tokenStore.refreshToken = refreshToken;
+    }
+    await this.saveTokens();
+  }
+
+  /**
+   * Clear tokens
+   */
+  async clearTokens(): Promise<void> {
+    this.tokenStore.accessToken = null;
+    this.tokenStore.refreshToken = null;
+    await this.saveTokens();
+  }
+
+  /**
+   * Load sessions from storage
+   */
+  async loadSessions(): Promise<Session[]> {
+    if (this.cachedSessions) {
+      return this.cachedSessions;
+    }
+
+    try {
+      const stored = await this.adapter.storage.get(SESSION_STORAGE_KEY);
+      if (stored) {
+        this.cachedSessions = JSON.parse(stored);
+        return this.cachedSessions || [];
+      }
+    } catch (error) {
+      console.warn('[SessionManager] Failed to load sessions:', error);
+    }
+
+    this.cachedSessions = [];
+    return [];
+  }
+
+  /**
+   * Save sessions to storage
+   */
+  private async saveSessions(sessions: Session[]): Promise<void> {
+    try {
+      await this.adapter.storage.set(SESSION_STORAGE_KEY, JSON.stringify(sessions));
+      this.cachedSessions = sessions;
+    } catch (error) {
+      console.warn('[SessionManager] Failed to save sessions:', error);
+    }
+  }
+
+  /**
+   * Get active session ID
+   */
+  async getActiveSessionId(): Promise<string | null> {
+    if (this.cachedActiveSessionId !== null) {
+      return this.cachedActiveSessionId;
+    }
+
+    try {
+      const stored = await this.adapter.storage.get(ACTIVE_SESSION_ID_KEY);
+      this.cachedActiveSessionId = stored;
+      return stored;
+    } catch (error) {
+      console.warn('[SessionManager] Failed to load active session ID:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Set active session ID
+   */
+  async setActiveSessionId(sessionId: string | null): Promise<void> {
+    try {
+      if (sessionId) {
+        await this.adapter.storage.set(ACTIVE_SESSION_ID_KEY, sessionId);
+      } else {
+        await this.adapter.storage.remove(ACTIVE_SESSION_ID_KEY);
+      }
+      this.cachedActiveSessionId = sessionId;
+    } catch (error) {
+      console.warn('[SessionManager] Failed to save active session ID:', error);
+    }
+  }
+
+  /**
+   * Get all sessions
+   */
+  async getAllSessions(): Promise<Session[]> {
+    return await this.loadSessions();
+  }
+
+  /**
+   * Get current session
+   */
+  async getSession(): Promise<Session | null> {
+    await this.loadTokens();
+    const accessToken = this.getAccessToken();
+    if (!accessToken) {
+      return null;
+    }
+
+    try {
+      const decoded = jwtDecode<AccessTokenPayload>(accessToken);
+      const sessionId = decoded.sessionId;
+      const userId = decoded.userId;
+
+      if (!sessionId || !userId) {
+        return null;
+      }
+
+      const sessions = await this.loadSessions();
+      const session = sessions.find(s => s.sessionId === sessionId);
+
+      if (session) {
+        return session;
+      }
+
+      // Create session from token if not found in storage
+      const device = await this.deviceManager.getCurrentDevice();
+      if (!device) {
+        return null;
+      }
+
+      const deviceInfo = await this.deviceManager.getDeviceInfo();
+
+      return {
+        sessionId,
+        userId,
+        deviceId: device.deviceId,
+        expiresAt: decoded.exp ? new Date(decoded.exp * 1000).toISOString() : new Date(Date.now() + 3600000).toISOString(),
+        lastActive: new Date().toISOString(),
+        deviceInfo,
+        isCurrent: true,
+        accessToken,
+      };
+    } catch (error) {
+      console.warn('[SessionManager] Failed to decode token:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Create a new session (sign in)
+   */
+  async createSession(
+    publicKey: string,
+    signature: string,
+    timestamp: number,
+    deviceName?: string
+  ): Promise<Session> {
+    if (!this.baseURL) {
+      throw createIdentitySessionError(
+        IdentitySessionErrorCodes.SESSION_CREATION_FAILED,
+        'Base URL not set for session creation'
+      );
+    }
+
+    const device = await this.deviceManager.getCurrentDevice();
+    if (!device) {
+      throw createIdentitySessionError(
+        IdentitySessionErrorCodes.DEVICE_NOT_FOUND,
+        'Device not found'
+      );
+    }
+
+    // Update device name if provided
+    if (deviceName) {
+      await this.deviceManager.updateDeviceName(deviceName);
+    }
+
+    const deviceInfo = await this.deviceManager.getDeviceInfo();
+
+    try {
+      const response = await this.adapter.fetch.fetch(`${this.baseURL}/api/auth/login`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+        },
+        body: JSON.stringify({
+          publicKey,
+          signature,
+          timestamp,
+          deviceId: device.deviceId,
+          deviceInfo,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw createIdentitySessionError(
+          IdentitySessionErrorCodes.SESSION_CREATION_FAILED,
+          errorData.message || `Login failed: ${response.status}`,
+          response.status
+        );
+      }
+
+      const data = await response.json();
+      const { accessToken, refreshToken, user, sessionId, deviceId, expiresAt } = data;
+
+      if (!accessToken || !sessionId) {
+        throw createIdentitySessionError(
+          IdentitySessionErrorCodes.SESSION_CREATION_FAILED,
+          'Invalid response from login endpoint'
+        );
+      }
+
+      // Set tokens
+      await this.setTokens(accessToken, refreshToken);
+
+      // Create session object
+      const session: Session = {
+        sessionId,
+        userId: user.id || user._id, // MongoDB ObjectId
+        deviceId: deviceId || device.deviceId,
+        expiresAt: expiresAt || new Date(Date.now() + 3600000).toISOString(),
+        lastActive: new Date().toISOString(),
+        deviceInfo,
+        isCurrent: true,
+        accessToken,
+        refreshToken,
+      };
+
+      // Save session
+      const sessions = await this.loadSessions();
+      const existingIndex = sessions.findIndex(s => s.sessionId === sessionId);
+      if (existingIndex >= 0) {
+        sessions[existingIndex] = session;
+      } else {
+        sessions.push(session);
+      }
+
+      // Mark all other sessions as not current
+      sessions.forEach(s => {
+        if (s.sessionId !== sessionId) {
+          s.isCurrent = false;
+        }
+      });
+
+      await this.saveSessions(sessions);
+      await this.setActiveSessionId(sessionId);
+
+      return session;
+    } catch (error) {
+      if (error instanceof Error && error.name === 'IdentitySessionError') {
+        throw error;
+      }
+      throw createIdentitySessionError(
+        IdentitySessionErrorCodes.SESSION_CREATION_FAILED,
+        `Failed to create session: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Refresh current session
+   */
+  async refreshSession(): Promise<Session> {
+    const session = await this.getSession();
+    if (!session) {
+      throw createIdentitySessionError(
+        IdentitySessionErrorCodes.SESSION_NOT_FOUND,
+        'No active session to refresh'
+      );
+    }
+
+    // Refresh token first
+    await this.refreshManager.refreshTokenIfNeeded(
+      () => this.getAccessToken(),
+      (accessToken, refreshToken) => this.setTokens(accessToken, refreshToken),
+      () => this.clearTokens()
+    );
+
+    // Get updated session
+    const refreshedSession = await this.getSession();
+    if (!refreshedSession) {
+      throw createIdentitySessionError(
+        IdentitySessionErrorCodes.SESSION_REFRESH_FAILED,
+        'Session not found after refresh'
+      );
+    }
+
+    // Update session in storage
+    const sessions = await this.loadSessions();
+    const index = sessions.findIndex(s => s.sessionId === refreshedSession.sessionId);
+    if (index >= 0) {
+      sessions[index] = refreshedSession;
+      await this.saveSessions(sessions);
+    }
+
+    return refreshedSession;
+  }
+
+  /**
+   * Invalidate a session
+   */
+  async invalidateSession(sessionId?: string): Promise<void> {
+    const targetSessionId = sessionId || await this.getActiveSessionId();
+    if (!targetSessionId) {
+      return;
+    }
+
+    if (!this.baseURL) {
+      // Just clear local storage if no base URL
+      await this.clearLocalSession(targetSessionId);
+      return;
+    }
+
+    try {
+      await this.adapter.fetch.fetch(`${this.baseURL}/api/session/${targetSessionId}/logout`, {
+        method: 'POST',
+        headers: {
+          'Accept': 'application/json',
+        },
+      });
+    } catch (error) {
+      // Continue with local cleanup even if API call fails
+      console.warn('[SessionManager] Failed to invalidate session on server:', error);
+    }
+
+    await this.clearLocalSession(targetSessionId);
+  }
+
+  /**
+   * Clear local session data
+   */
+  private async clearLocalSession(sessionId: string): Promise<void> {
+    const sessions = await this.loadSessions();
+    const filtered = sessions.filter(s => s.sessionId !== sessionId);
+    await this.saveSessions(filtered);
+
+    // If this was the active session, clear it
+    const activeSessionId = await this.getActiveSessionId();
+    if (activeSessionId === sessionId) {
+      await this.setActiveSessionId(null);
+      await this.clearTokens();
+    }
+  }
+
+  /**
+   * Invalidate all sessions
+   */
+  async invalidateAllSessions(): Promise<void> {
+    const sessions = await this.loadSessions();
+    
+    if (this.baseURL) {
+      // Try to invalidate all sessions on server
+      await Promise.allSettled(
+        sessions.map(session =>
+          this.adapter.fetch.fetch(`${this.baseURL}/api/session/${session.sessionId}/logout`, {
+            method: 'POST',
+            headers: { 'Accept': 'application/json' },
+          }).catch(() => {
+            // Ignore individual failures
+          })
+        )
+      );
+    }
+
+    // Clear all local session data
+    await this.saveSessions([]);
+    await this.setActiveSessionId(null);
+    await this.clearTokens();
+    this.invalidateCache();
+  }
+
+  /**
+   * Initialize - load tokens and sessions from storage
+   */
+  async initialize(): Promise<void> {
+    await this.loadTokens();
+    await this.loadSessions();
+  }
+}
+

package/src/core/identity-session/createIdentitySessionCore.ts

@@ -0,0 +1,19 @@
+/**
+ * Create Identity Session Core
+ * 
+ * Factory function to create and initialize IdentitySessionCore
+ */
+
+import { createPlatformAdapter } from '../../adapters';
+import { IdentitySessionCore } from './IdentitySessionCore';
+
+/**
+ * Create and initialize IdentitySessionCore
+ */
+export async function createIdentitySessionCore(baseURL?: string): Promise<IdentitySessionCore> {
+  const adapter = await createPlatformAdapter();
+  const core = new IdentitySessionCore(adapter, baseURL);
+  await core.initialize();
+  return core;
+}
+