@adstage/web-sdk/src/modules/events/events-module.ts

AdStage Web SDK - Production-ready marketing platform SDK with React Provider support for seamless integration

/**
 * AdStage SDK - Events 모듈
 * 이벤트 추적 시스템
 */

import { AdStageConfig, BaseModule } from '../../types/config';
import { endpoints } from '../../constants/endpoints';
import { ApiHeaders } from '../../utils/api-headers';
import { getSDKVersion } from '../../utils/version';
import { EventDeviceCollector } from '../../managers/events/event-device-collector';
import { EventUserCollector } from '../../managers/events/event-user-collector';
import { EventSessionManager } from '../../managers/events/event-session-manager';
import type { UserProperties, EventProperties } from '../../types/events';

export type { EventProperties, UserProperties };

export class EventsModule implements BaseModule {
  private _isReady = false;
  private _config: AdStageConfig | null = null;

  /**
   * Events 모듈 초기화 (동기)
   */
  init(config: AdStageConfig): void {
    this._config = config;
    this._isReady = true;

    if (config.debug) {
      console.log('📊 Events module initialized');
    }
  }

  /**
   * 모듈 준비 상태 확인
   */
  isReady(): boolean {
    return this._isReady;
  }

  /**
   * 모듈 설정 반환
   */
  getConfig(): AdStageConfig | null {
    return this._config;
  }

  /**
   * 사용자 ID 설정
   */
  setUserId(userId: string): void {
    EventSessionManager.setUserId(userId);
    
    if (this._config?.debug) {
      console.log('👤 User ID set:', userId);
    }
  }

  /**
   * 현재 사용자 ID 반환
   */
  getUserId(): string | undefined {
    return EventSessionManager.getUserId();
  }

  /**
   * 사용자 속성 설정
   */
  setUserProperties(properties: UserProperties): void {
    EventUserCollector.setUserProperties(properties);
    
    if (this._config?.debug) {
      console.log('👤 User properties set:', properties);
    }
  }

  /**
   * 현재 사용자 속성 반환
   */
  getUserProperties(): any {
    return EventUserCollector.getCurrentUserProperties();
  }

  /**
   * 디바이스 정보 설정
   */
  setDeviceInfo(deviceInfo: Partial<{
    category: 'mobile' | 'desktop' | 'tablet' | 'other';
    platform: string;
    model: string;
    appVersion: string;
    osVersion: string;
  }>): void {
    EventDeviceCollector.setDeviceInfo(deviceInfo);
    
    if (this._config?.debug) {
      console.log('📱 Device info set:', deviceInfo);
    }
  }

  /**
   * 개별 디바이스 속성 설정
   */
  setDeviceProperty(key: 'category' | 'platform' | 'model' | 'appVersion' | 'osVersion', value: string): void {
    EventDeviceCollector.setDeviceProperty(key, value);
    
    if (this._config?.debug) {
      console.log('📱 Device property set:', key, value);
    }
  }

  /**
   * 사용자 제공 디바이스 정보 초기화
   */
  clearDeviceInfo(): void {
    EventDeviceCollector.clearDeviceInfo();
    
    if (this._config?.debug) {
      console.log('📱 User provided device info cleared');
    }
  }

  /**
   * 현재 사용자가 설정한 디바이스 정보 반환
   */
  getUserDeviceInfo(): any {
    return EventDeviceCollector.getUserDeviceInfo();
  }

  /**
   * 현재 디바이스 정보 반환
   */
  getDeviceInfo(): any {
    return EventDeviceCollector.getDeviceInfo();
  }

  /**
   * 현재 사용자 정보 반환
   */
  getUserInfo(): any {
    return EventUserCollector.getUserInfo();
  }

  /**
   * 현재 사용자 속성 반환 (별칭)
   */
  getCurrentUserProperties(): any {
    return EventUserCollector.getCurrentUserProperties();
  }

  /**
   * 이벤트 추적
   * @param eventName 이벤트 이름
   * @param properties 이벤트 속성
   */
  async track(eventName: string, properties?: EventProperties): Promise<void> {
    if (!this._isReady) {
      console.warn('Events module not initialized. Call AdStage.init() first.');
      return;
    }

    if (!this._config?.apiKey) {
      console.warn('API key not configured for event tracking.');
      return;
    }

    try {
      const eventData = {
        eventName,
        userId: EventSessionManager.getUserId(),
        sessionId: EventSessionManager.getSessionId(),
        sdkVersion: getSDKVersion(),
        device: EventDeviceCollector.getDeviceInfo(),
        user: EventUserCollector.getUserInfo(),
        params: properties || {}
      };

      await this.sendEventToServer(eventData);

      if (this._config.debug) {
        console.log('✅ Event tracked:', eventName, properties);
      }
    } catch (error) {
      console.error('❌ Failed to track event:', error);
      
      if (this._config.debug) {
        console.error('Event data:', { eventName, properties });
      }
    }
  }



  /**
   * 서버에 이벤트 전송
   */
  private async sendEventToServer(eventData: any): Promise<void> {
    const response = await fetch(endpoints.events.track(), {
      method: 'POST',
      headers: {
        ...ApiHeaders.create(this._config!.apiKey),
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(eventData)
    });

    if (!response.ok) {
      throw new Error(`Event tracking failed: ${response.status} ${response.statusText}`);
    }
  }
}