@jmruthers/pace-core 0.5.67 → 0.5.69

package/src/services/InactivityService.ts

@@ -0,0 +1,388 @@
+/**
+ * @file Inactivity Service
+ * @package @jmruthers/pace-core
+ * @module Services
+ * @since 0.1.0
+ *
+ * Inactivity service implementation.
+ * Handles inactivity tracking, auto-logout, and warning modals.
+ */
+
+import { BaseService } from './base/BaseService';
+import { IInactivityService } from './interfaces/IInactivityService';
+
+export class InactivityService extends BaseService implements IInactivityService {
+  private _showInactivityWarning = false;
+  private _inactivityTimeRemaining = 0;
+  private _isIdle = false;
+  private _timeRemaining = 0;
+  private _showWarning = false;
+  private _isTracking = false;
+
+  // Dependencies
+  private supabaseClient: any = null;
+  private user: any = null;
+  private session: any = null;
+  private idleTimeoutMs = 30 * 60 * 1000; // 30 minutes
+  private warnBeforeMs = 60 * 1000; // 60 seconds
+  private onIdleLogout: ((reason: 'inactivity') => void) | null = null;
+
+  // Internal state management
+  private inactivityTracker: any = null;
+  private isInactivityEnabled = true;
+
+  constructor(
+    supabaseClient: any,
+    user: any,
+    session: any,
+    idleTimeoutMs: number = 30 * 60 * 1000,
+    warnBeforeMs: number = 60 * 1000,
+    onIdleLogout: (reason: 'inactivity') => void
+  ) {
+    super();
+    this.supabaseClient = supabaseClient;
+    this.user = user;
+    this.session = session;
+    this.idleTimeoutMs = idleTimeoutMs;
+    this.warnBeforeMs = warnBeforeMs;
+    this.onIdleLogout = onIdleLogout;
+    
+    // Initialize time remaining to idle timeout
+    this._timeRemaining = idleTimeoutMs;
+  }
+
+  // Interface implementation
+  isIdle(): boolean { return this._isIdle; }
+  getTimeRemaining(): number { return this._timeRemaining; }
+  isWarningShown(): boolean { return this._showWarning; }
+  isTracking(): boolean { return this._isTracking; }
+  getShowInactivityWarning(): boolean { return this._showInactivityWarning; }
+  getInactivityTimeRemaining(): number { return this._inactivityTimeRemaining; }
+
+  // Additional getter methods that tests expect
+  getIsIdle(): boolean { return this._isIdle; }
+  getIsTracking(): boolean { return this._isTracking; }
+  getShowWarning(): boolean { return this._showWarning; }
+
+  // Additional methods for testing
+  setShowInactivityWarning(value: boolean): void {
+    this._showInactivityWarning = value;
+    this.notify();
+  }
+
+  setInactivityTimeRemaining(value: number): void {
+    this._inactivityTimeRemaining = value;
+    this.notify();
+  }
+
+  setIsIdle(value: boolean): void {
+    this._isIdle = value;
+    this.notify();
+  }
+
+  setTimeRemaining(value: number): void {
+    this._timeRemaining = value;
+    this.notify();
+  }
+
+  setShowWarning(value: boolean): void {
+    this._showWarning = value;
+    this.notify();
+  }
+
+  setIsTracking(value: boolean): void {
+    this._isTracking = value;
+    this.notify();
+  }
+
+  triggerWarning(timeRemaining: number): void {
+    this._showInactivityWarning = true;
+    this._inactivityTimeRemaining = Math.ceil(timeRemaining / 1000);
+    this._showWarning = true;
+    this.notify();
+  }
+
+  triggerIdle(): void {
+    this._isIdle = true;
+    this.handleIdleLogout();
+    this.notify();
+  }
+
+  // Update dependencies
+  updateDependencies(
+    supabaseClient: any,
+    user: any,
+    session: any,
+    idleTimeoutMs?: number,
+    warnBeforeMs?: number,
+    onIdleLogout?: (reason: 'inactivity') => void
+  ): void {
+    this.supabaseClient = supabaseClient;
+    this.user = user;
+    this.session = session;
+    if (idleTimeoutMs !== undefined) this.idleTimeoutMs = idleTimeoutMs;
+    if (warnBeforeMs !== undefined) this.warnBeforeMs = warnBeforeMs;
+    if (onIdleLogout !== undefined) this.onIdleLogout = onIdleLogout;
+    this.notify();
+  }
+
+  // Inactivity methods
+  resetActivity(): void {
+    if (this.inactivityTracker) {
+      this.inactivityTracker.resetActivity();
+    }
+    this._isIdle = false;
+    this._showWarning = false;
+    this._showInactivityWarning = false;
+    this._inactivityTimeRemaining = 0;
+    this._timeRemaining = this.idleTimeoutMs;
+    this.notify();
+  }
+
+  startTracking(): void {
+    if (this.inactivityTracker) {
+      this.inactivityTracker.startTracking();
+    }
+    this._isTracking = true;
+    this.notify();
+  }
+
+  stopTracking(): void {
+    if (this.inactivityTracker) {
+      this.inactivityTracker.stopTracking();
+    }
+    this._isTracking = false;
+    this.notify();
+  }
+
+  async handleIdleLogout(): Promise<void> {
+    // Hide warning
+    this._showInactivityWarning = false;
+    this._inactivityTimeRemaining = 0;
+    
+    // Stop tracking
+    this.stopTracking();
+    
+    // Sign out via Supabase
+    try {
+      if (this.supabaseClient) {
+        await this.supabaseClient.auth.signOut();
+      }
+    } catch (error: any) {
+      console.error('[InactivityService] Error during idle logout:', error);
+    }
+    
+    // Call app callback for navigation/redirect
+    this.onIdleLogout?.('inactivity');
+    this.notify();
+  }
+
+  handleStaySignedIn(): void {
+    this._showInactivityWarning = false;
+    this._inactivityTimeRemaining = 0;
+    this.resetActivity();
+    this.notify();
+  }
+
+  async handleSignOutNow(): Promise<void> {
+    this._showInactivityWarning = false;
+    this._inactivityTimeRemaining = 0;
+    this.stopTracking();
+    
+    // Sign out via Supabase
+    try {
+      if (this.supabaseClient) {
+        await this.supabaseClient.auth.signOut();
+      }
+    } catch (error: any) {
+      console.error('[InactivityService] Error during manual sign out:', error);
+    }
+    
+    // Call app callback for navigation/redirect
+    this.onIdleLogout?.('inactivity');
+    this.notify();
+  }
+
+  // Lifecycle methods
+  async initialize(): Promise<void> {
+    await super.initialize();
+    await this.setupInactivityTracker();
+  }
+
+  cleanup(): void {
+    if (this.inactivityTracker) {
+      this.inactivityTracker.cleanup?.();
+      this.inactivityTracker = null;
+    }
+    this._isTracking = false;
+    this._isIdle = false;
+    this._showWarning = false;
+    this._showInactivityWarning = false;
+    this._timeRemaining = 0;
+    this._inactivityTimeRemaining = 0;
+    super.cleanup();
+  }
+
+  protected async doInitialize(): Promise<void> {
+    // Production safety check for inactivity feature
+    if (typeof window !== 'undefined') {
+      const isProduction = import.meta.env.MODE === 'production';
+      
+      if (isProduction) {
+        console.warn('[InactivityService] Inactivity feature enabled in production');
+      }
+    }
+  }
+
+  protected doCleanup(): void {
+    // Cleanup any resources
+  }
+
+  private async setupInactivityTracker(): Promise<void> {
+    if (typeof window === 'undefined') return;
+
+    // Check if inactivity is enabled
+    this.isInactivityEnabled = this.user && this.session;
+
+    if (!this.isInactivityEnabled) {
+      return;
+    }
+
+    try {
+      // Dynamically import the inactivity tracker hook
+      const { useInactivityTracker } = await import('../hooks/useInactivityTracker');
+      
+      // Create a mock implementation since we can't use hooks in services
+      // In a real implementation, you'd need to create a non-hook version
+      this.inactivityTracker = {
+        isIdle: false,
+        timeRemaining: 0,
+        showWarning: false,
+        isTracking: false,
+        resetActivity: () => {
+          this._isIdle = false;
+          this._timeRemaining = 0;
+          this._showWarning = false;
+          this.notify();
+        },
+        startTracking: () => {
+          this._isTracking = true;
+          this.notify();
+        },
+        stopTracking: () => {
+          this._isTracking = false;
+          this.notify();
+        },
+        cleanup: () => {
+          this._isTracking = false;
+          this._isIdle = false;
+          this._showWarning = false;
+          this._timeRemaining = 0;
+        }
+      };
+
+      // Set up event handlers
+      this.setupEventHandlers();
+    } catch (error) {
+      console.error('[InactivityService] Failed to setup inactivity tracker:', error);
+    }
+  }
+
+  private setupEventHandlers(): void {
+    if (typeof window === 'undefined') return;
+
+    let idleTimer: NodeJS.Timeout | null = null;
+    let warningTimer: NodeJS.Timeout | null = null;
+    let lastActivity = Date.now();
+
+    const resetTimers = () => {
+      lastActivity = Date.now();
+      
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+      
+      if (warningTimer) {
+        clearTimeout(warningTimer);
+        warningTimer = null;
+      }
+
+      this._showInactivityWarning = false;
+      this._inactivityTimeRemaining = 0;
+      this._isIdle = false;
+      this._showWarning = false;
+      this.notify();
+    };
+
+    const startIdleTimer = () => {
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+      }
+
+      idleTimer = setTimeout(() => {
+        this._isIdle = true;
+        this._showWarning = true;
+        this.notify();
+        
+        // Start warning timer
+        warningTimer = setTimeout(() => {
+          this.handleIdleLogout();
+        }, this.warnBeforeMs);
+      }, this.idleTimeoutMs - this.warnBeforeMs);
+    };
+
+    const startWarningTimer = () => {
+      if (warningTimer) {
+        clearTimeout(warningTimer);
+      }
+
+      warningTimer = setTimeout(() => {
+        this.handleIdleLogout();
+      }, this.warnBeforeMs);
+    };
+
+    // Activity detection
+    const activityEvents = ['mousedown', 'mousemove', 'keypress', 'scroll', 'touchstart', 'click'];
+    
+    const handleActivity = () => {
+      resetTimers();
+      startIdleTimer();
+    };
+
+    // Add event listeners
+    activityEvents.forEach(event => {
+      document.addEventListener(event, handleActivity, true);
+    });
+
+    // Start initial timer
+    startIdleTimer();
+
+    // Store cleanup function
+    this.inactivityTracker.cleanup = () => {
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+      
+      if (warningTimer) {
+        clearTimeout(warningTimer);
+        warningTimer = null;
+      }
+
+      activityEvents.forEach(event => {
+        document.removeEventListener(event, handleActivity, true);
+      });
+
+      this._isTracking = false;
+      this._isIdle = false;
+      this._showWarning = false;
+      this._timeRemaining = 0;
+      this._showInactivityWarning = false;
+      this._inactivityTimeRemaining = 0;
+    };
+
+    this._isTracking = true;
+    this.notify();
+  }
+}