@multiplayer-app/session-recorder-react-native 0.0.1-alpha.1 → 0.0.1-alpha.10

package/src/services/api.service.ts

@@ -1,78 +1,203 @@
-import { ISession, SessionRecorderOptions } from '../types'
-
-// Type definitions for fetch API
-type RequestInit = {
-  method?: string
-  headers?: Record<string, string>
-  body?: string
-  signal?: AbortSignal
-}
+import { SessionRecorderOptions, IResourceAttributes, ISessionAttributes } from '../types'
 
 export interface StartSessionRequest {
-  application: string
-  version: string
-  environment: string
-  metadata?: Record<string, any>
+  name?: string
+  stoppedAt?: string | number
+  sessionAttributes?: ISessionAttributes
+  resourceAttributes?: IResourceAttributes
+  debugSessionData?: Record<string, any>
 }
 
 export interface StopSessionRequest {
-  sessionId: string
-  comment?: string
+  sessionAttributes?: ISessionAttributes
+  stoppedAt: string | number
 }
 
 export class ApiService {
   private config?: SessionRecorderOptions
   private baseUrl: string = 'https://api.multiplayer.app'
 
+  constructor() {
+    this.config = {
+      apiKey: '',
+      apiBaseUrl: '',
+      exporterEndpoint: '',
+      version: '',
+      application: '',
+      environment: '',
+    } as SessionRecorderOptions
+  }
+
   init(config: SessionRecorderOptions): void {
-    this.config = config
+
+    this.config = {
+      ...this.config,
+      ...config,
+    }
     if (config.apiBaseUrl) {
       this.baseUrl = config.apiBaseUrl
     }
   }
 
-  private async makeRequest<T>(
-    endpoint: string,
-    options: RequestInit = {},
-  ): Promise<T> {
-    if (!this.config?.apiKey) {
-      throw new Error('API key not configured')
+  /**
+   * Update the API service configuration
+   * @param config - Partial configuration to update
+   */
+  public updateConfigs(config: Partial<SessionRecorderOptions>) {
+    if (this.config) {
+      this.config = { ...this.config, ...config }
     }
+  }
 
-    const url = `${this.baseUrl}${endpoint}`
-    const response = await fetch(url, {
-      ...options,
+  /**
+   * Make a request to the session debugger API
+   * @param path - API endpoint path (relative to the base URL)
+   * @param method - HTTP method (GET, POST, PATCH, etc.)
+   * @param body - request payload
+   * @param signal - AbortSignal to set request's signal
+   */
+  private async makeRequest(
+    path: string,
+    method: string,
+    body?: any,
+    signal?: AbortSignal,
+  ): Promise<any> {
+    const url = `${this.baseUrl}/v0/radar${path}`
+    const params = {
+      method,
+      body: body ? JSON.stringify(body) : null,
       headers: {
         'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.config.apiKey}`,
-        ...options.headers,
+        ...(this.config?.apiKey && { 'X-Api-Key': this.config.apiKey }),
       },
-    })
+    }
+
+    try {
+      const response = await fetch(url, {
+        ...params,
+        signal,
+      })
+
+      if (!response.ok) {
+        throw new Error('Network response was not ok: ' + response.statusText)
+      }
 
-    if (!response.ok) {
-      throw new Error(`API request failed: ${response.statusText}`)
+      if (response.status === 204) {
+        return null
+      }
+
+      return await response.json()
+    } catch (error: any) {
+      if (error?.name === 'AbortError') {
+        throw new Error('Request aborted')
+      }
+      throw new Error('Error making request: ' + error.message)
     }
+  }
+
+  /**
+   * Start a new debug session
+   * @param request - Session start request data
+   * @param signal - Optional AbortSignal for request cancellation
+   */
+  async startSession(
+    request: StartSessionRequest,
+    signal?: AbortSignal,
+  ): Promise<any> {
+    return this.makeRequest(
+      '/debug-sessions/start',
+      'POST',
+      request,
+      signal,
+    )
+  }
+
+  /**
+   * Stop an active debug session
+   * @param sessionId - ID of the session to stop
+   * @param request - Session stop request data
+   */
+  async stopSession(
+    sessionId: string,
+    request: StopSessionRequest,
+  ): Promise<any> {
+    return this.makeRequest(
+      `/debug-sessions/${sessionId}/stop`,
+      'PATCH',
+      request,
+    )
+  }
+
+  /**
+   * Cancel an active debug session
+   * @param sessionId - ID of the session to cancel
+   */
+  async cancelSession(sessionId: string): Promise<any> {
+    return this.makeRequest(
+      `/debug-sessions/${sessionId}/cancel`,
+      'DELETE',
+    )
+  }
 
-    return response.json()
+  /**
+   * Start a new continuous debug session
+   * @param request - Session start request data
+   * @param signal - Optional AbortSignal for request cancellation
+   */
+  async startContinuousDebugSession(
+    request: StartSessionRequest,
+    signal?: AbortSignal,
+  ): Promise<any> {
+    return this.makeRequest(
+      '/continuous-debug-sessions/start',
+      'POST',
+      request,
+      signal,
+    )
   }
 
-  async startSession(request: StartSessionRequest): Promise<ISession> {
-    return this.makeRequest<ISession>('/sessions', {
-      method: 'POST',
-      body: JSON.stringify(request),
-    })
+  /**
+   * Save a continuous debug session
+   * @param sessionId - ID of the session to save
+   * @param request - Session save request data
+   * @param signal - Optional AbortSignal for request cancellation
+   */
+  async saveContinuousDebugSession(
+    sessionId: string,
+    request: StartSessionRequest,
+    signal?: AbortSignal,
+  ): Promise<any> {
+    return this.makeRequest(
+      `/continuous-debug-sessions/${sessionId}/save`,
+      'POST',
+      request,
+      signal,
+    )
   }
 
-  async stopSession(request: StopSessionRequest): Promise<void> {
-    return this.makeRequest<void>(`/sessions/${request.sessionId}/stop`, {
-      method: 'POST',
-      body: JSON.stringify({ comment: request.comment }),
-    })
+  /**
+   * Stop an active continuous debug session
+   * @param sessionId - ID of the session to stop
+   */
+  async stopContinuousDebugSession(sessionId: string): Promise<any> {
+    return this.makeRequest(
+      `/continuous-debug-sessions/${sessionId}/cancel`,
+      'DELETE',
+    )
   }
 
-  async saveSession(sessionId: string): Promise<ISession> {
-    return this.makeRequest<ISession>(`/sessions/${sessionId}/save`, {
-      method: 'POST',
-    })
+  /**
+   * Check debug session should be started remotely
+   */
+  async checkRemoteSession(
+    requestBody: StartSessionRequest,
+    signal?: AbortSignal,
+  ): Promise<{ state: 'START' | 'STOP' }> {
+    return this.makeRequest(
+      '/remote-debug-session/check',
+      'POST',
+      requestBody,
+      signal,
+    )
   }
 }

package/src/services/storage.service.ts

@@ -1,6 +1,13 @@
 import AsyncStorage from '@react-native-async-storage/async-storage'
-import { ISession, SessionState } from '../types'
 import { SessionType } from '@multiplayer-app/session-recorder-common'
+import { ISession, SessionState } from '../types'
+
+interface CacheData {
+  sessionId: string | null
+  sessionType: SessionType | null
+  sessionState: SessionState | null
+  sessionObject: ISession | null
+}
 
 export class StorageService {
   private static readonly SESSION_ID_KEY = 'session_id'
@@ -8,123 +15,144 @@ export class StorageService {
   private static readonly SESSION_STATE_KEY = 'session_state'
   private static readonly SESSION_OBJECT_KEY = 'session_object'
 
-  async saveSessionId(sessionId: string): Promise<void> {
-    try {
-      await AsyncStorage.setItem(StorageService.SESSION_ID_KEY, sessionId)
-    } catch (error) {
-      console.error('Failed to save session ID:', error)
-      throw error
-    }
+  private static cache: CacheData = {
+    sessionId: null,
+    sessionType: null,
+    sessionState: null,
+    sessionObject: null,
+  }
+
+  private static cacheInitialized = false
+
+  constructor() {
+    StorageService.initialize()
   }
 
-  async getSessionId(): Promise<string | null> {
+  private static async initializeCache(): Promise<void> {
+    if (StorageService.cacheInitialized) return
+
     try {
-      return await AsyncStorage.getItem(StorageService.SESSION_ID_KEY)
+      const [sessionId, sessionType, sessionState, sessionObject] = await Promise.all([
+        AsyncStorage.getItem(StorageService.SESSION_ID_KEY),
+        AsyncStorage.getItem(StorageService.SESSION_TYPE_KEY),
+        AsyncStorage.getItem(StorageService.SESSION_STATE_KEY),
+        AsyncStorage.getItem(StorageService.SESSION_OBJECT_KEY),
+      ])
+
+      StorageService.cache = {
+        sessionId,
+        sessionType: sessionType as SessionType | null,
+        sessionState: sessionState as SessionState | null,
+        sessionObject: sessionObject ? JSON.parse(sessionObject) : null,
+      }
+      StorageService.cacheInitialized = true
     } catch (error) {
-      console.error('Failed to get session ID:', error)
-      return null
+      // Failed to initialize cache - silently continue
+      StorageService.cacheInitialized = true // Mark as initialized to prevent retries
     }
   }
 
-  async saveSessionType(sessionType: SessionType): Promise<void> {
+  saveSessionId(sessionId: string): void {
     try {
-      await AsyncStorage.setItem(StorageService.SESSION_TYPE_KEY, sessionType)
+      StorageService.cache.sessionId = sessionId
+      AsyncStorage.setItem(StorageService.SESSION_ID_KEY, sessionId).catch(error => {
+        // Failed to persist session ID - silently continue
+      })
     } catch (error) {
-      console.error('Failed to save session type:', error)
+      // Failed to save session ID - silently continue
       throw error
     }
   }
 
-  async getSessionType(): Promise<SessionType | null> {
-    try {
-      const type = await AsyncStorage.getItem(StorageService.SESSION_TYPE_KEY)
-      return type as SessionType | null
-    } catch (error) {
-      console.error('Failed to get session type:', error)
-      return null
-    }
+  getSessionId(): string | null {
+    return StorageService.cache.sessionId
   }
 
-  async saveSessionState(state: SessionState): Promise<void> {
+  saveSessionType(sessionType: SessionType): void {
     try {
-      await AsyncStorage.setItem(StorageService.SESSION_STATE_KEY, state)
+      StorageService.cache.sessionType = sessionType
+      AsyncStorage.setItem(StorageService.SESSION_TYPE_KEY, sessionType).catch(error => {
+        // Failed to persist session type - silently continue
+      })
     } catch (error) {
-      console.error('Failed to save session state:', error)
+      // Failed to save session type - silently continue
       throw error
     }
   }
 
-  async getSessionState(): Promise<SessionState | null> {
-    try {
-      const state = await AsyncStorage.getItem(StorageService.SESSION_STATE_KEY)
-      return state as SessionState | null
-    } catch (error) {
-      console.error('Failed to get session state:', error)
-      return null
-    }
+  getSessionType(): SessionType | null {
+    return StorageService.cache.sessionType
   }
 
-  async saveSessionObject(session: ISession): Promise<void> {
+  saveSessionState(state: SessionState): void {
     try {
-      await AsyncStorage.setItem(StorageService.SESSION_OBJECT_KEY, JSON.stringify(session))
+      StorageService.cache.sessionState = state
+
+      AsyncStorage.setItem(StorageService.SESSION_STATE_KEY, state).catch(error => {
+        // Failed to persist session state - silently continue
+      })
     } catch (error) {
-      console.error('Failed to save session object:', error)
+      // Failed to save session state - silently continue
       throw error
     }
   }
 
-  async getSessionObject(): Promise<ISession | null> {
+  getSessionState(): SessionState | null {
+    return StorageService.cache.sessionState
+  }
+
+  saveSessionObject(session: ISession): void {
     try {
-      const sessionData = await AsyncStorage.getItem(StorageService.SESSION_OBJECT_KEY)
-      return sessionData ? JSON.parse(sessionData) : null
+      StorageService.cache.sessionObject = session
+      AsyncStorage.setItem(StorageService.SESSION_OBJECT_KEY, JSON.stringify(session)).catch(error => {
+        // Failed to persist session object - silently continue
+      })
     } catch (error) {
-      console.error('Failed to get session object:', error)
-      return null
+      // Failed to save session object - silently continue
+      throw error
     }
   }
 
-  async clearSessionData(): Promise<void> {
+  getSessionObject(): ISession | null {
+    return StorageService.cache.sessionObject
+  }
+
+  clearSessionData(): void {
     try {
-      await AsyncStorage.multiRemove([
+      // Clear cache immediately
+      StorageService.cache = {
+        sessionId: null,
+        sessionType: null,
+        sessionState: null,
+        sessionObject: null,
+      }
+
+      // Clear persistent storage asynchronously
+      AsyncStorage.multiRemove([
         StorageService.SESSION_ID_KEY,
         StorageService.SESSION_TYPE_KEY,
         StorageService.SESSION_STATE_KEY,
         StorageService.SESSION_OBJECT_KEY,
-      ])
+      ]).catch(error => {
+        // Failed to clear session data from storage - silently continue
+      })
     } catch (error) {
-      console.error('Failed to clear session data:', error)
+      // Failed to clear session data - silently continue
       throw error
     }
   }
 
-  async getAllSessionData(): Promise<{
-    sessionId: string | null
-    sessionType: SessionType | null
-    sessionState: SessionState | null
-    sessionObject: ISession | null
-  }> {
-    try {
-      const [sessionId, sessionType, sessionState, sessionObject] = await Promise.all([
-        this.getSessionId(),
-        this.getSessionType(),
-        this.getSessionState(),
-        this.getSessionObject(),
-      ])
-
-      return {
-        sessionId,
-        sessionType,
-        sessionState,
-        sessionObject,
-      }
-    } catch (error) {
-      console.error('Failed to get all session data:', error)
-      return {
-        sessionId: null,
-        sessionType: null,
-        sessionState: null,
-        sessionObject: null,
-      }
+  getAllSessionData(): CacheData {
+    return {
+      sessionId: StorageService.cache.sessionId,
+      sessionType: StorageService.cache.sessionType,
+      sessionState: StorageService.cache.sessionState,
+      sessionObject: StorageService.cache.sessionObject,
     }
   }
+
+  // Initialize cache on first use - call this method when the service is first used
+  static async initialize(): Promise<void> {
+    await StorageService.initializeCache()
+  }
 }