@zeniai/client-epic-state 5.1.18-betaDI1 → 5.1.18-betaDI10

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

@@ -0,0 +1,1127 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { fromBase64 } from 'js-base64';
+import assignWith from 'lodash/assignWith';
+import { toURL } from '../../commonPayloadTypes/urlPayload';
+import { stringToUnion } from '../../commonStateTypes/stringToUnion';
+import { toMonthYearPeriod } from '../../commonStateTypes/timePeriod';
+import { toAccountingMethod } from '../../view/netBurnOrIncomeStoryCard/netBurnOrIncomeStoryCardSelectorTypes';
+import { toNumberOfMonthForAverage, toTimeSpanIdForAverage, } from '../../view/netBurnOrIncomeStoryCard/netBurnOrIncomeStoryCardState';
+import { date, dateNow } from '../../zeniDayJS';
+import { toSubscriptionSummary } from '../subscription/subscriptionSummary/subscriptionSummaryReducer';
+import { getInvitationStatus, getUserRoles, toMasterTOSInfo, toUserReimbursementInfo, } from '../userRole/userRolePayload';
+const EXTERNAL_INTEGRATION_TYPES = ['revenue', 'payments', 'email'];
+export const toExternalIntegrationType = (v) => stringToUnion(v, EXTERNAL_INTEGRATION_TYPES);
+const EXTERNAL_SUPPORTED_TOOLS = [
+    'chargebee',
+    'hubspot',
+    'stripe',
+    'mercury',
+    'paypal',
+    'gmail',
+    'outlook',
+];
+export const toExternalSupportedTool = (v) => stringToUnion(v, EXTERNAL_SUPPORTED_TOOLS);
+export const initialState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    accountLocked: false,
+    tenantsById: {},
+    onboardingTenantsById: {},
+    tenantIds: [],
+    signInState: 'Not-Started',
+    loggedInUser: undefined,
+    currentTenantId: undefined,
+    excludedResourcesByTenant: {},
+    externalConnectionsByTenant: {},
+    subscriptionSummaryByTenant: {},
+    activeTenantFetchState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    sendEmailMagicLinkFetchState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    magicLinkSignInFetchState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    verifyDeviceFetchState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    resendVerifyDeviceOTPFetchState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    magicLinkEmail: undefined,
+    magicLinkCodeVerifier: undefined,
+    otpChallenge: undefined,
+    twoFAPhoneNumber: undefined,
+    accountLockTime: undefined,
+    accountUnlockTime: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed' && this.tenantIds.length > 0;
+    },
+};
+const tenant = createSlice({
+    name: 'tenant',
+    initialState,
+    reducers: {
+        updateTenants: {
+            prepare(tenants, userTenantPayload, tenantUpdated = false) {
+                return { payload: { tenants, userTenantPayload, tenantUpdated } };
+            },
+            reducer(draft, action) {
+                action.payload.tenants.forEach((tenantPayload) => {
+                    const tenantInStore = draft.tenantsById[tenantPayload.tenant_id];
+                    const newTenant = mapTenantPayloadToTenant(tenantPayload, action.payload.userTenantPayload);
+                    if (tenantInStore == null ||
+                        (newTenant != null && action.payload.tenantUpdated)) {
+                        // Note: If tenant data already exists, save it if the new data is the latest one.
+                        // we dont want to overwrite the user related data since that has not come in the output
+                        const merged = applyTreasuryPromoUserFieldsFromPayload(tenantInStore, {
+                            ...newTenant,
+                            rewardsLastViewedTime: tenantInStore?.rewardsLastViewedTime,
+                        }, action.payload.userTenantPayload ?? {
+                            rewards_feature_last_viewed_time: null,
+                        });
+                        draft.tenantsById[tenantPayload.tenant_id] = {
+                            ...merged,
+                            capitalizableAccountOverrides: merged.capitalizableAccountOverrides ??
+                                tenantInStore?.capitalizableAccountOverrides ??
+                                null,
+                            capitalizationOnboardingDismissedAccounts: merged.capitalizationOnboardingDismissedAccounts ??
+                                tenantInStore?.capitalizationOnboardingDismissedAccounts ??
+                                null,
+                        };
+                    }
+                });
+            },
+        },
+        updateOnboardingTenants: {
+            prepare(tenants, tenantUpdated = false) {
+                return { payload: { tenants, tenantUpdated } };
+            },
+            reducer(draft, action) {
+                action.payload.tenants.forEach((tenantPayload) => {
+                    const tenantInStore = draft.onboardingTenantsById[tenantPayload.tenant_id];
+                    const newTenant = mapTenantPayloadToTenant(tenantPayload);
+                    if (tenantInStore == null ||
+                        (newTenant != null && action.payload.tenantUpdated)) {
+                        // Note: If tenant data already exists, save it if the new data is the latest one.
+                        // we dont want to overwrite the user related data since that has not come in the output
+                        draft.onboardingTenantsById[tenantPayload.tenant_id] = newTenant;
+                    }
+                });
+            },
+        },
+        updateTenantsSuccess(draft, action) {
+            const { tenants, user } = action.payload;
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+            const [tenantsbyId, tenantIds, firstUser] = mapTenantsPayloadToState(tenants, user);
+            tenantIds.forEach((tenantId) => {
+                const existingTenant = draft.tenantsById[tenantId];
+                tenantsbyId[tenantId] = applyTreasuryPromoUserFieldsFromPayload(existingTenant, tenantsbyId[tenantId], user);
+                if (existingTenant != null) {
+                    tenantsbyId[tenantId].capitalizableAccountOverrides =
+                        tenantsbyId[tenantId].capitalizableAccountOverrides ??
+                            existingTenant.capitalizableAccountOverrides;
+                    tenantsbyId[tenantId].capitalizationOnboardingDismissedAccounts =
+                        tenantsbyId[tenantId].capitalizationOnboardingDismissedAccounts ??
+                            existingTenant.capitalizationOnboardingDismissedAccounts;
+                }
+            });
+            draft.tenantsById = tenantsbyId;
+            draft.tenantIds = tenantIds;
+            draft.loggedInUser = assignWith(draft.loggedInUser ?? {}, firstUser, (objValue, srcValue) => srcValue ?? objValue);
+        },
+        updateTenantsFailure(draft, action) {
+            draft.fetchState = 'Error';
+            draft.signInState = 'Error';
+            draft.error = action.payload;
+            draft.tenantIds = [];
+            draft.tenantsById = {};
+        },
+        updateTenantSuccess(draft, action) {
+            const { tenants, user } = action.payload;
+            draft.activeTenantFetchState.fetchState = 'Completed';
+            draft.activeTenantFetchState.error = undefined;
+            const [tenantsbyId, tenantIds, firstUser] = mapTenantsPayloadToState(tenants, user);
+            tenantIds.forEach((tenantId) => {
+                const existingTenant = draft.tenantsById[tenantId];
+                if (existingTenant != null) {
+                    tenantsbyId[tenantId].capitalizableAccountOverrides =
+                        tenantsbyId[tenantId].capitalizableAccountOverrides ??
+                            existingTenant.capitalizableAccountOverrides;
+                    tenantsbyId[tenantId].capitalizationOnboardingDismissedAccounts =
+                        tenantsbyId[tenantId].capitalizationOnboardingDismissedAccounts ??
+                            existingTenant.capitalizationOnboardingDismissedAccounts;
+                }
+            });
+            draft.tenantsById = { ...draft.tenantsById, ...tenantsbyId };
+            draft.tenantIds = [...new Set([...draft.tenantIds, ...tenantIds])];
+            draft.loggedInUser = assignWith(draft.loggedInUser ?? {}, firstUser, (objValue, srcValue) => srcValue ?? objValue);
+        },
+        updateTenantAccountingClassesEnabled(draft, action) {
+            const { tenantId, enabled } = action.payload;
+            if (draft.tenantsById[tenantId] != null) {
+                draft.tenantsById[tenantId].isAccountingClassesEnabled = enabled;
+            }
+        },
+        // Optimistic per-key merge: assumes the backend PATCH merges
+        // capitalizable_account_overrides by key rather than replacing the whole field.
+        updateTenantCapitalizationAccountOverride(draft, action) {
+            const { tenantId, accountId, threshold, allOverrides } = action.payload;
+            if (draft.tenantsById[tenantId] != null) {
+                if (allOverrides !== undefined) {
+                    draft.tenantsById[tenantId].capitalizableAccountOverrides =
+                        allOverrides != null && Object.keys(allOverrides).length > 0
+                            ? allOverrides
+                            : null;
+                }
+                else {
+                    const currentOverrides = draft.tenantsById[tenantId].capitalizableAccountOverrides ?? {};
+                    if (threshold === null) {
+                        delete currentOverrides[accountId];
+                    }
+                    else {
+                        currentOverrides[accountId] = threshold;
+                    }
+                    draft.tenantsById[tenantId].capitalizableAccountOverrides =
+                        Object.keys(currentOverrides).length > 0 ? currentOverrides : null;
+                }
+            }
+        },
+        updateTenantCapitalizationOnboardingDismissed(draft, action) {
+            const { tenantId, accountId } = action.payload;
+            if (draft.tenantsById[tenantId] != null) {
+                const existing = draft.tenantsById[tenantId]
+                    .capitalizationOnboardingDismissedAccounts ?? {};
+                existing[accountId] = true;
+                draft.tenantsById[tenantId].capitalizationOnboardingDismissedAccounts =
+                    existing;
+            }
+        },
+        updateTenantMasterTOSInfo(draft, action) {
+            const { tenant_id, user_role_id, master_tos_info } = action.payload;
+            if (draft.tenantsById[tenant_id] != null &&
+                user_role_id != null &&
+                master_tos_info != null) {
+                draft.tenantsById[tenant_id].masterTOSInfo =
+                    toMasterTOSInfo(master_tos_info);
+            }
+        },
+        updateTenantFailure(draft, action) {
+            draft.activeTenantFetchState.fetchState = 'Error';
+            draft.activeTenantFetchState.error = action.payload;
+            draft.signInState = 'Error';
+            draft.tenantIds = [];
+            draft.tenantsById = {};
+        },
+        updateTenantReimbursementInfo(draft, action) {
+            const { tenant_id, reimbursement_info } = action.payload;
+            if (draft.tenantsById[tenant_id] != null && reimbursement_info != null) {
+                draft.tenantsById[tenant_id].userReimbursementInfo =
+                    toUserReimbursementInfo(reimbursement_info);
+            }
+        },
+        fetchAllTenants: {
+            prepare(userId, zeniSessionId) {
+                return { payload: { userId, zeniSessionId } };
+            },
+            reducer(draft) {
+                draft.fetchState = 'In-Progress';
+                draft.error = undefined;
+            },
+        },
+        fetchActiveTenant: {
+            prepare(userId, tenantId, zeniSessionId) {
+                return { payload: { userId, tenantId, zeniSessionId } };
+            },
+            reducer(draft) {
+                draft.activeTenantFetchState.fetchState = 'In-Progress';
+                draft.activeTenantFetchState.error = undefined;
+            },
+        },
+        updateCurrentTenant(draft, action) {
+            draft.currentTenantId = action.payload;
+        },
+        fetchExcludedResources: {
+            prepare(userId, tenantId) {
+                return { payload: { userId, tenantId } };
+            },
+            reducer(draft, action) {
+                draft.excludedResourcesByTenant[action.payload.tenantId] = {
+                    fetchState: 'In-Progress',
+                    resources: [],
+                    error: undefined,
+                };
+            },
+        },
+        updateExcludedResourcesSuccess: {
+            prepare(tenantId, excludedResources) {
+                return { payload: { tenantId, excludedResources } };
+            },
+            reducer(draft, action) {
+                draft.excludedResourcesByTenant[action.payload.tenantId] = {
+                    fetchState: 'Completed',
+                    resources: action.payload.excludedResources.map((payload) => toRoleResource(payload)),
+                    error: undefined,
+                };
+            },
+        },
+        updateExcludedResourcesFailure: {
+            prepare(tenantId, status) {
+                return { payload: { tenantId, status } };
+            },
+            reducer(draft, action) {
+                const { tenantId, status } = action.payload;
+                draft.excludedResourcesByTenant[tenantId] = {
+                    fetchState: 'Error',
+                    resources: [],
+                    error: status,
+                };
+            },
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        doSignIn(draft, _) {
+            draft.fetchState = 'In-Progress';
+            draft.signInState = 'In-Progress';
+            draft.error = undefined;
+        },
+        sendEmailMagicLinkToUser: {
+            prepare(email, deviceId) {
+                return { payload: { email, deviceId } };
+            },
+            reducer(draft, action) {
+                draft.sendEmailMagicLinkFetchState.fetchState = 'In-Progress';
+                draft.sendEmailMagicLinkFetchState.error = undefined;
+                draft.magicLinkEmail = action.payload.email;
+            },
+        },
+        sendEmailMagicLinkToUserSuccess: {
+            prepare(codeVerifier) {
+                return { payload: { codeVerifier } };
+            },
+            reducer(draft, action) {
+                const { codeVerifier } = action.payload;
+                draft.sendEmailMagicLinkFetchState.fetchState = 'Completed';
+                draft.sendEmailMagicLinkFetchState.error = undefined;
+                draft.magicLinkCodeVerifier = codeVerifier;
+            },
+        },
+        // accept account lock time and unlock time in the payload in sendEmailMagicLinkToUserFailure function
+        sendEmailMagicLinkToUserFailure(draft, action) {
+            const { error, accountLockTime, accountUnlockTime, isAccountLocked } = action.payload;
+            draft.sendEmailMagicLinkFetchState.fetchState = 'Error';
+            draft.sendEmailMagicLinkFetchState.error = error;
+            draft.accountLockTime =
+                accountLockTime != null ? date(accountLockTime) : undefined;
+            draft.accountUnlockTime =
+                accountUnlockTime != null ? date(accountUnlockTime) : undefined;
+            draft.accountLocked = isAccountLocked ?? false;
+        },
+        doMagicLinkSignIn: {
+            prepare(token, deviceId, magicLinkCodeVerifier) {
+                return {
+                    payload: { token, deviceId, magicLinkCodeVerifier },
+                };
+            },
+            reducer(draft) {
+                draft.magicLinkSignInFetchState.fetchState = 'In-Progress';
+                draft.magicLinkSignInFetchState.error = undefined;
+                draft.signInState = 'In-Progress';
+            },
+        },
+        magicLinkSignInSuccess: {
+            prepare(userId, sessionId) {
+                return { payload: { userId, sessionId } };
+            },
+            reducer(draft, action) {
+                const { userId, sessionId } = action.payload;
+                draft.fetchState = 'In-Progress'; // Why in progress ? Sign in is complete only after tenants are retrieved successfully.
+                draft.error = undefined;
+                draft.magicLinkSignInFetchState.fetchState = 'Completed';
+                draft.magicLinkSignInFetchState.error = undefined;
+                draft.loggedInUser = assignWith(draft.loggedInUser ?? {}, {
+                    userId: userId,
+                    zeniSessionId: sessionId,
+                }, (objValue, srcValue) => srcValue ?? objValue);
+            },
+        },
+        magicLinkSignInFailure(draft, action) {
+            draft.magicLinkSignInFetchState.fetchState = 'Error';
+            draft.magicLinkSignInFetchState.error = action.payload;
+            draft.signInState = 'Error';
+        },
+        resendVerifyDeviceOTP: {
+            prepare(deviceId, magicLinkEmail, otpChallenge) {
+                return { payload: { deviceId, magicLinkEmail, otpChallenge } };
+            },
+            reducer(draft) {
+                draft.resendVerifyDeviceOTPFetchState.fetchState = 'In-Progress';
+                draft.resendVerifyDeviceOTPFetchState.error = undefined;
+            },
+        },
+        resendVerifyDeviceOTPSuccess: {
+            prepare(otpChallenge, userEmail, twoFAPhoneNumber) {
+                return { payload: { otpChallenge, userEmail, twoFAPhoneNumber } };
+            },
+            reducer(draft, action) {
+                const { otpChallenge, userEmail, twoFAPhoneNumber } = action.payload;
+                draft.resendVerifyDeviceOTPFetchState.fetchState = 'Completed';
+                draft.resendVerifyDeviceOTPFetchState.error = undefined;
+                draft.otpChallenge = otpChallenge;
+                draft.twoFAPhoneNumber = twoFAPhoneNumber;
+                draft.magicLinkEmail = userEmail;
+            },
+        },
+        resendVerifyDeviceOTPFailure(draft, action) {
+            draft.resendVerifyDeviceOTPFetchState.fetchState = 'Error';
+            draft.resendVerifyDeviceOTPFetchState.error = action.payload;
+        },
+        updateSignInState(draft, action) {
+            draft.signInState = action.payload;
+        },
+        updateLoggedInUser: {
+            prepare(userPayload, zeniSessionId, authProvider) {
+                return { payload: { userPayload, zeniSessionId, authProvider } };
+            },
+            reducer(draft, action) {
+                draft.fetchState = 'In-Progress'; // Why in progress ? Sign in is complete only after tenants are retrieved successfully.
+                draft.error = undefined;
+                const user = mapLoggedInUserPayloadToLoggedInUser(action.payload.userPayload, action.payload.zeniSessionId, action.payload.authProvider);
+                draft.loggedInUser = assignWith(draft.loggedInUser ?? {}, user, (objValue, srcValue) => srcValue ?? objValue);
+            },
+        },
+        fetchExternalConnections: {
+            prepare(userId, tenantId) {
+                return { payload: { userId, tenantId } };
+            },
+            reducer(draft, action) {
+                draft.externalConnectionsByTenant[action.payload.tenantId] = {
+                    fetchState: 'In-Progress',
+                    accounting: [],
+                    email: [],
+                    payments: [],
+                    revenue: [],
+                    saveConnectionState: 'Not-Started',
+                    saveAPIKeyConnectionState: 'Not-Started',
+                    saveConnectorCredentialsStateBySlug: {},
+                    saveConnectorCredentialsErrorBySlug: {},
+                    saveOAuthConnectionState: 'Not-Started',
+                    deleteConnectionState: 'Not-Started',
+                    error: undefined,
+                };
+            },
+        },
+        fetchExternalConnectionsSuccess: {
+            prepare(tenantId, externalConnections) {
+                return { payload: { tenantId, externalConnections } };
+            },
+            reducer(draft, action) {
+                const { accounting, email, payments, revenue } = mapConnectionsPayloadToState(action.payload.externalConnections);
+                draft.externalConnectionsByTenant[action.payload.tenantId] = {
+                    fetchState: 'Completed',
+                    accounting,
+                    email,
+                    payments,
+                    revenue,
+                    saveConnectionState: 'Completed',
+                    saveAPIKeyConnectionState: 'Not-Started',
+                    saveConnectorCredentialsStateBySlug: {},
+                    saveConnectorCredentialsErrorBySlug: {},
+                    saveOAuthConnectionState: 'Not-Started',
+                    deleteConnectionState: 'Not-Started',
+                    error: undefined,
+                };
+            },
+        },
+        fetchExternalConnectionsFailure: {
+            prepare(tenantId, status) {
+                return { payload: { tenantId, status } };
+            },
+            reducer(draft, action) {
+                const { tenantId, status } = action.payload;
+                draft.externalConnectionsByTenant[tenantId] = {
+                    fetchState: 'Error',
+                    accounting: [],
+                    email: [],
+                    payments: [],
+                    revenue: [],
+                    saveConnectionState: 'Error',
+                    saveAPIKeyConnectionState: 'Not-Started',
+                    saveConnectorCredentialsStateBySlug: {},
+                    saveConnectorCredentialsErrorBySlug: {},
+                    saveOAuthConnectionState: 'Not-Started',
+                    deleteConnectionState: 'Not-Started',
+                    error: status,
+                };
+            },
+        },
+        saveExternalConnection: {
+            prepare(tenantId, connectionMeta, redirectUri, companyId, userId) {
+                return {
+                    payload: { tenantId, connectionMeta, redirectUri, companyId, userId },
+                };
+            },
+            reducer(draft, action) {
+                if (draft.externalConnectionsByTenant[action.payload.tenantId] != null) {
+                    draft.externalConnectionsByTenant[action.payload.tenantId] =
+                        Object.assign({}, draft.externalConnectionsByTenant[action.payload.tenantId], { saveConnectionState: 'In-Progress' });
+                }
+            },
+        },
+        saveExternalConnectionSuccess: {
+            prepare(tenantId, connectionPayload) {
+                return { payload: { tenantId, connectionPayload } };
+            },
+            reducer(draft, action) {
+                draft.externalConnectionsByTenant[action.payload.tenantId] =
+                    Object.assign({}, draft.externalConnectionsByTenant[action.payload.tenantId], {
+                        fetchState: 'Completed',
+                        accounting: [toConnection(action.payload.connectionPayload)],
+                        saveConnectionState: 'Completed',
+                        error: undefined,
+                    });
+            },
+        },
+        saveExternalConnectionFailure: {
+            prepare(tenantId, status) {
+                return { payload: { tenantId, status } };
+            },
+            reducer(draft, action) {
+                const { tenantId, status } = action.payload;
+                draft.externalConnectionsByTenant[tenantId] = Object.assign({}, draft.externalConnectionsByTenant[tenantId], {
+                    fetchState: 'Error',
+                    accounting: [],
+                    saveConnectionState: 'Error',
+                    error: status,
+                });
+            },
+        },
+        saveAPIKeyConnection: {
+            prepare(tenantId, connectionId, connectionType, connectionName, credentials) {
+                return {
+                    payload: {
+                        tenantId,
+                        connectionId,
+                        connectionType,
+                        connectionName,
+                        credentials,
+                    },
+                };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.saveAPIKeyConnectionState = 'In-Progress';
+                    existing.saveAPIKeyConnectionError = undefined;
+                }
+            },
+        },
+        saveAPIKeyConnectionSuccess: {
+            prepare(tenantId, connectionType, connectionPayload) {
+                return { payload: { tenantId, connectionType, connectionPayload } };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.saveAPIKeyConnectionState = 'Completed';
+                    // Upsert by connection_name — replacing the whole array would wipe
+                    // sibling connectors in the same bucket (e.g. saving ChargeBee under
+                    // 'revenue' must not drop the HubSpot row that lives there too).
+                    // Lazily initialize the bucket if a save lands before
+                    // fetchExternalConnections{,Success} hydrated it (or after a
+                    // rehydration with a stale shape).
+                    if (existing[action.payload.connectionType] == null) {
+                        existing[action.payload.connectionType] = [];
+                    }
+                    replaceOrAppendConnectionByName(existing[action.payload.connectionType], toConnection(action.payload.connectionPayload));
+                    existing.saveAPIKeyConnectionError = undefined;
+                }
+            },
+        },
+        saveAPIKeyConnectionFailure: {
+            prepare(tenantId, status) {
+                return { payload: { tenantId, status } };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.saveAPIKeyConnectionState = 'Error';
+                    existing.saveAPIKeyConnectionError = action.payload.status;
+                }
+            },
+        },
+        saveOAuthConnection: {
+            prepare(tenantId, connectionId, connectionType, connectionName, credentials) {
+                return {
+                    payload: {
+                        tenantId,
+                        connectionId,
+                        connectionType,
+                        connectionName,
+                        credentials,
+                    },
+                };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.saveOAuthConnectionState = 'In-Progress';
+                    existing.saveOAuthConnectionError = undefined;
+                }
+            },
+        },
+        saveOAuthConnectionSuccess: {
+            prepare(tenantId, connectionType, connectionPayload) {
+                return { payload: { tenantId, connectionType, connectionPayload } };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.saveOAuthConnectionState = 'Completed';
+                    // See saveAPIKeyConnectionSuccess — upsert, do not replace, and
+                    // lazy-init the bucket in case it isn't hydrated yet.
+                    if (existing[action.payload.connectionType] == null) {
+                        existing[action.payload.connectionType] = [];
+                    }
+                    replaceOrAppendConnectionByName(existing[action.payload.connectionType], toConnection(action.payload.connectionPayload));
+                    existing.saveOAuthConnectionError = undefined;
+                }
+            },
+        },
+        saveOAuthConnectionFailure: {
+            prepare(tenantId, status) {
+                return { payload: { tenantId, status } };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.saveOAuthConnectionState = 'Error';
+                    existing.saveOAuthConnectionError = action.payload.status;
+                }
+            },
+        },
+        // saveConnectorCredentials — generic save action backing the new
+        // POST /1.0/connectors/<slug>/credentials endpoint. Used by Phase 1
+        // connectors (Stripe + Mercury api_key, PayPal client_credentials).
+        // ChargeBee + HubSpot continue using the legacy saveAPIKeyConnection /
+        // saveOAuthConnection actions that POST to /1.0/connections/<id>.
+        saveConnectorCredentials: {
+            prepare(tenantId, connectionType, args) {
+                return {
+                    payload: { tenantId, connectionType, ...args },
+                };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.saveConnectorCredentialsStateBySlug[action.payload.connectionName] = 'In-Progress';
+                    delete existing.saveConnectorCredentialsErrorBySlug[action.payload.connectionName];
+                }
+            },
+        },
+        saveConnectorCredentialsSuccess: {
+            prepare(tenantId, connectionType, connectionName, connectionPayload) {
+                return {
+                    payload: {
+                        tenantId,
+                        connectionType,
+                        connectionName,
+                        connectionPayload,
+                    },
+                };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.saveConnectorCredentialsStateBySlug[action.payload.connectionName] = 'Completed';
+                    // Upsert by connection_name — see saveAPIKeyConnectionSuccess for
+                    // the rationale on lazy bucket init + replace-or-append.
+                    if (existing[action.payload.connectionType] == null) {
+                        existing[action.payload.connectionType] = [];
+                    }
+                    replaceOrAppendConnectionByName(existing[action.payload.connectionType], toConnection(action.payload.connectionPayload));
+                    delete existing.saveConnectorCredentialsErrorBySlug[action.payload.connectionName];
+                }
+            },
+        },
+        saveConnectorCredentialsFailure: {
+            prepare(tenantId, connectionName, status) {
+                return { payload: { tenantId, connectionName, status } };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.saveConnectorCredentialsStateBySlug[action.payload.connectionName] = 'Error';
+                    existing.saveConnectorCredentialsErrorBySlug[action.payload.connectionName] = action.payload.status;
+                }
+            },
+        },
+        // Email-connect (Gmail / Outlook) OAuth init. Distinct from the other
+        // connector saves because the FE never sees the access_token — the
+        // user-facing redirect lands on the auth service's callback, auth
+        // exchanges code → tokens and posts them to tenant, then redirects the
+        // browser back to ``redirectAfterUrl`` with ``?email_connect_result=...``.
+        // The success action carries the provider's authorization_url so the
+        // epic can drive a full-page redirect, mirroring the legacy HubSpot
+        // flow in zeni-web-app-ui/IntegrationsScreen.
+        initEmailConnectOAuth: {
+            prepare(tenantId, provider, redirectAfterUrl) {
+                return { payload: { tenantId, provider, redirectAfterUrl } };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    // Reuse the per-slug saveConnectorCredentialsStateBySlug bucket so
+                    // the IntegrationsSettingsPage shows the same loading affordance
+                    // it already uses for Stripe/Mercury/PayPal connect flows.
+                    existing.saveConnectorCredentialsStateBySlug[action.payload.provider] = 'In-Progress';
+                    delete existing.saveConnectorCredentialsErrorBySlug[action.payload.provider];
+                }
+            },
+        },
+        initEmailConnectOAuthSuccess: {
+            prepare(tenantId, provider, authorizationUrl) {
+                return { payload: { tenantId, provider, authorizationUrl } };
+            },
+            reducer(draft, action) {
+                // Intentionally leave state as 'In-Progress' — the epic is about to
+                // do a full-page redirect, so any UI state we set here would be
+                // overwritten by the navigation anyway. Setting Completed would
+                // briefly flash a success state before the redirect, which reads
+                // wrong because the connection isn't actually saved yet at this
+                // point (it lands after the OAuth round-trip).
+                void draft;
+                void action;
+            },
+        },
+        initEmailConnectOAuthFailure: {
+            prepare(tenantId, provider, status) {
+                return { payload: { tenantId, provider, status } };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.saveConnectorCredentialsStateBySlug[action.payload.provider] = 'Error';
+                    existing.saveConnectorCredentialsErrorBySlug[action.payload.provider] = action.payload.status;
+                }
+            },
+        },
+        deleteConnection: {
+            prepare(tenantId, connectionId, connectionType) {
+                return { payload: { tenantId, connectionId, connectionType } };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.deleteConnectionState = 'In-Progress';
+                    existing.deleteConnectionError = undefined;
+                }
+            },
+        },
+        deleteConnectionSuccess: {
+            prepare(tenantId, connectionId, connectionType) {
+                return { payload: { tenantId, connectionId, connectionType } };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.deleteConnectionState = 'Completed';
+                    existing.deleteConnectionError = undefined;
+                    const arr = existing[action.payload.connectionType];
+                    const idx = arr.findIndex((c) => c.connectionId === action.payload.connectionId);
+                    if (idx !== -1) {
+                        arr[idx] = { ...arr[idx], isValid: false };
+                    }
+                }
+            },
+        },
+        deleteConnectionFailure: {
+            prepare(tenantId, status) {
+                return { payload: { tenantId, status } };
+            },
+            reducer(draft, action) {
+                const existing = draft.externalConnectionsByTenant[action.payload.tenantId];
+                if (existing != null) {
+                    existing.deleteConnectionState = 'Error';
+                    existing.deleteConnectionError = action.payload.status;
+                }
+            },
+        },
+        doSignOut(draft) {
+            draft.fetchState = 'Not-Started';
+            draft.signInState = 'Not-Started';
+            draft.error = undefined;
+        },
+        resetSignInState(draft) {
+            draft.fetchState = 'Not-Started';
+            draft.signInState = 'Not-Started';
+            draft.sendEmailMagicLinkFetchState.fetchState = 'Not-Started';
+            draft.sendEmailMagicLinkFetchState.error = undefined;
+            draft.magicLinkSignInFetchState.fetchState = 'Not-Started';
+            draft.magicLinkSignInFetchState.error = undefined;
+            draft.accountLocked = false;
+            draft.accountLockTime = undefined;
+            draft.accountUnlockTime = undefined;
+            draft.error = undefined;
+        },
+        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) {
+                return { payload: { tenantId } };
+            },
+            reducer(draft, action) {
+                draft.subscriptionSummaryByTenant[action.payload.tenantId] = {
+                    fetchState: 'In-Progress',
+                    summary: undefined,
+                };
+            },
+        },
+        updateSubscriptionSummaryForTenantSuccess: {
+            prepare(tenantId, subscriptionSummary) {
+                return { payload: { tenantId, subscriptionSummary } };
+            },
+            reducer(draft, action) {
+                draft.subscriptionSummaryByTenant[action.payload.tenantId] = {
+                    fetchState: 'Completed',
+                    summary: toSubscriptionSummary(action.payload.subscriptionSummary),
+                };
+            },
+        },
+        updateSubscriptionSummaryForTenantFailure: {
+            prepare(tenantId, status) {
+                return { payload: { tenantId, status } };
+            },
+            reducer(draft, action) {
+                draft.subscriptionSummaryByTenant[action.payload.tenantId] = {
+                    fetchState: 'Error',
+                    summary: undefined,
+                };
+            },
+        },
+        removeOnboardingTenant(draft, action) {
+            delete draft.onboardingTenantsById[action.payload];
+        },
+        updateReferViewedForLoggedInUser(draft) {
+            if (draft.currentTenantId != null) {
+                draft.tenantsById[draft.currentTenantId].rewardsLastViewedTime =
+                    dateNow();
+            }
+        },
+        updateTreasuryVideoViewedForLoggedInUser(draft) {
+            if (draft.currentTenantId != null) {
+                draft.tenantsById[draft.currentTenantId].isTreasuryPromoVideoPlayed =
+                    true;
+            }
+        },
+        updateTreasuryPromoRemindMeLaterClickedForLoggedInUser(draft) {
+            if (draft.currentTenantId != null) {
+                draft.tenantsById[draft.currentTenantId].isTreasuryPromoVideoRemindMeLaterClicked = true;
+            }
+        },
+        updateTreasuryPromoIntroClosedByOutsideClickForLoggedInUser(draft) {
+            if (draft.currentTenantId != null) {
+                draft.tenantsById[draft.currentTenantId].isTreasuryPromoIntroClosedByOutsideClick = true;
+            }
+        },
+        trigger2FA: {
+            prepare(otpChallenge, userEmail, twoFAPhoneNumber) {
+                return { payload: { otpChallenge, userEmail, twoFAPhoneNumber } };
+            },
+            reducer(draft, action) {
+                const { otpChallenge, userEmail, twoFAPhoneNumber } = action.payload;
+                draft.magicLinkEmail = userEmail;
+                draft.otpChallenge = otpChallenge;
+                draft.twoFAPhoneNumber = twoFAPhoneNumber;
+                draft.magicLinkSignInFetchState.fetchState = 'Completed';
+                draft.magicLinkSignInFetchState.error = undefined;
+            },
+        },
+        verifyDeviceWithTwoFA: {
+            prepare(otp, deviceId, userEmail, otpChallenge) {
+                return { payload: { otp, deviceId, userEmail, otpChallenge } };
+            },
+            reducer(draft) {
+                draft.verifyDeviceFetchState.fetchState = 'In-Progress';
+                draft.verifyDeviceFetchState.error = undefined;
+                draft.signInState = 'In-Progress';
+            },
+        },
+        verifyDeviceWithTwoFASuccess: {
+            prepare(userId, sessionId) {
+                return { payload: { userId, sessionId } };
+            },
+            reducer(draft, action) {
+                const { userId, sessionId } = action.payload;
+                draft.fetchState = 'In-Progress'; // Why in progress ? Sign in is complete only after tenants are retrieved successfully.
+                draft.error = undefined;
+                draft.verifyDeviceFetchState.fetchState = 'Completed';
+                draft.verifyDeviceFetchState.error = undefined;
+                draft.otpChallenge = undefined;
+                draft.twoFAPhoneNumber = undefined;
+                draft.magicLinkEmail = undefined;
+                draft.loggedInUser = assignWith(draft.loggedInUser ?? {}, {
+                    userId: userId,
+                    zeniSessionId: sessionId,
+                }, (objValue, srcValue) => srcValue ?? objValue);
+            },
+        },
+        verifyDeviceWithTwoFAFailure(draft, action) {
+            draft.verifyDeviceFetchState.fetchState = 'Error';
+            draft.verifyDeviceFetchState.error = action.payload;
+            draft.signInState = 'Error';
+        },
+        clearAll: {
+            prepare(keepTenantCompanyState = true) {
+                return { payload: { keepTenantCompanyState } };
+            },
+            reducer(draft, action) {
+                if (!action.payload.keepTenantCompanyState) {
+                    Object.assign(draft, initialState);
+                }
+            },
+        },
+    },
+});
+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, saveAPIKeyConnection, saveAPIKeyConnectionSuccess, saveAPIKeyConnectionFailure, saveOAuthConnection, saveOAuthConnectionSuccess, saveOAuthConnectionFailure, saveConnectorCredentials, saveConnectorCredentialsSuccess, saveConnectorCredentialsFailure, initEmailConnectOAuth, initEmailConnectOAuthSuccess, initEmailConnectOAuthFailure, deleteConnection, deleteConnectionSuccess, deleteConnectionFailure, clearAll, fetchSubscriptionSummaryForTenant, updateSubscriptionSummaryForTenantSuccess, updateSubscriptionSummaryForTenantFailure, updateOnboardingTenants, removeOnboardingTenant, updateTenantReimbursementInfo, updateReferViewedForLoggedInUser, resetSignInState, trigger2FA, updateTenantAccountingClassesEnabled, updateTenantCapitalizationOnboardingDismissed, updateTenantCapitalizationAccountOverride, updateTenantMasterTOSInfo, verifyDeviceWithTwoFA, verifyDeviceWithTwoFASuccess, verifyDeviceWithTwoFAFailure, updateTreasuryVideoViewedForLoggedInUser, updateTreasuryPromoRemindMeLaterClickedForLoggedInUser, updateTreasuryPromoIntroClosedByOutsideClickForLoggedInUser, resendVerifyDeviceOTP, resendVerifyDeviceOTPSuccess, resendVerifyDeviceOTPFailure, } = tenant.actions;
+export default tenant.reducer;
+/**
+ * Applies treasury promo user fields from the tenants API user block when present.
+ * When a field is omitted from the payload, keeps the existing tenant value so a
+ * later fetch-all-tenants call does not reset values already loaded by fetch-active-tenant.
+ */
+function applyTreasuryPromoUserFieldsFromPayload(existingTenant, mappedTenant, userTenantPayload) {
+    if (existingTenant == null) {
+        return mappedTenant;
+    }
+    return {
+        ...mappedTenant,
+        isTreasuryPromoVideoPlayed: userTenantPayload.is_treasury_promo_video_played ??
+            existingTenant.isTreasuryPromoVideoPlayed,
+        isTreasuryPromoVideoRemindMeLaterClicked: userTenantPayload.is_treasury_promo_video_remind_me_later_clicked ??
+            existingTenant.isTreasuryPromoVideoRemindMeLaterClicked,
+        loginCounterForTreasuryPromoVideo: userTenantPayload.login_counter_for_treasury_promo_video ??
+            existingTenant.loginCounterForTreasuryPromoVideo,
+        isTreasuryPromoIntroClosedByOutsideClick: userTenantPayload.is_treasury_promo_intro_closed_by_outside_click ??
+            existingTenant.isTreasuryPromoIntroClosedByOutsideClick,
+    };
+}
+/**
+ * Converts tenants payload to Tenant and User State
+ * @param payload tenants payload as received from backend API response
+ * @returns returns tuple [tenantsById: Record<tenantId, Tenant>, tenantIds: ID{}, firstUser: LoggedInUser]
+ */
+function mapTenantsPayloadToState(tenantsPayload, userTenantPayload) {
+    if (tenantsPayload.length == 0) {
+        throw new Error('Empty list of tenants ? ');
+    }
+    const tenantsById = {};
+    const tenantIds = [];
+    tenantsPayload.forEach((tenantsPayload) => {
+        const tenant = mapTenantPayloadToTenant(tenantsPayload, userTenantPayload);
+        tenantsById[tenant.tenantId] = tenant;
+        tenantIds.push(tenant.tenantId);
+    });
+    const firstUser = mapTenantPayloadToUser(tenantsPayload[0]);
+    return [tenantsById, tenantIds, firstUser];
+}
+function mapTenantPayloadToTenant(payload, userTenantPayload) {
+    const tenant = {
+        accountingClassIDs: payload.accounting_class_ids,
+        isAccountingClassesEnabled: payload.is_accounting_classes_enabled ?? true,
+        isAccountingProjectsEnabled: payload.is_accounting_projects_enabled ?? false,
+        bookCloseDate: payload.book_close_date != null
+            ? date(payload.book_close_date)
+            : undefined,
+        tenantId: payload.tenant_id,
+        companyId: payload.company_id,
+        companyName: payload.company_name,
+        createTime: date(payload.create_time),
+        inviteAcceptTime: date(payload.invite_accept_time),
+        inviteCreateTime: date(payload.invite_create_time),
+        inviterEmail: payload.inviter_email,
+        inviterUserId: payload.inviter_id,
+        userRole: getUserRoles(payload),
+        userRoleId: payload.user_role_id,
+        isZeni: payload.is_zeni,
+        invitationStatus: getInvitationStatus(payload),
+        tenantEmailDomain: payload.tenant_email_domain,
+        updateTime: date(payload.update_time),
+        productSettings: {
+            isBankingEnabled: payload.is_banking_enabled,
+            isTreasuryEnabled: payload.is_treasury_enabled,
+            isSpendManagementEnabled: payload.is_spend_management_enabled,
+            isBookkeepingEnabled: payload.is_book_keeping_enabled,
+            isOtherProductsEnabled: payload.is_other_products_enabled,
+            isCardsEnabled: payload.is_card_enabled,
+            isPayrollEnabled: payload.is_payroll_enabled,
+            isCfoEnabled: payload.is_cfo_enabled,
+            isTaxEnabled: payload.is_tax_enabled,
+        },
+        userLastCheckInTime: payload.user_last_check_in_time_into_tenant != null
+            ? date(payload.user_last_check_in_time_into_tenant)
+            : date('1970-01-01'), // if the user_last_check_in_time_into_tenant is null consider the last check-in time as start of unix epoch.
+        netBurnSettings: {
+            accountingMethod: toAccountingMethod(payload.accounting_method_for_avg_net_burn),
+            numberOfMonthsForAverage: toNumberOfMonthForAverage(payload.no_completed_months_used_for_avg_net_burn),
+            timeSpanIdForAverage: toTimeSpanIdForAverage(payload.time_span_id_for_avg_net_burn),
+        },
+        chargebeeId: payload.chargebee_customer_id,
+        hubSpotId: payload.hubspot_id ?? undefined,
+        isOnboardingCompleted: true,
+        qboRealmId: payload.qbo_realm_id,
+        isCustomerCreated: payload.is_customer_created,
+        isEmailGroupCreated: payload.is_email_group_created,
+        userReimbursementInfo: payload.reimbursement_info != null
+            ? toUserReimbursementInfo(payload.reimbursement_info)
+            : undefined,
+        masterTOSInfo: payload.master_tos_info != null
+            ? toMasterTOSInfo(payload.master_tos_info)
+            : undefined,
+        rewardsLastViewedTime: userTenantPayload?.rewards_feature_last_viewed_time != null
+            ? date(userTenantPayload.rewards_feature_last_viewed_time)
+            : undefined,
+        isTreasuryPromoVideoPlayed: userTenantPayload?.is_treasury_promo_video_played ?? false,
+        isTreasuryPromoVideoRemindMeLaterClicked: userTenantPayload?.is_treasury_promo_video_remind_me_later_clicked ??
+            false,
+        loginCounterForTreasuryPromoVideo: userTenantPayload?.login_counter_for_treasury_promo_video ?? 0,
+        isTreasuryPromoIntroClosedByOutsideClick: userTenantPayload?.is_treasury_promo_intro_closed_by_outside_click ??
+            false,
+        zeniBookCloseDate: payload.zeni_book_close_date != null
+            ? date(payload.zeni_book_close_date)
+            : undefined,
+        zeniBookCloseMonthAndYear: payload.zeni_book_close_month_and_year != null
+            ? toMonthYearPeriod(payload.zeni_book_close_month_and_year)
+            : undefined,
+        capitalizableAccountOverrides: payload.capitalizable_account_overrides ?? null,
+        capitalizableAccounts: payload.capitalizable_accounts != null
+            ? mapCapitalizableAccountsPayload(payload.capitalizable_accounts)
+            : null,
+        capitalizationOnboardingDismissedAccounts: payload.capitalization_onboarding_dismissed_accounts ?? null,
+        capitalizationOnboardingShownForPrepaid: payload.capitalization_onboarding_shown_for_prepaid ?? false,
+        capitalizationOnboardingShownForFixedAsset: payload.capitalization_onboarding_shown_for_fixed_asset ?? false,
+    };
+    return tenant;
+}
+// Exported for unit testing — the snake→camel + date() transform here is the
+// only place the wire format is reshaped, and Nikunj called out we need
+// coverage for the populated + null-accounts cases on this mapper specifically.
+export function mapCapitalizableAccountsPayload(payload) {
+    return {
+        computedAt: date(payload.computed_at),
+        // Defensive `?? []` because the API has historically been generous with
+        // `null` on nested fields; without this an `{accounts: null}` response
+        // throws on `.map`.
+        accounts: (payload.accounts ?? []).map((acc) => ({
+            accountId: acc.account_id,
+            classificationType: acc.classification_type,
+            matchPattern: acc.match_pattern,
+            thresholdValue: acc.threshold_value,
+            thresholdSource: acc.threshold_source,
+            sampleCount: acc.sample_count,
+        })),
+    };
+}
+function mapTenantPayloadToUser(payload) {
+    const user = {
+        userId: payload.user_id,
+        userEmail: payload.user_email,
+        userEmailDomain: payload.user_email_domain,
+    };
+    return user;
+}
+function mapLoggedInUserPayloadToLoggedInUser(payload, zeniSessionId, authProvider) {
+    return {
+        userId: payload.user_id,
+        zeniSessionId: zeniSessionId,
+        firstName: payload.first_name?.trim(),
+        lastName: payload.last_name?.trim(),
+        photo: toURL(payload.photo),
+        authProvider: authProvider,
+        phoneNumber: payload.phone_number ?? undefined,
+    };
+}
+export const toRoleResource = (payload) => ({
+    roleResourceId: payload.role_resource_id,
+    resource: fromBase64(payload.resource),
+    resourceVersion: payload.resource_version,
+    isExclude: payload.is_exclude,
+    isZeni: payload.is_zeni,
+    createTime: date(payload.create_time),
+    updateTime: date(payload.update_time),
+});
+/**
+ * Converts Connections payload to Connection State
+ * @param payload Connections payload as received from backend API response
+ * @returns returns Connection[] list
+ */
+export function mapConnectionsPayloadToState(connectionsPayload) {
+    if (Object.keys(connectionsPayload).length == 0) {
+        throw new Error('No connections ? ');
+    }
+    const { connections } = connectionsPayload;
+    return {
+        accounting: connections.accounting.map((payload) => toConnection(payload)),
+        // Tenant materializes gmail/outlook under the `email` bucket via
+        // _THIRD_PARTY_CONNECTORS_TO_MATERIALIZE when their slugs are enabled in
+        // third_party_enabled_connectors Statsig config. Default to [] so older
+        // tenant deploys (or disabled-everywhere envs) don't blow up here.
+        email: (connections.email ?? []).map((payload) => toConnection(payload)),
+        payments: connections.payments.map((payload) => toConnection(payload)),
+        revenue: (connections.revenue ?? []).map((payload) => toConnection(payload)),
+    };
+}
+export const toConnection = (payload) => ({
+    authorizationCode: payload.authorization_code ?? undefined,
+    companyId: payload.company_id ?? '',
+    connectionId: payload.connection_id,
+    connectionName: payload.connection_name,
+    connectionDisplayName: payload.connection_name_for_display,
+    connectionType: payload.connection_type,
+    connectionDisplayType: payload.connection_type_for_display,
+    createTime: date(payload.create_time),
+    isValid: payload.is_valid,
+    realmId: payload.realm_id ?? undefined,
+    updateTime: date(payload.update_time),
+    userId: payload.user_id,
+});
+// Replace a Connection in a same-bucket array (e.g. revenue: [chargebee, hubspot])
+// matching by connectionName, or append if no match. Mutates the array — safe
+// inside an Immer draft, which is the only place this is called from.
+function replaceOrAppendConnectionByName(connections, incomingConnection) {
+    const existingIndex = connections.findIndex((existingConnection) => existingConnection.connectionName === incomingConnection.connectionName);
+    if (existingIndex === -1) {
+        connections.push(incomingConnection);
+    }
+    else {
+        connections[existingIndex] = incomingConnection;
+    }
+}