@oxyhq/services 5.16.43 → 5.17.0

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

@@ -1,500 +0,0 @@
-/**
- * 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

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