@nextsparkjs/plugin-amplitude 0.1.0-beta.1

package/lib/security.ts

@@ -0,0 +1,188 @@
+import { EventProperties, UserProperties } from '../types/amplitude.types';
+
+export type PIIPattern = {
+  regex: RegExp;
+  mask: string;
+};
+
+export class DataSanitizer {
+  public static sanitizeEventProperties(properties: EventProperties | undefined, piiPatterns: PIIPattern[]): EventProperties | undefined {
+    if (!properties) return properties;
+
+    const sanitized = { ...properties };
+    
+    for (const [key, value] of Object.entries(sanitized)) {
+      if (typeof value === 'string') {
+        sanitized[key] = this.sanitizeString(value, piiPatterns);
+      } else if (typeof value === 'object' && value !== null) {
+        sanitized[key] = this.sanitizeEventProperties(value, piiPatterns);
+      }
+    }
+
+    return sanitized;
+  }
+
+  public static sanitizeUserProperties(properties: UserProperties | undefined, piiPatterns: PIIPattern[]): UserProperties | undefined {
+    if (!properties) return properties;
+
+    const sanitized = { ...properties };
+    
+    for (const [key, value] of Object.entries(sanitized)) {
+      if (typeof value === 'string') {
+        sanitized[key] = this.sanitizeString(value, piiPatterns);
+      } else if (typeof value === 'object' && value !== null) {
+        sanitized[key] = this.sanitizeUserProperties(value, piiPatterns);
+      }
+    }
+
+    return sanitized;
+  }
+
+  private static sanitizeString(text: string, piiPatterns: PIIPattern[]): string {
+    let sanitized = text;
+    
+    for (const pattern of piiPatterns) {
+      sanitized = sanitized.replace(pattern.regex, pattern.mask);
+    }
+
+    return sanitized;
+  }
+}
+
+interface RateLimitEntry {
+  count: number;
+  firstRequest: number;
+  lastRequest: number;
+}
+
+export class SlidingWindowRateLimiter {
+  private requests = new Map<string, RateLimitEntry>();
+  private maxRequests: number;
+  private windowMs: number;
+
+  constructor(maxRequests: number, windowMs: number) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+  }
+
+  public checkRateLimit(identifier: string): boolean {
+    const now = Date.now();
+    const entry = this.requests.get(identifier);
+
+    if (!entry) {
+      this.requests.set(identifier, {
+        count: 1,
+        firstRequest: now,
+        lastRequest: now,
+      });
+      return true;
+    }
+
+    // Clean old entries
+    if (now - entry.firstRequest > this.windowMs) {
+      this.requests.set(identifier, {
+        count: 1,
+        firstRequest: now,
+        lastRequest: now,
+      });
+      return true;
+    }
+
+    // Check if under limit
+    if (entry.count < this.maxRequests) {
+      entry.count++;
+      entry.lastRequest = now;
+      return true;
+    }
+
+    return false;
+  }
+
+  public getRemainingRequests(identifier: string): number {
+    const entry = this.requests.get(identifier);
+    if (!entry) return this.maxRequests;
+
+    const now = Date.now();
+    if (now - entry.firstRequest > this.windowMs) {
+      return this.maxRequests;
+    }
+
+    return Math.max(0, this.maxRequests - entry.count);
+  }
+}
+
+export type AuditLogSeverity = 'INFO' | 'WARN' | 'ERROR' | 'CRITICAL';
+
+export interface AuditLogEntry {
+  id: string;
+  timestamp: number;
+  event: string;
+  data: any;
+  severity: AuditLogSeverity;
+  source: string;
+}
+
+export class SecurityAuditLogger {
+  private logs: AuditLogEntry[] = [];
+  private maxLogs: number;
+  private retentionDays: number;
+
+  constructor(retentionDays: number = 30, maxLogs: number = 10000) {
+    this.retentionDays = retentionDays;
+    this.maxLogs = maxLogs;
+  }
+
+  public log(event: string, data: any, severity: AuditLogSeverity = 'INFO', source: string = 'amplitude-plugin'): void {
+    const entry: AuditLogEntry = {
+      id: `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      timestamp: Date.now(),
+      event,
+      data,
+      severity,
+      source,
+    };
+
+    this.logs.push(entry);
+    this.cleanup();
+
+    // Log to console for debugging
+    const logLevel = severity === 'CRITICAL' || severity === 'ERROR' ? 'error' : 
+                    severity === 'WARN' ? 'warn' : 'log';
+    console[logLevel](`[Audit] ${event}:`, data);
+  }
+
+  public getLogs(startTime?: number, endTime?: number, severity?: AuditLogSeverity): AuditLogEntry[] {
+    let filteredLogs = this.logs;
+
+    if (startTime) {
+      filteredLogs = filteredLogs.filter(log => log.timestamp >= startTime);
+    }
+
+    if (endTime) {
+      filteredLogs = filteredLogs.filter(log => log.timestamp <= endTime);
+    }
+
+    if (severity) {
+      filteredLogs = filteredLogs.filter(log => log.severity === severity);
+    }
+
+    return filteredLogs.sort((a, b) => b.timestamp - a.timestamp);
+  }
+
+  private cleanup(): void {
+    const now = Date.now();
+    const cutoffTime = now - (this.retentionDays * 24 * 60 * 60 * 1000);
+
+    // Remove old logs
+    this.logs = this.logs.filter(log => log.timestamp > cutoffTime);
+
+    // Remove excess logs
+    if (this.logs.length > this.maxLogs) {
+      this.logs = this.logs.slice(-this.maxLogs);
+    }
+  }
+}
+
+export const dataSanitizer = DataSanitizer;
+export const rateLimiter = new SlidingWindowRateLimiter(1000, 60000); // 1000 requests per minute
+export const auditLogger = new SecurityAuditLogger(30);

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@nextsparkjs/plugin-amplitude",
+  "version": "0.1.0-beta.1",
+  "private": false,
+  "main": "./plugin.config.ts",
+  "requiredPlugins": [],
+  "dependencies": {},
+  "peerDependencies": {
+    "@nextsparkjs/core": "workspace:*",
+    "next": "^15.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "zod": "^4.0.0"
+  }
+}

package/plugin.config.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import type { PluginConfig } from '@nextsparkjs/core/types/plugin';
+
+const AmplitudePluginConfigSchema = z.object({
+  apiKey: z.string().regex(/^[a-zA-Z0-9]{32}$/, "Invalid Amplitude API Key format").describe("Amplitude API Key"),
+  serverZone: z.enum(['US', 'EU']).default('US').describe("Amplitude server zone"),
+  enableSessionReplay: z.boolean().default(false).describe("Enable session replay recording"),
+  enableABTesting: z.boolean().default(false).describe("Enable A/B testing experiments"),
+  sampleRate: z.number().min(0).max(1).default(1).describe("Event sampling rate (0-1)"),
+  enableConsentManagement: z.boolean().default(true).describe("Enable GDPR/CCPA consent management"),
+  batchSize: z.number().min(1).max(100).default(30).describe("Number of events to batch before sending"),
+  flushInterval: z.number().min(1000).max(60000).default(10000).describe("Interval in ms to flush event queue"),
+  debugMode: z.boolean().default(false).describe("Enable debug logging for Amplitude plugin"),
+  piiMaskingEnabled: z.boolean().default(true).describe("Enable automatic PII masking"),
+  rateLimitEventsPerMinute: z.number().min(10).max(5000).default(1000).describe("Max events per minute per user/IP"),
+  errorRetryAttempts: z.number().min(0).max(5).default(3).describe("Number of retry attempts for failed events"),
+  errorRetryDelayMs: z.number().min(100).max(10000).default(1000).describe("Delay in ms between retry attempts"),
+});
+
+export const amplitudePlugin: PluginConfig = {
+  name: 'amplitude',
+  version: '1.0.0',
+  displayName: 'Amplitude Analytics',
+  description: 'Advanced user analytics and behavioral tracking plugin for SaaS applications.',
+  enabled: true,
+  dependencies: [],
+
+  // Plugin components that can be used throughout the app
+  components: {
+    ConsentManager: undefined, // Would contain actual component
+    AnalyticsDashboard: undefined,
+    ExperimentWrapper: undefined,
+    PerformanceMonitor: undefined
+  },
+
+  // Plugin services/hooks that can be used by other parts of the app
+  services: {
+    // Would contain amplitude-specific services
+  },
+
+  // Plugin lifecycle hooks
+  hooks: {
+    async onLoad() {
+      console.log('[Amplitude Plugin] Loading...');
+    },
+    async onActivate() {
+      console.log('[Amplitude Plugin] Activated');
+    },
+    async onDeactivate() {
+      console.log('[Amplitude Plugin] Deactivated');
+    },
+    async onUnload() {
+      console.log('[Amplitude Plugin] Unloaded');
+    }
+  }
+};
+
+export default amplitudePlugin;

package/providers/AmplitudeProvider.tsx

@@ -0,0 +1,113 @@
+import React, { createContext, useContext, useState, useEffect, useRef, useCallback } from 'react';
+import { AmplitudeCore } from '../lib/amplitude-core';
+import { amplitudePlugin } from '../plugin.config';
+import { AmplitudePluginConfig, AmplitudePluginContext, ConsentState, isAmplitudeAPIKey } from '../types/amplitude.types';
+
+const AmplitudeContext = createContext<AmplitudePluginContext | undefined>(undefined);
+
+export const AmplitudeProvider: React.FC<{ children: React.ReactNode; overrideConfig?: Partial<AmplitudePluginConfig> }> = ({ 
+  children, 
+  overrideConfig 
+}) => {
+  const [isInitialized, setIsInitialized] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+  const [consent, setConsent] = useState<ConsentState>({ 
+    analytics: false, 
+    sessionReplay: false, 
+    experiments: false, 
+    performance: false 
+  });
+
+  // TODO: Fix plugin config schema integration
+  const pluginConfig = overrideConfig as AmplitudePluginConfig;
+  const configLoading = false;
+  const configError = null;
+
+  const currentConfig = useRef<AmplitudePluginConfig | null>(null);
+  const retryCount = useRef(0);
+  const MAX_RETRIES = pluginConfig?.errorRetryAttempts || 3;
+  const RETRY_DELAY_MS = pluginConfig?.errorRetryDelayMs || 1000;
+
+  const initializeAmplitude = useCallback(async (config: AmplitudePluginConfig) => {
+    if (!config.apiKey || !isAmplitudeAPIKey(config.apiKey)) {
+      throw new Error('Invalid Amplitude API key');
+    }
+
+    try {
+      await AmplitudeCore.init(config.apiKey as any, config);
+      setIsInitialized(true);
+      setError(null);
+      retryCount.current = 0;
+      console.log('[Amplitude] Successfully initialized');
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error('Failed to initialize Amplitude');
+      
+      if (retryCount.current < MAX_RETRIES) {
+        retryCount.current++;
+        console.warn(`[Amplitude] Initialization failed, retrying in ${RETRY_DELAY_MS}ms (attempt ${retryCount.current}/${MAX_RETRIES})`);
+        
+        setTimeout(() => {
+          initializeAmplitude(config);
+        }, RETRY_DELAY_MS);
+      } else {
+        setError(error);
+        setIsInitialized(false);
+        console.error('[Amplitude] Initialization failed after max retries:', error);
+      }
+    }
+  }, [MAX_RETRIES, RETRY_DELAY_MS]);
+
+  const updateConsent = useCallback((newConsent: ConsentState) => {
+    setConsent(newConsent);
+    localStorage.setItem('amplitude_consent', JSON.stringify(newConsent));
+  }, []);
+
+  useEffect(() => {
+    const savedConsent = localStorage.getItem('amplitude_consent');
+    if (savedConsent) {
+      try {
+        setConsent(JSON.parse(savedConsent));
+      } catch (error) {
+        console.warn('[Amplitude] Failed to parse saved consent:', error);
+      }
+    }
+  }, []);
+
+  useEffect(() => {
+    if (pluginConfig && !configLoading && !configError && !isInitialized && !error) {
+      currentConfig.current = { ...pluginConfig, ...overrideConfig };
+      initializeAmplitude(currentConfig.current);
+    }
+  }, [pluginConfig, configLoading, configError, isInitialized, error, initializeAmplitude, overrideConfig]);
+
+  const contextValue: AmplitudePluginContext = {
+    amplitude: AmplitudeCore,
+    isInitialized,
+    config: currentConfig.current,
+    consent,
+    updateConsent,
+    error,
+  };
+
+  if (configLoading) {
+    return <div>Loading Amplitude configuration...</div>;
+  }
+
+  if (error && !isInitialized) {
+    return <div>Amplitude initialization failed: {error.message}</div>;
+  }
+
+  return (
+    <AmplitudeContext.Provider value={contextValue}>
+      {children}
+    </AmplitudeContext.Provider>
+  );
+};
+
+export const useAmplitudeContext = () => {
+  const context = useContext(AmplitudeContext);
+  if (context === undefined) {
+    throw new Error('useAmplitudeContext must be used within an AmplitudeProvider');
+  }
+  return context;
+};