@cognior/iap-sdk 0.1.0

package/src/services/userContextService.ts

@@ -0,0 +1,286 @@
+// src/services/userContextService.ts
+// Standard User Context Handling for DAP SDK
+
+/**
+ * User interface - follows DAP standard user model
+ */
+export interface DapUser {
+  id: string;
+  role?: string;
+  email?: string;
+  attributes?: Record<string, string>;
+}
+
+/**
+ * Analytics context structure
+ */
+export interface UserAnalyticsContext {
+  userId: string;
+  role?: string;
+  attributes?: Record<string, string>;
+  isAnonymous: boolean;
+}
+
+/**
+ * User context change event
+ */
+export interface UserContextChangeEvent {
+  type: 'user-changed' | 'user-cleared';
+  user: DapUser | null;
+  previousUser: DapUser | null;
+}
+
+/**
+ * UserContextService - Singleton service for managing user context in DAP SDK
+ * 
+ * SECURITY CONSTRAINTS:
+ * - NEVER infer user identity
+ * - Only accept explicitly provided data
+ * - Host application is source of truth
+ */
+export class UserContextService {
+  private static _instance: UserContextService | null = null;
+  private _user: DapUser | null = null;
+  private _fallbackUserId: string | null = null;
+  private _eventListeners: ((event: UserContextChangeEvent) => void)[] = [];
+  
+  private readonly SESSION_STORAGE_KEY = 'dap_user_context';
+  private readonly FALLBACK_USER_KEY = 'dap_anonymous_user_id';
+
+  private constructor() {
+    this.initializeFromStorage();
+    console.debug('[DAP UserContext] Service initialized');
+  }
+
+  /**
+   * Get singleton instance
+   */
+  public static getInstance(): UserContextService {
+    if (!this._instance) {
+      this._instance = new UserContextService();
+    }
+    return this._instance;
+  }
+
+  /**
+   * Initialize user context from sessionStorage
+   */
+  private initializeFromStorage(): void {
+    try {
+      // Restore user context
+      const storedUser = sessionStorage.getItem(this.SESSION_STORAGE_KEY);
+      if (storedUser) {
+        this._user = JSON.parse(storedUser);
+        console.debug('[DAP UserContext] Restored user from storage:', this._user?.id);
+      }
+
+      // Restore or generate fallback user ID
+      this._fallbackUserId = sessionStorage.getItem(this.FALLBACK_USER_KEY);
+      if (!this._fallbackUserId) {
+        this._fallbackUserId = this.generateFallbackUserId();
+        sessionStorage.setItem(this.FALLBACK_USER_KEY, this._fallbackUserId);
+        console.debug('[DAP UserContext] Generated fallback user ID:', this._fallbackUserId);
+      }
+    } catch (error) {
+      console.error('[DAP UserContext] Error initializing from storage:', error);
+      this._fallbackUserId = this.generateFallbackUserId();
+    }
+  }
+
+  /**
+   * Generate a stable unique fallback user ID
+   */
+  private generateFallbackUserId(): string {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 15);
+    return `dap-anon-${timestamp}-${random}`;
+  }
+
+  /**
+   * Set user context (replaces existing user)
+   */
+  public setUser(user: DapUser): void {
+    if (!user || !user.id) {
+      console.error('[DAP UserContext] Invalid user - id is required');
+      return;
+    }
+
+    const previousUser = this._user;
+    this._user = { ...user };
+
+    // Persist to sessionStorage
+    try {
+      sessionStorage.setItem(this.SESSION_STORAGE_KEY, JSON.stringify(this._user));
+    } catch (error) {
+      console.error('[DAP UserContext] Error persisting user:', error);
+    }
+
+    console.debug('[DAP UserContext] User set:', this._user.id);
+    this.notifyListeners({ type: 'user-changed', user: this._user, previousUser });
+  }
+
+  /**
+   * Update user context (merge with existing data)
+   */
+  public updateUser(partialUser: Partial<DapUser>): void {
+    if (!this._user) {
+      console.warn('[DAP UserContext] Cannot update - no user context available');
+      return;
+    }
+
+    const previousUser = { ...this._user };
+    this._user = {
+      ...this._user,
+      ...partialUser,
+      // Merge attributes specifically
+      attributes: {
+        ...this._user.attributes,
+        ...partialUser.attributes
+      }
+    };
+
+    // Persist to sessionStorage
+    try {
+      sessionStorage.setItem(this.SESSION_STORAGE_KEY, JSON.stringify(this._user));
+    } catch (error) {
+      console.error('[DAP UserContext] Error persisting updated user:', error);
+    }
+
+    console.debug('[DAP UserContext] User updated:', this._user.id);
+    this.notifyListeners({ type: 'user-changed', user: this._user, previousUser });
+  }
+
+  /**
+   * Get current user context
+   */
+  public getUser(): DapUser | null {
+    return this._user ? { ...this._user } : null;
+  }
+
+  /**
+   * Clear user context (reverts to anonymous)
+   */
+  public clearUser(): void {
+    const previousUser = this._user;
+    this._user = null;
+
+    // Remove from sessionStorage
+    try {
+      sessionStorage.removeItem(this.SESSION_STORAGE_KEY);
+    } catch (error) {
+      console.error('[DAP UserContext] Error clearing user storage:', error);
+    }
+
+    console.debug('[DAP UserContext] User context cleared');
+    this.notifyListeners({ type: 'user-cleared', user: null, previousUser });
+  }
+
+  /**
+   * Check if real user context is available (not anonymous)
+   */
+  public hasRealUser(): boolean {
+    return this._user !== null;
+  }
+
+  /**
+   * Get analytics context for tracking
+   */
+  public getAnalyticsContext(): UserAnalyticsContext {
+    if (this._user) {
+      return {
+        userId: this._user.id,
+        role: this._user.role,
+        attributes: this._user.attributes,
+        isAnonymous: false
+      };
+    } else {
+      return {
+        userId: this._fallbackUserId || 'unknown',
+        isAnonymous: true
+      };
+    }
+  }
+
+  /**
+   * Get user property for rule evaluation
+   * Supports: user.id, user.role, user.email, user.attributes.*
+   */
+  public getUserProperty(propertyPath: string): string | null {
+    if (!propertyPath.startsWith('user.')) {
+      return null;
+    }
+
+    const path = propertyPath.substring(5); // Remove 'user.' prefix
+
+    // Handle anonymous user - only allow id
+    if (!this._user) {
+      if (path === 'id') {
+        return this._fallbackUserId;
+      }
+      console.debug(`[DAP UserContext] Property ${propertyPath} not available - no user context`);
+      return null;
+    }
+
+    // Handle direct properties
+    switch (path) {
+      case 'id':
+        return this._user.id;
+      case 'role':
+        return this._user.role || null;
+      case 'email':
+        return this._user.email || null;
+      default:
+        // Handle attributes
+        if (path.startsWith('attributes.')) {
+          const attributeKey = path.substring(11); // Remove 'attributes.' prefix
+          return this._user.attributes?.[attributeKey] || null;
+        }
+        console.warn(`[DAP UserContext] Unknown property path: ${propertyPath}`);
+        return null;
+    }
+  }
+
+  /**
+   * Subscribe to user context changes
+   */
+  public onUserChange(callback: (event: UserContextChangeEvent) => void): () => void {
+    this._eventListeners.push(callback);
+    
+    // Return unsubscribe function
+    return () => {
+      const index = this._eventListeners.indexOf(callback);
+      if (index > -1) {
+        this._eventListeners.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * Notify all listeners of user context changes
+   */
+  private notifyListeners(event: UserContextChangeEvent): void {
+    this._eventListeners.forEach(callback => {
+      try {
+        callback(event);
+      } catch (error) {
+        console.error('[DAP UserContext] Error in change listener:', error);
+      }
+    });
+  }
+
+  /**
+   * Debug method to get current state
+   */
+  public getDebugState(): any {
+    return {
+      hasUser: this.hasRealUser(),
+      userId: this._user?.id || this._fallbackUserId,
+      userRole: this._user?.role,
+      isAnonymous: !this.hasRealUser(),
+      attributeCount: Object.keys(this._user?.attributes || {}).length
+    };
+  }
+}
+
+// Export singleton instance
+export const userContextService = UserContextService.getInstance();