@multiplayer-app/session-recorder-react-native 0.0.1-beta.6 → 0.0.1-beta.8

package/src/services/api.service.ts

@@ -1,203 +0,0 @@
-import { SessionRecorderOptions, IResourceAttributes, ISessionAttributes } from '../types'
-
-export interface StartSessionRequest {
-  name?: string
-  stoppedAt?: string | number
-  sessionAttributes?: ISessionAttributes
-  resourceAttributes?: IResourceAttributes
-  debugSessionData?: Record<string, any>
-}
-
-export interface StopSessionRequest {
-  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 = {
-      ...this.config,
-      ...config,
-    }
-    if (config.apiBaseUrl) {
-      this.baseUrl = config.apiBaseUrl
-    }
-  }
-
-  /**
-   * Update the API service configuration
-   * @param config - Partial configuration to update
-   */
-  public updateConfigs(config: Partial<SessionRecorderOptions>) {
-    if (this.config) {
-      this.config = { ...this.config, ...config }
-    }
-  }
-
-  /**
-   * 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',
-        ...(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.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',
-    )
-  }
-
-  /**
-   * 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,
-    )
-  }
-
-  /**
-   * 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,
-    )
-  }
-
-  /**
-   * 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',
-    )
-  }
-
-  /**
-   * 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/screenMaskingService.ts

@@ -1,118 +0,0 @@
-import SessionRecorderNative, { MaskingOptions } from '../native/SessionRecorderNative'
-import { logger } from '../utils'
-import { testNativeModuleAvailability } from '../utils/nativeModuleTest'
-
-export interface ScreenMaskingConfig {
-  /** Whether screen masking is enabled */
-  enabled: boolean
-  /** Whether to mask all input fields automatically */
-  inputMasking: boolean
-  /** Default masking options */
-  defaultOptions?: MaskingOptions
-}
-
-export class ScreenMaskingService {
-  private config: ScreenMaskingConfig
-  private isAvailable: boolean = false
-
-  constructor(config: ScreenMaskingConfig = { enabled: true, inputMasking: true }) {
-    this.config = config
-    this.checkAvailability()
-  }
-
-  /**
-   * Check if the native masking module is available
-   */
-  private checkAvailability(): void {
-    try {
-      // Try to access the native module to check if it's available
-      if (SessionRecorderNative && typeof SessionRecorderNative.captureAndMask === 'function') {
-        this.isAvailable = true
-        logger.info('ScreenMaskingService', 'Screen masking native module is available')
-      } else {
-        this.isAvailable = false
-        logger.warn('ScreenMaskingService', 'Screen masking native module is not available - auto-linking may still be in progress')
-
-        // Run diagnostic test
-        testNativeModuleAvailability()
-
-        // Retry after a delay for auto-linking
-        setTimeout(() => {
-          this.checkAvailability()
-        }, 2000)
-      }
-    } catch (error) {
-      this.isAvailable = false
-      logger.error('ScreenMaskingService', 'Error checking screen masking availability:', error)
-    }
-  }
-
-  /**
-   * Capture screen with masking applied
-   */
-  async captureMaskedScreen(options?: MaskingOptions): Promise<string | null> {
-    if (!this.isAvailable || !this.config.enabled) {
-      logger.warn('ScreenMaskingService', 'Screen masking is not available or disabled')
-      return null
-    }
-
-    try {
-      const maskingOptions: MaskingOptions = {
-        ...this.config.defaultOptions,
-        ...options,
-        inputMasking: this.config.inputMasking,
-      }
-
-      const maskedImageBase64 = await SessionRecorderNative.captureAndMaskWithOptions(maskingOptions)
-      logger.info('ScreenMaskingService', 'Successfully captured masked screen')
-      return maskedImageBase64
-    } catch (error) {
-      logger.error('ScreenMaskingService', 'Failed to capture masked screen:', error)
-      return null
-    }
-  }
-
-  /**
-   * Capture screen with basic masking (no custom options)
-   */
-  async captureMaskedScreenBasic(): Promise<string | null> {
-    if (!this.isAvailable || !this.config.enabled) {
-      logger.warn('ScreenMaskingService', 'Screen masking is not available or disabled')
-      return null
-    }
-
-    try {
-      const maskedImageBase64 = await SessionRecorderNative.captureAndMask()
-      logger.info('ScreenMaskingService', 'Successfully captured masked screen (basic)')
-      return maskedImageBase64
-    } catch (error) {
-      logger.error('ScreenMaskingService', 'Failed to capture masked screen (basic):', error)
-      return null
-    }
-  }
-
-  /**
-   * Update the masking configuration
-   */
-  updateConfig(config: Partial<ScreenMaskingConfig>): void {
-    this.config = { ...this.config, ...config }
-    logger.info('ScreenMaskingService', 'Screen masking configuration updated')
-  }
-
-  /**
-   * Check if screen masking is available
-   */
-  isScreenMaskingAvailable(): boolean {
-    return this.isAvailable && this.config.enabled
-  }
-
-  /**
-   * Get the current configuration
-   */
-  getConfig(): ScreenMaskingConfig {
-    return { ...this.config }
-  }
-}
-
-// Create a singleton instance
-export const screenMaskingService = new ScreenMaskingService()

package/src/services/storage.service.ts

@@ -1,199 +0,0 @@
-import AsyncStorage from '@react-native-async-storage/async-storage'
-import { SessionType } from '@multiplayer-app/session-recorder-common'
-import { ISession, SessionState } from '../types'
-import { logger } from '../utils'
-
-interface CacheData {
-  sessionId: string | null
-  sessionType: SessionType | null
-  sessionState: SessionState | null
-  sessionObject: ISession | null
-  floatingButtonPosition: { x: number; y: number } | null
-}
-
-export class StorageService {
-  private static readonly SESSION_ID_KEY = 'session_id'
-  private static readonly SESSION_TYPE_KEY = 'session_type'
-  private static readonly SESSION_STATE_KEY = 'session_state'
-  private static readonly SESSION_OBJECT_KEY = 'session_object'
-  private static readonly FLOATING_BUTTON_POSITION_KEY = 'floating_button_position'
-
-  private static cache: CacheData = {
-    sessionId: null,
-    sessionType: null,
-    sessionState: null,
-    sessionObject: null,
-    floatingButtonPosition: null,
-  }
-
-  private static cacheInitialized = false
-  private static instance: StorageService | null = null
-  private static positionSaveTimeout: NodeJS.Timeout | null = null
-
-  private constructor() {
-    // Private constructor for singleton
-  }
-
-  static getInstance(): StorageService {
-    if (!StorageService.instance) {
-      StorageService.instance = new StorageService()
-      StorageService.initialize()
-    }
-    return StorageService.instance
-  }
-
-  private static async initializeCache(): Promise<void> {
-    if (StorageService.cacheInitialized) return
-
-    try {
-      const [sessionId, sessionType, sessionState, sessionObject, floatingButtonPosition] = 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),
-        AsyncStorage.getItem(StorageService.FLOATING_BUTTON_POSITION_KEY),
-      ])
-
-      StorageService.cache = {
-        sessionId,
-        sessionType: sessionType as SessionType | null,
-        sessionState: sessionState as SessionState | null,
-        sessionObject: sessionObject ? JSON.parse(sessionObject) : null,
-        floatingButtonPosition: floatingButtonPosition ? JSON.parse(floatingButtonPosition) : null,
-      }
-      StorageService.cacheInitialized = true
-    } catch (error) {
-      // Failed to initialize cache - silently continue
-      StorageService.cacheInitialized = true // Mark as initialized to prevent retries
-    }
-  }
-
-  saveSessionId(sessionId: string): void {
-    try {
-      StorageService.cache.sessionId = sessionId
-      AsyncStorage.setItem(StorageService.SESSION_ID_KEY, sessionId).catch(error => {
-        // Failed to persist session ID - silently continue
-      })
-    } catch (error) {
-      // Failed to save session ID - silently continue
-      throw error
-    }
-  }
-
-  getSessionId(): string | null {
-    return StorageService.cache.sessionId
-  }
-
-  saveSessionType(sessionType: SessionType): void {
-    try {
-      StorageService.cache.sessionType = sessionType
-      AsyncStorage.setItem(StorageService.SESSION_TYPE_KEY, sessionType).catch(error => {
-        // Failed to persist session type - silently continue
-      })
-    } catch (error) {
-      // Failed to save session type - silently continue
-      throw error
-    }
-  }
-
-  getSessionType(): SessionType | null {
-    return StorageService.cache.sessionType
-  }
-
-  saveSessionState(state: SessionState): void {
-    try {
-      StorageService.cache.sessionState = state
-
-      AsyncStorage.setItem(StorageService.SESSION_STATE_KEY, state).catch(error => {
-        // Failed to persist session state - silently continue
-      })
-    } catch (error) {
-      // Failed to save session state - silently continue
-      throw error
-    }
-  }
-
-  getSessionState(): SessionState | null {
-    return StorageService.cache.sessionState
-  }
-
-  saveSessionObject(session: ISession): void {
-    try {
-      StorageService.cache.sessionObject = session
-      AsyncStorage.setItem(StorageService.SESSION_OBJECT_KEY, JSON.stringify(session)).catch(error => {
-        // Failed to persist session object - silently continue
-      })
-    } catch (error) {
-      // Failed to save session object - silently continue
-      throw error
-    }
-  }
-
-  getSessionObject(): ISession | null {
-    return StorageService.cache.sessionObject
-  }
-
-  clearSessionData(): void {
-    try {
-      // Clear cache immediately
-      StorageService.cache = {
-        ...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) {
-      // Failed to clear session data - silently continue
-      throw error
-    }
-  }
-
-  getAllSessionData(): Omit<CacheData, 'floatingButtonPosition'> {
-    return {
-      sessionId: StorageService.cache.sessionId,
-      sessionType: StorageService.cache.sessionType,
-      sessionState: StorageService.cache.sessionState,
-      sessionObject: StorageService.cache.sessionObject,
-    }
-  }
-
-  saveFloatingButtonPosition(position: { x: number; y: number }): void {
-    try {
-      StorageService.cache.floatingButtonPosition = position
-
-      // Debounce AsyncStorage writes to avoid excessive I/O
-      if (StorageService.positionSaveTimeout) {
-        clearTimeout(StorageService.positionSaveTimeout)
-      }
-
-      StorageService.positionSaveTimeout = setTimeout(() => {
-        AsyncStorage.setItem(StorageService.FLOATING_BUTTON_POSITION_KEY, JSON.stringify(position)).catch(error => {
-          logger.error('StorageService', 'Failed to persist floating button position', error)
-        })
-      }, 100) // 100ms debounce
-    } catch (error) {
-      logger.error('StorageService', 'Failed to save floating button position', error)
-      throw error
-    }
-  }
-
-  getFloatingButtonPosition(): { x: number; y: number } | null {
-    return StorageService.cache.floatingButtonPosition
-  }
-
-  // Initialize cache on first use - call this method when the service is first used
-  static async initialize(): Promise<void> {
-    await StorageService.initializeCache()
-  }
-}