@zeniai/client-epic-state 5.0.11 → 5.0.12-beta0ND

package/lib/esm/entity/tenant/SessionManager.js

@@ -0,0 +1,286 @@
+/**
+ * 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).
+ */
+import { DEFAULT_SESSION_CONFIG, } from './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';
+export class SessionManager {
+    constructor() {
+        this.config = 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;
+        /** 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 = { ...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;
+        }
+        // Industry-standard idle detection: resetting on tab focus is expected.
+        if (document.visibilityState === 'visible') {
+            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.secondsRemaining = this.config.warningDurationSeconds;
+        // Don't extend session while warning is showing.
+        this.clearTimer('heartbeatInterval');
+        this.callbacks?.onWarningStart(this.secondsRemaining);
+        this.countdownInterval = setInterval(() => {
+            this.secondsRemaining -= 1;
+            if (this.secondsRemaining <= 0) {
+                this.clearTimer('countdownInterval');
+                this.warningActive = false;
+                this.callbacks?.onAutoLogout();
+            }
+            else {
+                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;
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../responsePayload';
+import { sendSessionHeartbeat, sessionHeartbeatFailure, sessionHeartbeatSuccess, } from '../tenantReducer';
+export const sessionHeartbeatEpic = (actions$, _, zeniAPI) => actions$.pipe(filter(sendSessionHeartbeat.match), switchMap(() => zeniAPI
+    .postAndGetJSON(`${zeniAPI.apiEndPoints.authMicroServiceBaseUrl}/1.0/heartbeat`)
+    .pipe(mergeMap((response) => {
+    if (isSuccessResponse(response)) {
+        return of(sessionHeartbeatSuccess(response.data?.expiry ?? ''));
+    }
+    return of(sessionHeartbeatFailure(response.status));
+}), catchError((error) => of(sessionHeartbeatFailure(createZeniAPIStatus('Heartbeat failed', 'Session heartbeat API call errored: ' + JSON.stringify(error))))))));

package/lib/esm/entity/tenant/sessionTypes.js

@@ -0,0 +1,9 @@
+/**
+ * Session management types for idle timeout and heartbeat.
+ */
+export const DEFAULT_SESSION_CONFIG = {
+    heartbeatIntervalMinutes: 10,
+    idleTimeoutMinutes: 30,
+    isAutoLogoutEnabled: true,
+    warningDurationSeconds: 60,
+};

package/lib/esm/entity/tenant/tenantReducer.js

@@ -428,6 +428,26 @@ const tenant = createSlice({
         signOutSuccess(draft) {
             draft.loggedInUser = undefined;
             draft.currentTenantId = undefined;
+            draft.sessionExpiresAt = undefined;
+        },
+        sendSessionHeartbeat() {
+            // No state change needed — epic handles the API call
+        },
+        sessionHeartbeatSuccess: {
+            prepare(expiresAt) {
+                return { payload: { expiresAt } };
+            },
+            reducer(draft, action) {
+                draft.sessionExpiresAt = action.payload.expiresAt;
+            },
+        },
+        sessionHeartbeatFailure: {
+            prepare(error) {
+                return { payload: { error } };
+            },
+            reducer(draft, action) {
+                draft.error = action.payload.error;
+            },
         },
         fetchSubscriptionSummaryForTenant: {
             prepare(tenantId) {
@@ -535,7 +555,7 @@ const tenant = createSlice({
         },
     },
 });
-export const { updateTenants, fetchAllTenants, updateTenantsSuccess, updateTenantsFailure, fetchActiveTenant, updateTenantSuccess, updateTenantFailure, updateCurrentTenant, fetchExcludedResources, updateExcludedResourcesSuccess, updateExcludedResourcesFailure, doSignIn, doMagicLinkSignIn, magicLinkSignInSuccess, magicLinkSignInFailure, sendEmailMagicLinkToUser, sendEmailMagicLinkToUserSuccess, sendEmailMagicLinkToUserFailure, updateSignInState, doSignOut, signOutSuccess, updateLoggedInUser, fetchExternalConnections, saveExternalConnection, saveExternalConnectionSuccess, saveExternalConnectionFailure, fetchExternalConnectionsFailure, fetchExternalConnectionsSuccess, clearAll, fetchSubscriptionSummaryForTenant, updateSubscriptionSummaryForTenantSuccess, updateSubscriptionSummaryForTenantFailure, updateOnboardingTenants, removeOnboardingTenant, updateTenantReimbursementInfo, updateReferViewedForLoggedInUser, updateTreasuryVideoViewedForLoggedInUser, resetSignInState, trigger2FA, updateTenantAccountingClassesEnabled, updateTenantMasterTOSInfo, verifyDeviceWithTwoFA, verifyDeviceWithTwoFASuccess, verifyDeviceWithTwoFAFailure, resendVerifyDeviceOTP, resendVerifyDeviceOTPSuccess, resendVerifyDeviceOTPFailure, } = tenant.actions;
+export const { updateTenants, fetchAllTenants, updateTenantsSuccess, updateTenantsFailure, fetchActiveTenant, updateTenantSuccess, updateTenantFailure, updateCurrentTenant, fetchExcludedResources, updateExcludedResourcesSuccess, updateExcludedResourcesFailure, doSignIn, doMagicLinkSignIn, magicLinkSignInSuccess, magicLinkSignInFailure, sendEmailMagicLinkToUser, sendEmailMagicLinkToUserSuccess, sendEmailMagicLinkToUserFailure, updateSignInState, doSignOut, signOutSuccess, sendSessionHeartbeat, sessionHeartbeatSuccess, sessionHeartbeatFailure, updateLoggedInUser, fetchExternalConnections, saveExternalConnection, saveExternalConnectionSuccess, saveExternalConnectionFailure, fetchExternalConnectionsFailure, fetchExternalConnectionsSuccess, clearAll, fetchSubscriptionSummaryForTenant, updateSubscriptionSummaryForTenantSuccess, updateSubscriptionSummaryForTenantFailure, updateOnboardingTenants, removeOnboardingTenant, updateTenantReimbursementInfo, updateReferViewedForLoggedInUser, updateTreasuryVideoViewedForLoggedInUser, resetSignInState, trigger2FA, updateTenantAccountingClassesEnabled, updateTenantMasterTOSInfo, verifyDeviceWithTwoFA, verifyDeviceWithTwoFASuccess, verifyDeviceWithTwoFAFailure, resendVerifyDeviceOTP, resendVerifyDeviceOTPSuccess, resendVerifyDeviceOTPFailure, } = tenant.actions;
 export default tenant.reducer;
 /**
  * Converts tenants payload to Tenant and User State

package/lib/esm/index.js

@@ -59,7 +59,7 @@ import { closeSnackbar, openSnackbar } from './entity/snackbar/snackbarReducer';
 import { getSnackbar } from './entity/snackbar/snackbarSelector';
 import { toPriorityCodeType, toTaskStatusCodeType, } from './entity/task/taskState';
 import { getTaskGroupById } from './entity/taskGroup/taskGroupSelector';
-import { clearAll, doMagicLinkSignIn, doSignIn, doSignOut, fetchActiveTenant, fetchAllTenants, fetchExcludedResources as fetchExcludedResourcesForTenant, fetchExternalConnections as fetchExternalConnectionsForTenant, fetchSubscriptionSummaryForTenant, resendVerifyDeviceOTP, resetSignInState, saveExternalConnection as saveExternalConnectionForTenant, sendEmailMagicLinkToUser, updateCurrentTenant, updateSignInState, verifyDeviceWithTwoFA, } from './entity/tenant/tenantReducer';
+import { clearAll, doMagicLinkSignIn, doSignIn, doSignOut, sendSessionHeartbeat, fetchActiveTenant, fetchAllTenants, fetchExcludedResources as fetchExcludedResourcesForTenant, fetchExternalConnections as fetchExternalConnectionsForTenant, fetchSubscriptionSummaryForTenant, resendVerifyDeviceOTP, resetSignInState, saveExternalConnection as saveExternalConnectionForTenant, sendEmailMagicLinkToUser, updateCurrentTenant, updateSignInState, verifyDeviceWithTwoFA, } from './entity/tenant/tenantReducer';
 import { getCurrentTenant, getIsAccountingClassesEnabled, getIsAccountingProjectsEnabled, getTenantBaseById, getTenantBaseViewForTenantId, getTenantBaseViewForTenantView, getTenantsBaseByCheckInDateSelector, getTenantsByCheckInDateSelector, getTenantsCoreDetailsByCheckInDateSelector, isOtherProductsEnabledForTenant, isTenantBankingOnly, isTenantBookkeepingEnabled, isTenantCardsOnly, isTenantUsingZeniCOA, isZeniDomainTenant, toTenantCoreDetailsView, } from './entity/tenant/tenantSelector';
 import { pushToastNotification } from './entity/toastNotification/toastNotificationReducer';
 import { getLastNotificationTime, getNotifications, } from './entity/toastNotification/toastNotificationSelector';
@@ -433,7 +433,7 @@ export { toTimeframeTick, mapTimePeriodtoTimeframeTick, toTimePeriod, toAbsolute
 export { toVendorSpendTrendFilterTabsTypeStrict, } from './entity/vendorExpense/vendorExpenseSelector';
 export { getNumberOfPeriods };
 export { SCHEDULE_DAYS_OF_MONTH, toScheduleDaysOfMonth, toMonth, toMonthStrict, toQuarter, toQuarterStrict, };
-export { getTenantBaseById, getCurrentTenant, getIsAccountingClassesEnabled, getIsAccountingProjectsEnabled, getTenantsByCheckInDateSelector, getTenantsBaseByCheckInDateSelector, getTenantsCoreDetailsByCheckInDateSelector, toTenantCoreDetailsView, getTenantBaseViewForTenantView, getTenantBaseViewForTenantId, isZeniDomainTenant, isTenantUsingZeniCOA, fetchActiveTenant, fetchAllTenants, updateCurrentTenant, clearAll, doMagicLinkSignIn, verifyDeviceWithTwoFA, resendVerifyDeviceOTP, sendEmailMagicLinkToUser, doSignIn, updateSignInState, doSignOut, resetSignInState, fetchExcludedResourcesForTenant, fetchExternalConnectionsForTenant, saveExternalConnectionForTenant, fetchSubscriptionSummaryForTenant, isTenantBankingOnly, isTenantCardsOnly, isTenantBookkeepingEnabled, isOtherProductsEnabledForTenant, };
+export { getTenantBaseById, getCurrentTenant, getIsAccountingClassesEnabled, getIsAccountingProjectsEnabled, getTenantsByCheckInDateSelector, getTenantsBaseByCheckInDateSelector, getTenantsCoreDetailsByCheckInDateSelector, toTenantCoreDetailsView, getTenantBaseViewForTenantView, getTenantBaseViewForTenantId, isZeniDomainTenant, isTenantUsingZeniCOA, fetchActiveTenant, fetchAllTenants, updateCurrentTenant, clearAll, doMagicLinkSignIn, verifyDeviceWithTwoFA, resendVerifyDeviceOTP, sendEmailMagicLinkToUser, doSignIn, updateSignInState, doSignOut, sendSessionHeartbeat, resetSignInState, fetchExcludedResourcesForTenant, fetchExternalConnectionsForTenant, saveExternalConnectionForTenant, fetchSubscriptionSummaryForTenant, isTenantBankingOnly, isTenantCardsOnly, isTenantBookkeepingEnabled, isOtherProductsEnabledForTenant, };
 export { toAccountType, toAccountGroupType, getAccountGroupKey, };
 export { getClassById } from './entity/class/classSelector';
 export { getForecast };
@@ -631,3 +631,6 @@ export { getAutoTransferRules, getAutoTransferRuleById, getAutoTransferRuleHisto
 export { BULK_UPLOAD_AUTOMATCHING_TIMEOUT_MS, BULK_UPLOAD_BAR_COMPLETE_HOLD_MS, } from './view/expenseAutomationView/helpers/bulkUploadTiming';
 export { fetchTransactionActivityLog } from './view/transactionActivityLogView/transactionActivityLogViewReducer';
 export { getTransactionActivityLogView, } from './view/transactionActivityLogView/transactionActivityLogViewSelector';
+// ── Session Management ──────────────────────────────────────────────
+export { SessionManager } from './entity/tenant/SessionManager';
+export { DEFAULT_SESSION_CONFIG } from './entity/tenant/sessionTypes';

package/lib/esm/view/spendManagement/billPay/billDetailView/epics/fetchBillDetailEpic.js

@@ -53,7 +53,7 @@ export const fetchBillDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(
                 response.data?.transaction?.transaction_id != null) {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 const transcationId = response.data.transaction.transaction_id;
-                const vendorInResponse = response.data?.vendors[0];
+                const vendorInResponse = response.data?.vendors?.[0];
                 const flattenedContacts = vendorInResponse?.contacts ?? [];
                 const flattenedAddresses = getFlattenedAddress(response.data?.vendors ?? []);
                 const flattenedBankAccounts = vendorInResponse?.bank_accounts ?? [];
@@ -85,7 +85,7 @@ export const fetchBillDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(
                         ...response.data.bank_accounts,
                     ]),
                     updatePaymentInstruments(flattenedPaymentInstruments),
-                    updateVendors(response.data.vendors),
+                    updateVendors(response.data.vendors ?? []),
                     // end: save all vendor related entities
                 ];
                 if (vendorInResponse == null &&
@@ -94,15 +94,15 @@ export const fetchBillDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(
                     fetchActions.push(fetchVendorsList({
                         searchString: response.data?.transaction.candidate_vendor_name,
                     }));
-                    fetchActions.push(waitForVendorByNameThenUpdateBillDetail(billId, response.data, response.data.vendors[0]?.vendor_id));
+                    fetchActions.push(waitForVendorByNameThenUpdateBillDetail(billId, response.data, undefined));
                 }
                 else {
                     fetchActions.push(updateBillDetail({ billId, billDetail: response.data }));
-                    fetchActions.push(updateBillDetailFetchState(transcationId, 'Completed', undefined, response.data.vendors[0]?.vendor_id));
+                    fetchActions.push(updateBillDetailFetchState(transcationId, 'Completed', undefined, vendorInResponse?.vendor_id));
                     const transactionInResponse = response.data?.transaction;
                     if (transactionInResponse != null &&
                         transactionInResponse.total_amount != null &&
-                        Boolean(vendorInResponse) === true) {
+                        vendorInResponse != null) {
                         fetchActions.push(fetchDuplicateBill(vendorInResponse.vendor_name, vendorInResponse.vendor_id, transactionInResponse.total_amount, transactionInResponse.recipient_total_amount, transactionInResponse.document_id, billId));
                     }
                     const billHasPaymentError = [

package/lib/index.d.ts

@@ -123,7 +123,7 @@ import { PriorityCodeType, Task, TaskCodeType, TaskPriority, TaskStatus, TaskSta
 import { getTaskGroupById } from './entity/taskGroup/taskGroupSelector';
 import { TaskGroupState } from './entity/taskGroup/taskGroupState';
 import { TaskGroupTemplate } from './entity/taskGroupTemplate/taskGroupTemplateState';
-import { DoSignInPayload, clearAll, doMagicLinkSignIn, doSignIn, doSignOut, fetchActiveTenant, fetchAllTenants, fetchExcludedResources as fetchExcludedResourcesForTenant, fetchExternalConnections as fetchExternalConnectionsForTenant, fetchSubscriptionSummaryForTenant, resendVerifyDeviceOTP, resetSignInState, saveExternalConnection as saveExternalConnectionForTenant, sendEmailMagicLinkToUser, updateCurrentTenant, updateSignInState, verifyDeviceWithTwoFA } from './entity/tenant/tenantReducer';
+import { DoSignInPayload, clearAll, doMagicLinkSignIn, doSignIn, doSignOut, sendSessionHeartbeat, fetchActiveTenant, fetchAllTenants, fetchExcludedResources as fetchExcludedResourcesForTenant, fetchExternalConnections as fetchExternalConnectionsForTenant, fetchSubscriptionSummaryForTenant, resendVerifyDeviceOTP, resetSignInState, saveExternalConnection as saveExternalConnectionForTenant, sendEmailMagicLinkToUser, updateCurrentTenant, updateSignInState, verifyDeviceWithTwoFA } from './entity/tenant/tenantReducer';
 import { CurrentTenant, TenantBaseView, TenantCoreDetailsView, TenantView, TenantsBaseOrdered, TenantsOrdered, getCurrentTenant, getIsAccountingClassesEnabled, getIsAccountingProjectsEnabled, getTenantBaseById, getTenantBaseViewForTenantId, getTenantBaseViewForTenantView, getTenantsBaseByCheckInDateSelector, getTenantsByCheckInDateSelector, getTenantsCoreDetailsByCheckInDateSelector, isOtherProductsEnabledForTenant, isTenantBankingOnly, isTenantBookkeepingEnabled, isTenantCardsOnly, isTenantUsingZeniCOA, isZeniDomainTenant, toTenantCoreDetailsView } from './entity/tenant/tenantSelector';
 import { Connection, LoggedInUser, RoleResource, Tenant, TenantProductSettings } from './entity/tenant/tenantState';
 import { ToastNotificationPayload } from './entity/toastNotification/toastNotificationPayload';
@@ -643,7 +643,7 @@ export { TimeframeTick, TimeframeTickWithMetaData, toTimeframeTick, mapTimePerio
 export { VendorSpendTrendFilterTabType, toVendorSpendTrendFilterTabsTypeStrict, } from './entity/vendorExpense/vendorExpenseSelector';
 export { getNumberOfPeriods };
 export { SCHEDULE_DAYS_OF_MONTH, ScheduleDaysOfMonth, toScheduleDaysOfMonth, Day, Month, toMonth, toMonthStrict, Quarter, toQuarter, toQuarterStrict, AbsoluteDay, TimePeriod, };
-export { Tenant, TenantView, LoggedInUser, TenantBaseView, CurrentTenant, TenantProductSettings, getTenantBaseById, getCurrentTenant, getIsAccountingClassesEnabled, getIsAccountingProjectsEnabled, getTenantsByCheckInDateSelector, getTenantsBaseByCheckInDateSelector, getTenantsCoreDetailsByCheckInDateSelector, toTenantCoreDetailsView, getTenantBaseViewForTenantView, getTenantBaseViewForTenantId, isZeniDomainTenant, isTenantUsingZeniCOA, TenantsBaseOrdered, TenantsOrdered, TenantCoreDetailsView, fetchActiveTenant, fetchAllTenants, updateCurrentTenant, clearAll, doMagicLinkSignIn, verifyDeviceWithTwoFA, resendVerifyDeviceOTP, sendEmailMagicLinkToUser, doSignIn, updateSignInState, DoSignInPayload, doSignOut, resetSignInState, RoleResource, Connection, fetchExcludedResourcesForTenant, fetchExternalConnectionsForTenant, saveExternalConnectionForTenant, fetchSubscriptionSummaryForTenant, isTenantBankingOnly, isTenantCardsOnly, isTenantBookkeepingEnabled, isOtherProductsEnabledForTenant, };
+export { Tenant, TenantView, LoggedInUser, TenantBaseView, CurrentTenant, TenantProductSettings, getTenantBaseById, getCurrentTenant, getIsAccountingClassesEnabled, getIsAccountingProjectsEnabled, getTenantsByCheckInDateSelector, getTenantsBaseByCheckInDateSelector, getTenantsCoreDetailsByCheckInDateSelector, toTenantCoreDetailsView, getTenantBaseViewForTenantView, getTenantBaseViewForTenantId, isZeniDomainTenant, isTenantUsingZeniCOA, TenantsBaseOrdered, TenantsOrdered, TenantCoreDetailsView, fetchActiveTenant, fetchAllTenants, updateCurrentTenant, clearAll, doMagicLinkSignIn, verifyDeviceWithTwoFA, resendVerifyDeviceOTP, sendEmailMagicLinkToUser, doSignIn, updateSignInState, DoSignInPayload, doSignOut, sendSessionHeartbeat, resetSignInState, RoleResource, Connection, fetchExcludedResourcesForTenant, fetchExternalConnectionsForTenant, saveExternalConnectionForTenant, fetchSubscriptionSummaryForTenant, isTenantBankingOnly, isTenantCardsOnly, isTenantBookkeepingEnabled, isOtherProductsEnabledForTenant, };
 export { Account, AccountType, AccountBase, StatementCloseDay, toAccountType, AccountReport, NestedAccountReport, AccountWithBalanceReport, AccountGroup, AccountGroupReportV2, AccountGroupType, toAccountGroupType, AccountGroupReport, getAccountGroupKey, AccountGroupKey, RecommendedAccountBase, };
 export { Class, ClassBase, RecommendedClassBase, } from './entity/class/classState';
 export { getClassById } from './entity/class/classSelector';
@@ -901,3 +901,6 @@ export { BULK_UPLOAD_AUTOMATCHING_TIMEOUT_MS, BULK_UPLOAD_BAR_COMPLETE_HOLD_MS,
 export { fetchTransactionActivityLog } from './view/transactionActivityLogView/transactionActivityLogViewReducer';
 export { TransactionActivityLogViewSelectorView, getTransactionActivityLogView, } from './view/transactionActivityLogView/transactionActivityLogViewSelector';
 export { UserGroup } from './entity/userGroups/userGroupsState';
+export { SessionManager } from './entity/tenant/SessionManager';
+export type { SessionCallbacks, SessionConfig } from './entity/tenant/sessionTypes';
+export { DEFAULT_SESSION_CONFIG } from './entity/tenant/sessionTypes';