@zeniai/client-epic-state 5.0.12-beta2ND → 5.0.12-betaVR1

package/lib/entity/tenant/SessionManager.js

@@ -1,310 +0,0 @@
-"use strict";
-/**
- * SessionManager — Central session lifecycle manager.
- *
- * Responsibilities:
- * 1. Track user activity (mousemove, keydown, click, scroll, touch)
- * 2. Send heartbeat at configurable intervals — only when user has been active
- * 3. Show warning popup after idle timeout
- * 4. Auto-logout after warning countdown expires
- * 5. Sync activity across same-origin tabs via BroadcastChannel so one
- *    active tab keeps other tabs' sessions alive (no cascading logout).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionManager = void 0;
-const sessionTypes_1 = require("./sessionTypes");
-/** Events that indicate user activity. */
-const ACTIVITY_EVENTS = [
-    'mousemove',
-    'mousedown',
-    'keydown',
-    'scroll',
-    'touchstart',
-    'click',
-];
-/** Debounce interval for activity events (ms). */
-const ACTIVITY_DEBOUNCE_MS = 1000;
-/** Name of the BroadcastChannel used for cross-tab activity sync. */
-const BROADCAST_CHANNEL_NAME = 'zeni-session-activity';
-class SessionManager {
-    constructor() {
-        this.config = sessionTypes_1.DEFAULT_SESSION_CONFIG;
-        this.callbacks = null;
-        /** Timestamps and timers */
-        this.lastActivityTime = 0;
-        /** Timestamp of the last heartbeat fire (initial/periodic/continue/activity). */
-        this.lastHeartbeatTime = 0;
-        /** Set to true whenever user (or any same-origin tab) shows activity. */
-        this.hadActivitySinceLastHeartbeat = false;
-        this.idleCheckInterval = null;
-        this.heartbeatInterval = null;
-        this.countdownInterval = null;
-        this.activityDebounceTimer = null;
-        /** State */
-        this.running = false;
-        this.warningActive = false;
-        this.secondsRemaining = 0;
-        /** Wall-clock timestamp when the warning countdown began (for background-tab accuracy). */
-        this.warningStartTime = 0;
-        /** Cross-tab activity sync */
-        this.broadcastChannel = null;
-        /** Bound handlers for event listener cleanup. */
-        this.boundOnActivity = this.onActivity.bind(this);
-        this.boundOnVisibilityChange = this.onVisibilityChange.bind(this);
-        this.boundOnBroadcastMessage = this.onBroadcastMessage.bind(this);
-    }
-    // ─── Public API ────────────────────────────────────────────
-    start(config = {}, callbacks) {
-        if (this.running) {
-            this.stop();
-        }
-        this.config = { ...sessionTypes_1.DEFAULT_SESSION_CONFIG, ...config };
-        this.callbacks = callbacks;
-        this.running = true;
-        this.warningActive = false;
-        this.lastActivityTime = Date.now();
-        this.lastHeartbeatTime = 0; // fireHeartbeat('initial') below will set this
-        this.hadActivitySinceLastHeartbeat = true; // initial heartbeat is expected
-        console.log('[SessionManager] start() called with config:', this.config);
-        const heartbeatEnabled = this.config.heartbeatIntervalMinutes > 0;
-        const idleTrackingEnabled = this.config.isAutoLogoutEnabled;
-        if (!heartbeatEnabled && !idleTrackingEnabled) {
-            console.log('[SessionManager] Heartbeat and idle tracking both disabled — nothing to start');
-            return;
-        }
-        // Activity listeners — needed for both heartbeat activity-gate and idle
-        // detection. BroadcastChannel keeps multiple tabs in sync.
-        ACTIVITY_EVENTS.forEach((event) => {
-            document.addEventListener(event, this.boundOnActivity, {
-                capture: true,
-                passive: true,
-            });
-        });
-        this.setupBroadcastChannel();
-        if (heartbeatEnabled) {
-            this.startHeartbeat();
-            // Initial heartbeat on sign-in
-            this.fireHeartbeat('initial');
-        }
-        else {
-            console.log('[SessionManager] Heartbeat disabled (heartbeatIntervalMinutes <= 0)');
-        }
-        if (idleTrackingEnabled) {
-            document.addEventListener('visibilitychange', this.boundOnVisibilityChange);
-            this.idleCheckInterval = setInterval(() => this.checkIdle(), 1000);
-        }
-        else {
-            console.log('[SessionManager] Idle tracking disabled for this user — heartbeat-only mode');
-        }
-    }
-    stop() {
-        this.running = false;
-        this.warningActive = false;
-        ACTIVITY_EVENTS.forEach((event) => {
-            document.removeEventListener(event, this.boundOnActivity, {
-                capture: true,
-            });
-        });
-        document.removeEventListener('visibilitychange', this.boundOnVisibilityChange);
-        this.teardownBroadcastChannel();
-        this.clearTimer('idleCheckInterval');
-        this.clearTimer('heartbeatInterval');
-        this.clearTimer('countdownInterval');
-        this.clearTimer('activityDebounceTimer');
-    }
-    continueSession() {
-        if (!this.running) {
-            return;
-        }
-        this.warningActive = false;
-        this.secondsRemaining = 0;
-        this.lastActivityTime = Date.now();
-        this.hadActivitySinceLastHeartbeat = true;
-        this.clearTimer('countdownInterval');
-        // Fire heartbeat immediately — user explicitly extended the session
-        this.fireHeartbeat('continue-session');
-        this.callbacks?.onSessionExtended();
-        this.broadcast({ type: 'activity', timestamp: Date.now() });
-        this.startHeartbeat();
-    }
-    isWarningActive() {
-        return this.warningActive;
-    }
-    getSecondsRemaining() {
-        return this.secondsRemaining;
-    }
-    // ─── Private ───────────────────────────────────────────────
-    onActivity() {
-        if (!this.running || this.warningActive) {
-            return;
-        }
-        // Debounce: only update lastActivityTime at most once per second
-        if (this.activityDebounceTimer != null) {
-            return;
-        }
-        const now = Date.now();
-        this.registerActivity(now);
-        this.broadcast({ type: 'activity', timestamp: now });
-        // If heartbeat is enabled and the interval has elapsed since the last
-        // heartbeat, fire one immediately and restart the timer. This covers
-        // the "user active again after >interval idle" case without waiting
-        // for the next scheduled tick.
-        if (this.config.heartbeatIntervalMinutes > 0) {
-            const intervalMs = this.config.heartbeatIntervalMinutes * 60 * 1000;
-            const timeSinceLastHeartbeat = now - this.lastHeartbeatTime;
-            if (timeSinceLastHeartbeat >= intervalMs) {
-                this.fireHeartbeat('activity-after-idle');
-                this.startHeartbeat();
-            }
-        }
-        this.activityDebounceTimer = setTimeout(() => {
-            this.activityDebounceTimer = null;
-        }, ACTIVITY_DEBOUNCE_MS);
-    }
-    onVisibilityChange() {
-        if (!this.running) {
-            return;
-        }
-        if (document.visibilityState === 'visible') {
-            if (this.warningActive) {
-                // Tab was hidden while countdown was running — check if it already expired.
-                const elapsed = Math.floor((Date.now() - this.warningStartTime) / 1000);
-                if (elapsed >= this.config.warningDurationSeconds) {
-                    this.secondsRemaining = 0;
-                    this.clearTimer('countdownInterval');
-                    this.warningActive = false;
-                    this.callbacks?.onAutoLogout();
-                }
-                return;
-            }
-            // Industry-standard idle detection: resetting on tab focus is expected.
-            this.registerActivity(Date.now());
-            this.checkIdle();
-        }
-    }
-    /** Single source of truth for marking activity locally. */
-    registerActivity(timestamp) {
-        this.lastActivityTime = Math.max(this.lastActivityTime, timestamp);
-        this.hadActivitySinceLastHeartbeat = true;
-    }
-    checkIdle() {
-        if (!this.running || this.warningActive) {
-            return;
-        }
-        const idleMs = Date.now() - this.lastActivityTime;
-        const idleTimeoutMs = this.config.idleTimeoutMinutes * 60 * 1000;
-        if (idleMs >= idleTimeoutMs) {
-            this.startWarning();
-        }
-    }
-    startWarning() {
-        this.warningActive = true;
-        this.warningStartTime = Date.now();
-        this.secondsRemaining = this.config.warningDurationSeconds;
-        // Don't extend session while warning is showing.
-        this.clearTimer('heartbeatInterval');
-        this.callbacks?.onWarningStart(this.secondsRemaining);
-        // Use wall-clock elapsed time so countdown stays accurate in background tabs.
-        // Browsers throttle setInterval when the tab is hidden, but each tick
-        // recomputes from the real start time so no seconds are "lost".
-        this.countdownInterval = setInterval(() => {
-            const elapsed = Math.floor((Date.now() - this.warningStartTime) / 1000);
-            const remaining = this.config.warningDurationSeconds - elapsed;
-            if (remaining <= 0) {
-                this.secondsRemaining = 0;
-                this.clearTimer('countdownInterval');
-                this.warningActive = false;
-                this.callbacks?.onAutoLogout();
-            }
-            else {
-                this.secondsRemaining = remaining;
-                this.callbacks?.onWarningTick(this.secondsRemaining);
-            }
-        }, 1000);
-    }
-    startHeartbeat() {
-        this.clearTimer('heartbeatInterval');
-        const intervalMs = this.config.heartbeatIntervalMinutes * 60 * 1000;
-        console.log(`[SessionManager] Heartbeat timer set to fire every ${this.config.heartbeatIntervalMinutes} min (${intervalMs} ms)`);
-        this.heartbeatInterval = setInterval(() => {
-            if (!this.running || this.warningActive) {
-                console.log('[SessionManager] Heartbeat tick skipped — running:', this.running, 'warningActive:', this.warningActive);
-                return;
-            }
-            if (!this.hadActivitySinceLastHeartbeat) {
-                console.log('[SessionManager] Heartbeat tick skipped — no activity in this interval');
-                return;
-            }
-            this.fireHeartbeat('periodic');
-        }, intervalMs);
-    }
-    fireHeartbeat(reason) {
-        console.log(`[SessionManager] Heartbeat fired (${reason})`);
-        this.lastHeartbeatTime = Date.now();
-        this.hadActivitySinceLastHeartbeat = false;
-        this.callbacks?.onHeartbeat();
-        // Let other tabs know we just fired a heartbeat — they can skip theirs
-        // this cycle to avoid N tabs all firing heartbeats.
-        this.broadcast({ type: 'heartbeat-fired', timestamp: this.lastHeartbeatTime });
-    }
-    // ─── BroadcastChannel (cross-tab activity sync) ───────────
-    setupBroadcastChannel() {
-        if (typeof BroadcastChannel === 'undefined') {
-            console.log('[SessionManager] BroadcastChannel not available — cross-tab sync disabled');
-            return;
-        }
-        try {
-            this.broadcastChannel = new BroadcastChannel(BROADCAST_CHANNEL_NAME);
-            this.broadcastChannel.addEventListener('message', this.boundOnBroadcastMessage);
-            console.log('[SessionManager] BroadcastChannel ready for cross-tab sync');
-        }
-        catch (err) {
-            console.warn('[SessionManager] BroadcastChannel setup failed:', err);
-            this.broadcastChannel = null;
-        }
-    }
-    teardownBroadcastChannel() {
-        if (this.broadcastChannel == null) {
-            return;
-        }
-        this.broadcastChannel.removeEventListener('message', this.boundOnBroadcastMessage);
-        this.broadcastChannel.close();
-        this.broadcastChannel = null;
-    }
-    broadcast(message) {
-        this.broadcastChannel?.postMessage(message);
-    }
-    onBroadcastMessage(event) {
-        if (!this.running) {
-            return;
-        }
-        const msg = event.data;
-        if (msg == null) {
-            return;
-        }
-        if (msg.type === 'activity') {
-            // Another tab saw user activity — treat as activity here too.
-            this.registerActivity(msg.timestamp);
-        }
-        else if (msg.type === 'heartbeat-fired') {
-            // Another tab already fired a heartbeat in this interval — backend
-            // session is already extended. Reset our local tracking so we don't
-            // also fire one this cycle.
-            this.lastHeartbeatTime = Math.max(this.lastHeartbeatTime, msg.timestamp);
-            this.hadActivitySinceLastHeartbeat = false;
-        }
-    }
-    clearTimer(name) {
-        const timer = this[name];
-        if (timer != null) {
-            if (name === 'activityDebounceTimer') {
-                clearTimeout(timer);
-            }
-            else {
-                clearInterval(timer);
-            }
-            this[name] = null;
-        }
-    }
-}
-exports.SessionManager = SessionManager;

package/lib/entity/tenant/epic/sessionHeartbeatEpic.d.ts

@@ -1,16 +0,0 @@
-import { ActionsObservable, StateObservable } from 'redux-observable';
-import { RootState } from '../../../reducer';
-import { ZeniAPI } from '../../../zeniAPI';
-import { sendSessionHeartbeat, sessionHeartbeatFailure, sessionHeartbeatSuccess } from '../tenantReducer';
-export type ActionType = ReturnType<typeof sendSessionHeartbeat> | ReturnType<typeof sessionHeartbeatSuccess> | ReturnType<typeof sessionHeartbeatFailure>;
-export declare const sessionHeartbeatEpic: (actions$: ActionsObservable<ActionType>, _: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<{
-    payload: {
-        expiresAt: string;
-    };
-    type: "tenant/sessionHeartbeatSuccess";
-} | {
-    payload: {
-        error: import("../../../responsePayload").ZeniAPIStatus<Record<string, unknown>>;
-    };
-    type: "tenant/sessionHeartbeatFailure";
-}>;

package/lib/entity/tenant/epic/sessionHeartbeatEpic.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sessionHeartbeatEpic = void 0;
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const responsePayload_1 = require("../../../responsePayload");
-const tenantReducer_1 = require("../tenantReducer");
-const sessionHeartbeatEpic = (actions$, _, zeniAPI) => actions$.pipe((0, operators_1.filter)(tenantReducer_1.sendSessionHeartbeat.match), (0, operators_1.switchMap)(() => zeniAPI
-    .postAndGetJSON(`${zeniAPI.apiEndPoints.authMicroServiceBaseUrl}/1.0/heartbeat`)
-    .pipe((0, operators_1.mergeMap)((response) => {
-    if ((0, responsePayload_1.isSuccessResponse)(response)) {
-        return (0, rxjs_1.of)((0, tenantReducer_1.sessionHeartbeatSuccess)(response.data?.expiry ?? ''));
-    }
-    return (0, rxjs_1.of)((0, tenantReducer_1.sessionHeartbeatFailure)(response.status));
-}), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, tenantReducer_1.sessionHeartbeatFailure)((0, responsePayload_1.createZeniAPIStatus)('Heartbeat failed', 'Session heartbeat API call errored: ' + JSON.stringify(error))))))));
-exports.sessionHeartbeatEpic = sessionHeartbeatEpic;

package/lib/entity/tenant/sessionTypes.d.ts

@@ -1,26 +0,0 @@
-/**
- * Session management types for idle timeout and heartbeat.
- */
-export interface SessionConfig {
-    /** Minutes between heartbeat API calls while user is active. Default: 10 */
-    heartbeatIntervalMinutes: number;
-    /** Minutes of inactivity before the warning popup appears. Default: 30 */
-    idleTimeoutMinutes: number;
-    /** Whether auto-logout is enabled. Default: true */
-    isAutoLogoutEnabled: boolean;
-    /** Seconds to count down in the warning popup before auto-logout. Default: 60 */
-    warningDurationSeconds: number;
-}
-export declare const DEFAULT_SESSION_CONFIG: SessionConfig;
-export interface SessionCallbacks {
-    /** Called when the countdown reaches zero — app should sign out. */
-    onAutoLogout: () => void;
-    /** Called to send a heartbeat API request. */
-    onHeartbeat: () => void;
-    /** Called when the session is extended (heartbeat success or "Continue Session"). */
-    onSessionExtended: () => void;
-    /** Called when the warning countdown starts. */
-    onWarningStart: (secondsRemaining: number) => void;
-    /** Called every second during the countdown. */
-    onWarningTick: (secondsRemaining: number) => void;
-}

package/lib/entity/tenant/sessionTypes.js

@@ -1,12 +0,0 @@
-"use strict";
-/**
- * Session management types for idle timeout and heartbeat.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SESSION_CONFIG = void 0;
-exports.DEFAULT_SESSION_CONFIG = {
-    heartbeatIntervalMinutes: 10,
-    idleTimeoutMinutes: 30,
-    isAutoLogoutEnabled: true,
-    warningDurationSeconds: 60,
-};