@nextsparkjs/plugin-amplitude 0.1.0-beta.1

package/jest.setup.ts

@@ -0,0 +1,276 @@
+/**
+ * Jest setup file for Amplitude plugin tests
+ */
+
+import '@testing-library/jest-dom';
+
+// Mock window and document objects
+Object.defineProperty(window, 'location', {
+  value: {
+    href: 'https://example.com',
+    pathname: '/',
+    search: '',
+    hash: '',
+    origin: 'https://example.com',
+    protocol: 'https:',
+    host: 'example.com',
+    hostname: 'example.com',
+    port: '',
+    assign: jest.fn(),
+    replace: jest.fn(),
+    reload: jest.fn(),
+  },
+  writable: true,
+});
+
+Object.defineProperty(window, 'navigator', {
+  value: {
+    userAgent: 'Mozilla/5.0 (compatible; Test)',
+    language: 'en-US',
+    onLine: true,
+  },
+  writable: true,
+});
+
+Object.defineProperty(window, 'screen', {
+  value: {
+    width: 1920,
+    height: 1080,
+  },
+  writable: true,
+});
+
+Object.defineProperty(window, 'innerWidth', {
+  value: 1200,
+  writable: true,
+});
+
+Object.defineProperty(window, 'innerHeight', {
+  value: 800,
+  writable: true,
+});
+
+Object.defineProperty(window, 'scrollX', {
+  value: 0,
+  writable: true,
+});
+
+Object.defineProperty(window, 'scrollY', {
+  value: 0,
+  writable: true,
+});
+
+Object.defineProperty(window, 'devicePixelRatio', {
+  value: 2,
+  writable: true,
+});
+
+// Mock performance API
+Object.defineProperty(window, 'performance', {
+  value: {
+    now: jest.fn(() => Date.now()),
+    getEntriesByType: jest.fn(() => []),
+    getEntriesByName: jest.fn(() => []),
+    mark: jest.fn(),
+    measure: jest.fn(),
+    memory: {
+      usedJSHeapSize: 1024 * 1024,
+      totalJSHeapSize: 2 * 1024 * 1024,
+      jsHeapSizeLimit: 4 * 1024 * 1024,
+    },
+  },
+  writable: true,
+});
+
+// Mock document methods
+Object.defineProperty(document, 'title', {
+  value: 'Test Page',
+  writable: true,
+});
+
+Object.defineProperty(document, 'referrer', {
+  value: 'https://example.com',
+  writable: true,
+});
+
+Object.defineProperty(document, 'hidden', {
+  value: false,
+  writable: true,
+});
+
+Object.defineProperty(document, 'visibilityState', {
+  value: 'visible',
+  writable: true,
+});
+
+// Mock localStorage
+const localStorageMock = {
+  getItem: jest.fn(),
+  setItem: jest.fn(),
+  removeItem: jest.fn(),
+  clear: jest.fn(),
+  length: 0,
+  key: jest.fn(),
+};
+
+Object.defineProperty(window, 'localStorage', {
+  value: localStorageMock,
+  writable: true,
+});
+
+// Mock sessionStorage
+const sessionStorageMock = {
+  getItem: jest.fn(),
+  setItem: jest.fn(),
+  removeItem: jest.fn(),
+  clear: jest.fn(),
+  length: 0,
+  key: jest.fn(),
+};
+
+Object.defineProperty(window, 'sessionStorage', {
+  value: sessionStorageMock,
+  writable: true,
+});
+
+// Mock MutationObserver
+class MockMutationObserver {
+  constructor(callback: MutationCallback) {
+    this.callback = callback;
+  }
+  
+  private callback: MutationCallback;
+  
+  observe = jest.fn();
+  disconnect = jest.fn();
+  takeRecords = jest.fn(() => []);
+}
+
+Object.defineProperty(window, 'MutationObserver', {
+  value: MockMutationObserver,
+  writable: true,
+});
+
+// Mock IntersectionObserver
+class MockIntersectionObserver {
+  constructor(callback: IntersectionObserverCallback, options?: IntersectionObserverInit) {
+    this.callback = callback;
+    this.options = options;
+  }
+  
+  private callback: IntersectionObserverCallback;
+  private options?: IntersectionObserverInit;
+  
+  observe = jest.fn();
+  unobserve = jest.fn();
+  disconnect = jest.fn();
+  takeRecords = jest.fn(() => []);
+}
+
+Object.defineProperty(window, 'IntersectionObserver', {
+  value: MockIntersectionObserver,
+  writable: true,
+});
+
+// Mock ResizeObserver
+class MockResizeObserver {
+  constructor(callback: ResizeObserverCallback) {
+    this.callback = callback;
+  }
+  
+  private callback: ResizeObserverCallback;
+  
+  observe = jest.fn();
+  unobserve = jest.fn();
+  disconnect = jest.fn();
+}
+
+Object.defineProperty(window, 'ResizeObserver', {
+  value: MockResizeObserver,
+  writable: true,
+});
+
+// Mock setTimeout and setInterval for consistent testing
+global.setTimeout = jest.fn((fn, delay) => {
+  if (typeof fn === 'function') {
+    return setTimeout(fn, delay);
+  }
+  return setTimeout(fn, delay);
+}) as any;
+
+global.setInterval = jest.fn((fn, delay) => {
+  if (typeof fn === 'function') {
+    return setInterval(fn, delay);
+  }
+  return setInterval(fn, delay);
+}) as any;
+
+global.clearTimeout = jest.fn(clearTimeout);
+global.clearInterval = jest.fn(clearInterval);
+
+// Mock console methods to reduce noise in tests
+const originalConsole = global.console;
+global.console = {
+  ...originalConsole,
+  log: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  info: jest.fn(),
+  debug: jest.fn(),
+};
+
+// Mock fetch for API calls
+global.fetch = jest.fn(() =>
+  Promise.resolve({
+    ok: true,
+    status: 200,
+    json: () => Promise.resolve({}),
+    text: () => Promise.resolve(''),
+    blob: () => Promise.resolve(new Blob()),
+  })
+) as jest.Mock;
+
+// Mock crypto for UUID generation
+Object.defineProperty(global, 'crypto', {
+  value: {
+    randomUUID: jest.fn(() => 'test-uuid-1234-5678'),
+    getRandomValues: jest.fn((arr) => {
+      for (let i = 0; i < arr.length; i++) {
+        arr[i] = Math.floor(Math.random() * 256);
+      }
+      return arr;
+    }),
+  },
+  writable: true,
+});
+
+// Error boundary for React components
+const originalError = console.error;
+beforeAll(() => {
+  console.error = (...args) => {
+    if (
+      typeof args[0] === 'string' &&
+      args[0].includes('Warning: ReactDOM.render is no longer supported')
+    ) {
+      return;
+    }
+    originalError.call(console, ...args);
+  };
+});
+
+afterAll(() => {
+  console.error = originalError;
+});
+
+// Clean up after each test
+afterEach(() => {
+  jest.clearAllMocks();
+  localStorageMock.getItem.mockClear();
+  localStorageMock.setItem.mockClear();
+  localStorageMock.removeItem.mockClear();
+  localStorageMock.clear.mockClear();
+  sessionStorageMock.getItem.mockClear();
+  sessionStorageMock.setItem.mockClear();
+  sessionStorageMock.removeItem.mockClear();
+  sessionStorageMock.clear.mockClear();
+});

package/lib/amplitude-core.ts

@@ -0,0 +1,178 @@
+import { AmplitudeAPIKey, AmplitudePluginConfig, EventProperties, EventType, UserProperties, UserId } from '../types/amplitude.types';
+import { trackPerformanceMetric, getPerformanceMetrics } from './performance';
+import { EventQueue } from './queue';
+import { DataSanitizer } from './security';
+
+class AmplitudeCoreWrapper {
+  private initialized = false;
+  private config: AmplitudePluginConfig | null = null;
+  private eventQueue: EventQueue;
+  private healthCheckInterval: NodeJS.Timeout | null = null;
+
+  constructor() {
+    this.eventQueue = new EventQueue(this.sendEventsBatch.bind(this));
+  }
+
+  public async init(apiKey: AmplitudeAPIKey, config: AmplitudePluginConfig): Promise<void> {
+    try {
+      // Check for double initialization
+      if (this.initialized) {
+        throw new Error('Amplitude is already initialized');
+      }
+
+      // Validate API key (must be at least 32 characters)
+      if (!apiKey || apiKey.length < 32) {
+        throw new Error('Invalid API key: Must be at least 32 characters');
+      }
+
+      this.config = config;
+
+      // Initialize Amplitude SDK (mock for now)
+      console.log(`[Amplitude Core] Initializing with API key: ${apiKey.substring(0, 8)}...`);
+
+      // Simulate async initialization
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      this.initialized = true;
+      this.startHealthChecks();
+
+      trackPerformanceMetric('amplitude_init_success', 1, 'counter');
+      console.log('[Amplitude Core] Successfully initialized');
+    } catch (error) {
+      trackPerformanceMetric('amplitude_init_error', 1, 'counter');
+      throw new Error(`Failed to initialize Amplitude: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  public async track(eventType: EventType, properties?: EventProperties): Promise<void> {
+    if (!this.initialized) {
+      throw new Error('Amplitude not initialized');
+    }
+
+    const startTime = Date.now();
+    
+    try {
+      // Sanitize properties
+      const sanitizedProperties = this.config?.piiMaskingEnabled 
+        ? DataSanitizer.sanitizeEventProperties(properties, [])
+        : properties;
+
+      // Add to queue for batch processing
+      await this.eventQueue.enqueue(eventType, sanitizedProperties);
+      
+      const latency = Date.now() - startTime;
+      trackPerformanceMetric('amplitude_track_latency', latency, 'timing');
+    } catch (error) {
+      trackPerformanceMetric('amplitude_track_error', 1, 'counter');
+      throw error;
+    }
+  }
+
+  private async sendEventsBatch(events: Array<{ eventType: EventType; properties?: EventProperties; timestamp?: number }>): Promise<void> {
+    if (!this.initialized || events.length === 0) return;
+
+    try {
+      // Mock sending to Amplitude API
+      console.log(`[Amplitude Core] Sending batch of ${events.length} events`);
+      
+      // Simulate API call
+      await new Promise(resolve => setTimeout(resolve, Math.random() * 100 + 50));
+      
+      trackPerformanceMetric('amplitude_batch_sent', events.length, 'counter');
+    } catch (error) {
+      trackPerformanceMetric('amplitude_batch_error', 1, 'counter');
+      throw error;
+    }
+  }
+
+  public async identify(userId: UserId, properties?: UserProperties): Promise<void> {
+    if (!this.initialized) {
+      throw new Error('Amplitude not initialized');
+    }
+
+    try {
+      // Sanitize user properties
+      const sanitizedProperties = this.config?.piiMaskingEnabled 
+        ? DataSanitizer.sanitizeUserProperties(properties, [])
+        : properties;
+
+      // Mock identify call
+      console.log(`[Amplitude Core] Identifying user: ${userId}`);
+      
+      trackPerformanceMetric('amplitude_identify_success', 1, 'counter');
+    } catch (error) {
+      trackPerformanceMetric('amplitude_identify_error', 1, 'counter');
+      throw error;
+    }
+  }
+
+  public async setUserProperties(properties: UserProperties): Promise<void> {
+    if (!this.initialized) {
+      throw new Error('Amplitude not initialized');
+    }
+
+    try {
+      // Sanitize user properties
+      const sanitizedProperties = this.config?.piiMaskingEnabled 
+        ? DataSanitizer.sanitizeUserProperties(properties, [])
+        : properties;
+
+      // Mock setUserProperties call
+      console.log('[Amplitude Core] Setting user properties');
+      
+      trackPerformanceMetric('amplitude_user_properties_success', 1, 'counter');
+    } catch (error) {
+      trackPerformanceMetric('amplitude_user_properties_error', 1, 'counter');
+      throw error;
+    }
+  }
+
+  public reset(): void {
+    if (!this.initialized) {
+      throw new Error('Amplitude not initialized');
+    }
+
+    try {
+      // Mock reset call
+      console.log('[Amplitude Core] Resetting user session');
+      
+      trackPerformanceMetric('amplitude_reset', 1, 'counter');
+    } catch (error) {
+      trackPerformanceMetric('amplitude_reset_error', 1, 'counter');
+      throw error;
+    }
+  }
+
+  public isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  public shutdown(): void {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+    
+    this.eventQueue.shutdown();
+    this.initialized = false;
+    
+    console.log('[Amplitude Core] Shutdown complete');
+  }
+
+  private startHealthChecks(): void {
+    this.healthCheckInterval = setInterval(() => {
+      const metrics = getPerformanceMetrics();
+      const memoryUsage = (performance as any).memory?.usedJSHeapSize || 0;
+      
+      trackPerformanceMetric('amplitude_memory_usage', memoryUsage, 'gauge');
+      trackPerformanceMetric('amplitude_health_check', 1, 'counter');
+      
+      // Check for performance issues
+      if (memoryUsage > 50 * 1024 * 1024) { // 50MB
+        console.warn('[Amplitude Core] High memory usage detected:', memoryUsage);
+      }
+    }, 30000); // Every 30 seconds
+  }
+}
+
+export const AmplitudeCore = new AmplitudeCoreWrapper();

package/lib/cache.ts

@@ -0,0 +1,181 @@
+interface CacheEntry<T> {
+  value: T;
+  timestamp: number;
+  ttl: number;
+  hits: number;
+  lastAccessed: number;
+}
+
+export class LRUCache<K, V> {
+  private cache: Map<K, CacheEntry<V>> = new Map();
+  private maxSize: number;
+  private defaultTtl: number;
+  private hitCount = 0;
+  private missCount = 0;
+
+  constructor(maxSize: number = 1000, defaultTtl: number = 300000) { // 5 minutes default TTL
+    this.maxSize = maxSize;
+    this.defaultTtl = defaultTtl;
+  }
+
+  public get(key: K): V | undefined {
+    const entry = this.cache.get(key);
+    
+    if (!entry) {
+      this.missCount++;
+      return undefined;
+    }
+
+    // Check if expired
+    if (Date.now() > entry.timestamp + entry.ttl) {
+      this.cache.delete(key);
+      this.missCount++;
+      return undefined;
+    }
+
+    // Update access stats
+    entry.hits++;
+    entry.lastAccessed = Date.now();
+    this.hitCount++;
+
+    // Move to end (most recently used)
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+
+    return entry.value;
+  }
+
+  public set(key: K, value: V, ttl?: number): void {
+    const now = Date.now();
+    const entryTtl = ttl || this.defaultTtl;
+
+    // Remove existing entry if it exists
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      // Remove least recently used item
+      this.evictLRU();
+    }
+
+    // Add new entry
+    this.cache.set(key, {
+      value,
+      timestamp: now,
+      ttl: entryTtl,
+      hits: 0,
+      lastAccessed: now,
+    });
+  }
+
+  public delete(key: K): boolean {
+    return this.cache.delete(key);
+  }
+
+  public has(key: K): boolean {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+
+    // Check if expired
+    if (Date.now() > entry.timestamp + entry.ttl) {
+      this.cache.delete(key);
+      return false;
+    }
+
+    return true;
+  }
+
+  public clear(): void {
+    this.cache.clear();
+    this.hitCount = 0;
+    this.missCount = 0;
+  }
+
+  public size(): number {
+    this.cleanupExpired();
+    return this.cache.size;
+  }
+
+  public getStats(): {
+    size: number;
+    maxSize: number;
+    hitRate: number;
+    missRate: number;
+    totalHits: number;
+    totalMisses: number;
+  } {
+    this.cleanupExpired();
+    const total = this.hitCount + this.missCount;
+    
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hitRate: total > 0 ? this.hitCount / total : 0,
+      missRate: total > 0 ? this.missCount / total : 0,
+      totalHits: this.hitCount,
+      totalMisses: this.missCount,
+    };
+  }
+
+  public getEntryStats(key: K): {
+    hits: number;
+    age: number;
+    ttl: number;
+    lastAccessed: number;
+  } | null {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+
+    return {
+      hits: entry.hits,
+      age: Date.now() - entry.timestamp,
+      ttl: entry.ttl,
+      lastAccessed: entry.lastAccessed,
+    };
+  }
+
+  private evictLRU(): void {
+    // Find the least recently used entry
+    let lruKey: K | null = null;
+    let oldestAccess = Date.now();
+
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.lastAccessed < oldestAccess) {
+        oldestAccess = entry.lastAccessed;
+        lruKey = key;
+      }
+    }
+
+    if (lruKey !== null) {
+      this.cache.delete(lruKey);
+    }
+  }
+
+  private cleanupExpired(): void {
+    const now = Date.now();
+    const expiredKeys: K[] = [];
+
+    for (const [key, entry] of this.cache.entries()) {
+      if (now > entry.timestamp + entry.ttl) {
+        expiredKeys.push(key);
+      }
+    }
+
+    expiredKeys.forEach(key => this.cache.delete(key));
+  }
+
+  public keys(): K[] {
+    this.cleanupExpired();
+    return Array.from(this.cache.keys());
+  }
+
+  public values(): V[] {
+    this.cleanupExpired();
+    return Array.from(this.cache.values()).map(entry => entry.value);
+  }
+
+  public entries(): [K, V][] {
+    this.cleanupExpired();
+    return Array.from(this.cache.entries()).map(([key, entry]) => [key, entry.value]);
+  }
+}
+