@umituz/web-traffic 1.0.6

package/src/infrastructure/tracking/web-traffic.service.ts

@@ -0,0 +1,188 @@
+/**
+ * Web Traffic Service
+ * @description Main service for web-traffic (Facade pattern)
+ */
+
+import { EventId } from '../../domains/tracking/value-objects/event-id.vo';
+import { SessionId } from '../../domains/tracking/value-objects/session-id.vo';
+import { SiteId } from '../../domains/affiliate/value-objects/site-id.vo';
+import { DeviceInfo } from '../../domains/tracking/value-objects/device-info.vo';
+import { Session } from '../../domains/tracking/aggregates/session.aggregate';
+import type { Event } from '../../domains/tracking/entities/event.entity';
+import type { Pageview } from '../../domains/tracking/entities/pageview.entity';
+import type { TrackingCommandResult } from '../../domains/tracking/application/tracking-command.service';
+import { TrackingCommandService } from '../../domains/tracking/application/tracking-command.service';
+import {
+  HTTPEventRepository,
+  HTTPPageviewRepository,
+  LocalSessionRepository,
+} from '../repositories/http-event.repository.impl';
+import { HTTPAnalyticsRepository } from '../analytics/http-analytics.repository.impl';
+
+export interface WebTrafficConfig {
+  readonly apiKey: string;
+  readonly apiUrl?: string;
+  readonly autoTrack?: boolean;
+}
+
+class WebTrafficService {
+  private initialized = false;
+  private commandService: TrackingCommandService | null = null;
+  private currentSession: Session | null = null;
+  private eventRepo: HTTPEventRepository | null = null;
+  private pageviewRepo: HTTPPageviewRepository | null = null;
+  private sessionRepo: LocalSessionRepository | null = null;
+
+  initialize(config: WebTrafficConfig): void {
+    if (this.initialized) {
+      console.warn('WebTrafficService already initialized');
+      return;
+    }
+
+    const apiUrl = config.apiUrl ?? 'https://analytics.umituz.com';
+
+    // Initialize repositories
+    this.eventRepo = new HTTPEventRepository({ apiUrl, apiKey: config.apiKey });
+    this.pageviewRepo = new HTTPPageviewRepository({ apiUrl, apiKey: config.apiKey });
+    this.sessionRepo = new LocalSessionRepository();
+
+    // Initialize command service
+    this.commandService = new TrackingCommandService(
+      this.sessionRepo,
+      this.eventRepo,
+      this.pageviewRepo
+    );
+
+    // Get or create session
+    this.initializeSession();
+
+    // Setup auto-tracking if enabled
+    if (config.autoTrack && typeof window !== 'undefined') {
+      this.setupAutoTrack();
+    }
+
+    this.initialized = true;
+  }
+
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  async trackEvent(
+    name: string,
+    properties: Record<string, unknown> = {}
+  ): Promise<TrackingCommandResult> {
+    if (!this.commandService || !this.currentSession) {
+      return { success: false, error: 'Service not initialized' };
+    }
+
+    return this.commandService.trackEvent(
+      this.currentSession.id.toString(),
+      name,
+      properties
+    );
+  }
+
+  async trackPageView(path?: string): Promise<TrackingCommandResult> {
+    if (!this.commandService || !this.currentSession) {
+      return { success: false, error: 'Service not initialized' };
+    }
+
+    const currentPath = path ?? (typeof window !== 'undefined' ? window.location.pathname : '/');
+    const referrer = typeof window !== 'undefined' ? document.referrer : null;
+
+    return this.commandService.trackPageview(
+      this.currentSession.id.toString(),
+      currentPath,
+      referrer,
+      this.getUTMFromURL()
+    );
+  }
+
+  private async initializeSession(): Promise<void> {
+    if (!this.sessionRepo) return;
+
+    const deviceId = this.getOrCreateDeviceId();
+    const existingSession = await this.sessionRepo.findActive(deviceId);
+
+    if (existingSession) {
+      this.currentSession = existingSession;
+    } else {
+      const sessionId = SessionId.generate();
+      const siteId = SiteId.generate();
+      const deviceInfo = DeviceInfo.fromUserAgent(
+        typeof window !== 'undefined' ? navigator.userAgent : '',
+        typeof window !== 'undefined' ? window.screen.width : undefined
+      );
+
+      this.currentSession = new Session({
+        id: sessionId,
+        deviceId,
+        siteId,
+        deviceInfo,
+      });
+      await this.sessionRepo.save(this.currentSession);
+    }
+  }
+
+  private getOrCreateDeviceId(): string {
+    if (typeof window === 'undefined') return '';
+
+    let deviceId = localStorage.getItem('wt_device_id');
+    if (!deviceId) {
+      deviceId = `device-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+      localStorage.setItem('wt_device_id', deviceId);
+    }
+
+    return deviceId;
+  }
+
+  private getUTMFromURL() {
+    if (typeof window === 'undefined') return undefined;
+
+    const searchParams = new URLSearchParams(window.location.search);
+    const source = searchParams.get('utm_source') || undefined;
+    const medium = searchParams.get('utm_medium') || undefined;
+    const campaign = searchParams.get('utm_campaign') || undefined;
+    const term = searchParams.get('utm_term') || undefined;
+    const content = searchParams.get('utm_content') || undefined;
+
+    if (!source && !medium && !campaign && !term && !content) {
+      return undefined;
+    }
+
+    return { source, medium, campaign, term, content };
+  }
+
+  private setupAutoTrack(): void {
+    if (typeof window === 'undefined') return;
+
+    // Track initial pageview
+    this.trackPageView();
+
+    // Track SPA navigation
+    const originalPushState = history.pushState;
+    const originalReplaceState = history.replaceState;
+
+    history.pushState = (...args) => {
+      originalPushState.apply(history, args);
+      this.trackPageView();
+    };
+
+    history.replaceState = (...args) => {
+      originalReplaceState.apply(history, args);
+      this.trackPageView();
+    };
+
+    window.addEventListener('popstate', () => {
+      this.trackPageView();
+    });
+  }
+
+  destroy(): void {
+    this.eventRepo?.destroy();
+    this.initialized = false;
+  }
+}
+
+export const webTrafficService = new WebTrafficService();

package/src/presentation/context.tsx

@@ -0,0 +1,43 @@
+/**
+ * Web Traffic React Context
+ * @description React context provider for web-traffic tracking
+ */
+
+import type { createContext } from 'react';
+import { createContext, useContext, useEffect, useMemo, type ReactNode } from 'react';
+import { webTrafficService, type WebTrafficConfig } from '../infrastructure/tracking/web-traffic.service';
+import type { WebTrafficContextValue, TrackingCommandResult } from './hooks';
+
+const TrackingContext = createContext<WebTrafficContextValue | null>(null);
+
+export interface WebTrafficProviderProps {
+  readonly children: ReactNode;
+  readonly config: WebTrafficConfig;
+}
+
+export function WebTrafficProvider({ children, config }: WebTrafficProviderProps): React.ReactElement {
+  useEffect(() => {
+    webTrafficService.initialize(config);
+
+    return () => {
+      webTrafficService.destroy();
+    };
+  }, [config]);
+
+  const value = useMemo<WebTrafficContextValue>(
+    () => ({
+      trackEvent: async (name: string, properties?: Record<string, unknown>) => {
+        return webTrafficService.trackEvent(name, properties);
+      },
+      trackPageView: async (path?: string) => {
+        return webTrafficService.trackPageView(path);
+      },
+      isInitialized: webTrafficService.isInitialized(),
+    }),
+    []
+  );
+
+  return <TrackingContext.Provider value={value}>{children}</TrackingContext.Provider>;
+}
+
+export { TrackingContext as WebTrafficContext };

package/src/presentation/hooks.ts

@@ -0,0 +1,78 @@
+/**
+ * Web Traffic React Hooks
+ * @description React hooks for web-traffic tracking
+ */
+
+import { useContext, useCallback, useEffect, useState } from 'react';
+import { WebTrafficContext } from './context';
+import { webTrafficService } from '../infrastructure/tracking/web-traffic.service';
+import { HTTPAnalyticsRepository } from '../infrastructure/analytics/http-analytics.repository.impl';
+import type { AnalyticsQuery } from '../domains/analytics/repositories/analytics.repository.interface';
+import type { AnalyticsData } from '../domains/analytics/entities/analytics.entity';
+
+export interface TrackingCommandResult {
+  success: boolean;
+  eventId?: string;
+  error?: string;
+}
+
+export interface WebTrafficContextValue {
+  readonly trackEvent: (name: string, properties?: Record<string, unknown>) => Promise<TrackingCommandResult>;
+  readonly trackPageView: (path?: string) => Promise<TrackingCommandResult>;
+  readonly isInitialized: boolean;
+}
+
+export function useWebTraffic(): WebTrafficContextValue {
+  const context = useContext(WebTrafficContext);
+
+  if (!context) {
+    // If no context, use service directly
+    return {
+      trackEvent: useCallback(async (name: string, properties?: Record<string, unknown>) => {
+        return webTrafficService.trackEvent(name, properties);
+      }, []),
+      trackPageView: useCallback(async (path?: string) => {
+        return webTrafficService.trackPageView(path);
+      }, []),
+      isInitialized: webTrafficService.isInitialized(),
+    };
+  }
+
+  return context;
+}
+
+export function useAnalytics(query: AnalyticsQuery) {
+  const [data, setData] = useState<AnalyticsData | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function fetchAnalytics() {
+      setLoading(true);
+      setError(null);
+
+      // Note: You'll need to initialize this with proper config
+      const repo = new HTTPAnalyticsRepository({
+        apiUrl: 'https://analytics.umituz.com',
+        apiKey: 'your-api-key', // This should come from config
+      });
+
+      const result = await repo.getAnalytics(query);
+
+      if (!cancelled) {
+        setData(result);
+        setLoading(false);
+      }
+    }
+
+    fetchAnalytics();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [query]);
+
+  return { data, loading, error };
+}

package/src/presentation/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Presentation Layer Export
+ * Subpath: @umituz/web-traffic/presentation
+ */
+
+export { useWebTraffic, useAnalytics } from './hooks';
+export type { WebTrafficContextValue } from './hooks';
+
+export { WebTrafficProvider } from './context';
+export { WebTrafficContext } from './context';
+export type { WebTrafficProviderProps } from './context';