@zeniai/client-epic-state 5.2.14 → 5.2.16

package/lib/esm/view/expenseAutomationView/epics/common/fetchAllExpenseAutomationTabsEpic.js

@@ -8,6 +8,7 @@ import { fetchJeSchedulesPage } from '../../reducers/jeSchedulesViewReducer';
 import { fetchMissingReceipts } from '../../reducers/missingReceiptsViewReducer';
 import { fetchReconciliation } from '../../reducers/reconciliationViewReducer';
 import { fetchTransactionCategorizationView } from '../../reducers/transactionsViewReducer';
+import { getJESchedulePeriodTabKey } from '../../types/jeSchedulesViewState';
 export const fetchAllExpenseAutomationTabsEpic = (actions$, state$) => actions$.pipe(filter(fetchAllExpenseAutomationTabs.match), switchMap((action) => {
     const { cacheOverride, refreshViewInBackground } = action.payload;
     const state = state$.value;
@@ -59,14 +60,16 @@ export const fetchAllExpenseAutomationTabsEpic = (actions$, state$) => actions$.
                 state.expenseAutomationFluxAnalysisViewState.groupsBySelectedPeriod[monthYearPeriodId] == null)) {
             fetchActions.push(fetchFluxAnalysisView(selectedPeriod, cacheOverride, refreshViewInBackground, null));
         }
+        // The two JE tabs cache separately, so only the tab actually being shown decides whether a
+        // fetch is still needed.
+        const jeSchedulesPeriodTabKey = getJESchedulePeriodTabKey(state.expenseAutomationJESchedulesViewState.uiState.selectedPageTab, monthYearPeriodId);
         if (state.expenseAutomationJESchedulesViewState.fetchState !==
             'In-Progress' &&
             (!state.expenseAutomationJESchedulesViewState.hasValidState() ||
                 state.expenseAutomationJESchedulesViewState
-                    .jeScheduleTransactionKeysByPeriod[monthYearPeriodId] == null ||
+                    .jeScheduleTransactionKeysByPeriodAndTab[jeSchedulesPeriodTabKey] == null ||
                 state.expenseAutomationJESchedulesViewState
-                    .failedJeScheduleTransactionKeysByPeriod[monthYearPeriodId] ==
-                    null)) {
+                    .failedJeScheduleTransactionKeysByPeriodAndTab[jeSchedulesPeriodTabKey] == null)) {
             fetchActions.push(fetchJeSchedulesPage({ start: timePeriodStart, end: timePeriodEnd }, cacheOverride));
         }
         if (state.expenseAutomationReconciliationViewState.fetchState !==

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/fetchJeSchedulePageEpic.js

@@ -14,6 +14,14 @@ export const fetchJeSchedulesPageEpic = (actions$, state$) => actions$.pipe(filt
         jeSchedulePageActions.push(fetchAccountList(accountType.accountListKey, true, false, false, false, accountType.allowedAccountList));
     }
     jeSchedulePageActions.push(fetchJeSchedules(period, refreshViewInBackground));
-    jeSchedulePageActions.push(initializeAccountSettingsView());
+    // Only on the first page load. Account settings cannot change from a tab switch or a
+    // refresh, and re-initializing puts accountSettingsView back to 'In-Progress' -- which the
+    // page reads as "still loading" and answers with a full skeleton over rows it already has.
+    // The action also resets localData, so re-dispatching it blindly would empty the settings
+    // form until the refetch lands. Saving account settings still re-initializes explicitly.
+    if (!state$.value.expenseAutomationJESchedulesViewState.accountSettings
+        .hasLoadedAccountSettings) {
+        jeSchedulePageActions.push(initializeAccountSettingsView());
+    }
     return concat(from(jeSchedulePageActions));
 }));

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/fetchJeSchedulesEpic.js

@@ -1,9 +1,12 @@
 import { from, of } from 'rxjs';
-import { catchError, filter, mergeMap } from 'rxjs/operators';
-import { toString } from '../../../../commonStateTypes/timePeriod';
-import { updateJESchedules, updateJESchedulesDetails, } from '../../../../entity/jeSchedules/jeSchedulesReducer';
+import { catchError, filter, mergeMap, takeUntil } from 'rxjs/operators';
+import { DEFAULT_DATE_FORMAT } from '../../../../commonStateTypes/timePeriod';
+import { toAbsoluteDay, toString } from '../../../../commonStateTypes/timePeriod';
+import { updateAccruedJESchedules, updateAccruedJESchedulesDetails, updateJEOneTimeAccruals, updateJESchedules, updateJESchedulesDetails, } from '../../../../entity/jeSchedules/jeSchedulesReducer';
 import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { clearAll } from '../../../../rootActions';
+import { date } from '../../../../zeniDayJS';
 import { fetchJeSchedules, fetchJeSchedulesFailure, fetchJeSchedulesSuccess, initializeJeScheduleLocalData, } from '../../reducers/jeSchedulesViewReducer';
 export const fetchJeSchedulesEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchJeSchedules.match), mergeMap((action) => {
     const state = state$.value;
@@ -11,27 +14,54 @@ export const fetchJeSchedulesEpic = (actions$, state$, zeniAPI) => actions$.pipe
     const { period, refreshViewInBackground } = action.payload;
     const currentTenant = getCurrentTenant(state);
     const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    const { selectedPageTab } = state.expenseAutomationJESchedulesViewState.uiState;
+    const isClosePeriodTab = selectedPageTab === 'schedules';
+    const existingEndDate = toAbsoluteDay(date(toString(period.start))
+        .subtract(1, 'month')
+        .endOf('month')
+        .format(DEFAULT_DATE_FORMAT));
     const queryParam = {
         start_date: toString(period.start),
-        end_date: toString(period.end),
+        end_date: isClosePeriodTab || existingEndDate == null
+            ? toString(period.end)
+            : toString(existingEndDate),
+        include_accrued: true,
+        ...(isClosePeriodTab
+            ? { close_period_start_date: toString(period.start) }
+            : {}),
     };
     return zeniAPI
         .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/expenses_automation/je_schedules?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
         .pipe(mergeMap((response) => {
         if (isSuccessResponse(response) && response.data != null) {
             const updateActions = [];
+            const accruedJeSchedules = response.data.accrued_je_schedules?.je_schedules ?? [];
+            const oneTimeAccruals = response.data.one_time_accruals ?? [];
             updateActions.push(updateJESchedules([
                 ...response.data.je_schedules,
                 ...response.data.failed_je_postings.je_schedules,
             ]), updateJESchedulesDetails([...response.data.failed_je_postings.je_schedules], response.data.failed_je_postings.scheduled_journal_entries), initializeJeScheduleLocalData([
                 ...response.data.failed_je_postings.je_schedules,
             ]));
+            if (accruedJeSchedules.length > 0) {
+                updateActions.push(updateAccruedJESchedules(accruedJeSchedules), updateAccruedJESchedulesDetails(accruedJeSchedules, response.data.accrued_je_schedules
+                    ?.scheduled_journal_entries));
+            }
+            if (oneTimeAccruals.length > 0) {
+                // Single action, unlike the accrued pair above: this one writes the entity
+                // directly because an accrual denormalizes its vendor, accounts and classes, so
+                // there is no fan-out fetch to trigger.
+                updateActions.push(updateJEOneTimeAccruals(oneTimeAccruals));
+            }
             updateActions.push(fetchJeSchedulesSuccess({
                 jeSchedules: [...response.data.je_schedules],
                 failedJeSchedules: [
                     ...response.data.failed_je_postings.je_schedules,
                 ],
+                accruedJeSchedules: accruedJeSchedules,
+                oneTimeAccruals: oneTimeAccruals,
                 selectedPeriod: selectedPeriod,
+                selectedPageTab: selectedPageTab,
                 refreshViewInBackground: refreshViewInBackground,
             }));
             return from(updateActions);
@@ -40,11 +70,17 @@ export const fetchJeSchedulesEpic = (actions$, state$, zeniAPI) => actions$.pipe
             return of(fetchJeSchedulesFailure({
                 status: response.status,
                 selectedPeriod,
+                selectedPageTab,
             }));
         }
     }), catchError((error) => of(fetchJeSchedulesFailure({
         status: createZeniAPIStatus('Unexpected Error', 'fetch JE schedules REST API call errored out' +
             JSON.stringify(error)),
         selectedPeriod,
-    }))));
+        selectedPageTab,
+    }))), 
+    // A tenant switch clears the store while this request is still in flight. Without this
+    // the old tenant's rows are written back into the freshly cleared store and stay on
+    // screen under the new tenant until a manual refresh.
+    takeUntil(actions$.pipe(filter(clearAll.match))));
 }));

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/fetchOneTimeAccrualEpic.js

@@ -0,0 +1,45 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, takeUntil } from 'rxjs/operators';
+import { updateJEOneTimeAccruals } from '../../../../entity/jeSchedules/jeSchedulesReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { clearAll } from '../../../../rootActions';
+import { fetchOneTimeAccrual, fetchOneTimeAccrualFailure, fetchOneTimeAccrualSuccess, } from '../../reducers/jeSchedulesViewReducer';
+/**
+ * Read one accrual by id so its detail page can render from a URL alone.
+ *
+ * Every other row on this page arrives with the JE Schedules list, and the accrual detail page used
+ * to render only from what that list had already put in the store -- so opening its URL directly, on
+ * a refresh or a shared link, had nothing to render and showed not-found. This is the read that
+ * makes the URL self-sufficient.
+ *
+ * The response is the same `{accrual}` envelope promote / ignore / revert return, and it goes through
+ * the same `updateJEOneTimeAccruals`, so a page loaded cold holds exactly the entity a page reached
+ * through the list holds.
+ */
+export const fetchOneTimeAccrualEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchOneTimeAccrual.match), mergeMap((action) => {
+    const { accrualId } = action.payload;
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/accruals/${accrualId}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return from([
+                updateJEOneTimeAccruals([response.data.accrual]),
+                fetchOneTimeAccrualSuccess({ accrualId }),
+            ]);
+        }
+        // A deleted or ignored accrual answers 404 here, the same as an id that never existed.
+        // Both end as an error state the page turns into not-found, rather than a spinner that
+        // never resolves.
+        return from([
+            fetchOneTimeAccrualFailure({ accrualId, status: response.status }),
+        ]);
+    }), catchError((error) => from([
+        fetchOneTimeAccrualFailure({
+            accrualId,
+            status: createZeniAPIStatus('Unexpected Error', `Fetch one-time accrual REST API call errored out ${JSON.stringify(error)}`),
+        }),
+    ])), 
+    // A tenant switch clears the store while this request is in flight. Without this the old
+    // tenant's accrual is written back into the freshly cleared store.
+    takeUntil(actions$.pipe(filter(clearAll.match))));
+}));

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/ignoreRecommendedJeScheduleEpic.js

@@ -11,13 +11,25 @@ import { ignoreRecommendedJeSchedule, ignoreRecommendedJeScheduleFailure, ignore
 export const ignoreRecommendedJeScheduleEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(ignoreRecommendedJeSchedule.match), mergeMap((action) => {
     const state = state$.value;
     const { expenseAutomationViewState: { selectedPeriodByTenantId }, } = state;
-    const { scheduleType, jeScheduleTransactionKey } = action.payload;
+    const { scheduleType, jeScheduleTransactionKey, reason, note } = action.payload;
     const currentTenant = getCurrentTenant(state);
     const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
     const actions = [];
     const jeScheduleTransactionState = getJEScheduledTransactionByJEScheduleTransactionKey(jeScheduleTransactionKey, state);
+    const ignorePayload = prepareIgnoreSchedulePayload(scheduleType, jeScheduleTransactionState, state);
+    // The gateway reads reason/note from je_schedules[0].feedback and nowhere else, and rejects
+    // anything but those two keys inside it — `action` is stamped server-side.
     const payload = {
-        ...prepareIgnoreSchedulePayload(scheduleType, jeScheduleTransactionState, state),
+        ...ignorePayload,
+        je_schedules: ignorePayload.je_schedules.map((schedule, index) => index === 0
+            ? {
+                ...schedule,
+                feedback: {
+                    reason,
+                    ...(note != null && note !== '' ? { note } : {}),
+                },
+            }
+            : schedule),
     };
     const queryParam = {
         je_schedule_type: scheduleType,

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/newSchedule/createOneTimeAccrualEpic.js

@@ -0,0 +1,104 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, takeUntil } from 'rxjs/operators';
+import { convertToPeriod, toAbsoluteDay, } from '../../../../../commonStateTypes/timePeriod';
+import { updateJEOneTimeAccruals } from '../../../../../entity/jeSchedules/jeSchedulesReducer';
+import { openSnackbar } from '../../../../../entity/snackbar/snackbarReducer';
+import { getCurrentTenant } from '../../../../../entity/tenant/tenantSelector';
+import { clearAll } from '../../../../../rootActions';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
+import { prepareCreateOneTimeAccrualPayload, } from '../../../payload/jeSchedulesPayload';
+import { createOneTimeAccrual, createOneTimeAccrualFailure, createOneTimeAccrualSuccess, fetchJeSchedules, } from '../../../reducers/jeSchedulesViewReducer';
+export const createOneTimeAccrualEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(createOneTimeAccrual.match), mergeMap((action) => {
+    const state = state$.value;
+    const { localData } = action.payload;
+    /*
+     * Idempotency for the create. agent-je dedupes on this: the same key again returns the
+     * existing accrual rather than posting a second JE to QBO.
+     *
+     * Body `request_id` rather than the `Idempotency-Key` header the API doc prefers, on Mohit's
+     * call (2026-08-24). The header cannot reach the service from a browser -- common's
+     * Access-Control-Allow-Headers does not list it, so cross-origin preflight rejects the
+     * request. Same meaning either way; the header simply wins when both are sent.
+     *
+     * Minted here, per create action, and deliberately not held in local data or the form: a new
+     * Save must produce a new key, and only a retry of *this* request may reuse one. Nothing
+     * retries today -- if a retry operator is ever added below, it has to sit inside this
+     * mergeMap so the key is not re-minted, or the guarantee is silently lost.
+     */
+    const requestId = crypto.randomUUID();
+    const payload = {
+        ...prepareCreateOneTimeAccrualPayload(state, localData),
+        request_id: requestId,
+    };
+    // convertToPeriod destructures, so an unset period would throw here and take the epic
+    // subscription down for the whole session — a missed refresh is the cheaper failure.
+    const selectedMonthYear = state.expenseAutomationViewState.selectedPeriodByTenantId[getCurrentTenant(state).tenantId];
+    const selectedPeriod = selectedMonthYear != null
+        ? convertToPeriod(selectedMonthYear)
+        : undefined;
+    const periodStart = selectedPeriod != null
+        ? toAbsoluteDay(selectedPeriod.start)
+        : undefined;
+    const periodEnd = selectedPeriod != null ? toAbsoluteDay(selectedPeriod.end) : undefined;
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/accruals`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const successActions = [
+                updateJEOneTimeAccruals([response.data.accrual]),
+                createOneTimeAccrualSuccess(),
+                openSnackbar({
+                    messageSection: 'create_schedule',
+                    messageText: 'success',
+                    type: 'success',
+                    variables: [
+                        {
+                            variableName: '_vendor_name_',
+                            variableValue: localData.vendorName,
+                        },
+                    ],
+                }),
+            ];
+            // The tab buckets (jeScheduleOneTimeAccrualKeysByPeriodAndTab) are rebuilt wholesale
+            // per fetch, and the backend decides whether a freshly posted accrual belongs to
+            // Review or Existing — so refetch rather than guess which bucket to insert into.
+            if (periodStart != null && periodEnd != null) {
+                successActions.push(fetchJeSchedules({ start: periodStart, end: periodEnd }, true));
+            }
+            return from(successActions);
+        }
+        return from([
+            createOneTimeAccrualFailure({ status: response.status }),
+            openSnackbar({
+                messageSection: 'create_schedule',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }),
+        ]);
+    }), catchError((error) => from([
+        openSnackbar({
+            messageSection: 'create_schedule',
+            messageText: 'failed',
+            type: 'error',
+            variables: [
+                {
+                    variableName: '_api-error_',
+                    variableValue: JSON.stringify(error),
+                },
+            ],
+        }),
+        createOneTimeAccrualFailure({
+            status: createZeniAPIStatus('Unexpected Error', `Create One Time Accrual REST API call errored out ${JSON.stringify(error)}`),
+        }),
+    ])), 
+    // A tenant switch clears the store while this request is still in flight.
+    // Without this the old tenant's response is written back into the freshly
+    // cleared store and stays on screen under the new tenant.
+    takeUntil(actions$.pipe(filter(clearAll.match))));
+}));

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/newSchedule/initializeNewScheduleEpic.js

@@ -0,0 +1,25 @@
+import { from } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { fetchAccountList } from '../../../../accountList/accountListReducer';
+import { fetchClassList } from '../../../../classList/classListReducer';
+import { getAccountsTypesForScheduleEpics } from '../../../../scheduleView/scheduleListView/scheduleListHelper';
+import { clearSearchTransactionsForNewSchedule, initializeNewSchedule, resetNewScheduleLocalData, } from '../../../reducers/jeSchedulesViewReducer';
+export const initializeNewScheduleEpic = (actions$, state$) => actions$.pipe(filter(initializeNewSchedule.match), mergeMap((action) => {
+    const newScheduleActions = [];
+    const accountType = getAccountsTypesForScheduleEpics();
+    const { accountListState, classListState } = state$.value;
+    if (accountListState.byReportId[accountType.accountListKey]?.fetchState ===
+        'Not-Started') {
+        newScheduleActions.push(fetchAccountList(accountType.accountListKey, true, false, false, false, accountType.allowedAccountList));
+    }
+    if (classListState.fetchState === 'Not-Started') {
+        newScheduleActions.push(fetchClassList());
+    }
+    // The account and class fetches above are idempotent (both guard on 'Not-Started'), so they
+    // can run on every open. Clearing what the user entered cannot, so it is opt-in.
+    if (action.payload.shouldResetEnteredData) {
+        newScheduleActions.push(resetNewScheduleLocalData({ scheduleType: action.payload.scheduleType }));
+        newScheduleActions.push(clearSearchTransactionsForNewSchedule());
+    }
+    return from(newScheduleActions);
+}));

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/newSchedule/saveNewScheduleEpic.js

@@ -0,0 +1,138 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, takeUntil } from 'rxjs/operators';
+import { convertToPeriod, toAbsoluteDay, } from '../../../../../commonStateTypes/timePeriod';
+import { getCurrentTenant } from '../../../../../entity/tenant/tenantSelector';
+import { clearAll } from '../../../../../rootActions';
+import { updateJESchedules, updateJESchedulesDetails, } from '../../../../../entity/jeSchedules/jeSchedulesReducer';
+import { getJEScheduleTransactionKey } from '../../../../../entity/jeSchedules/jeSchedulesTypes';
+import { openSnackbar } from '../../../../../entity/snackbar/snackbarReducer';
+import { getScheduleTransactionById } from '../../../../../entity/transaction/transactionSelector';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
+import { prepareNewSchedulePayload, } from '../../../helpers/newScheduleLocalDataHelper';
+import { fetchJeSchedules, resetNewScheduleLocalData, saveNewSchedule, saveNewScheduleFailure, saveNewScheduleSuccess, } from '../../../reducers/jeSchedulesViewReducer';
+const FAILURE_REASON_MESSAGES = {
+    missing_third_party_id: 'This transaction is missing a QuickBooks reference and cannot be scheduled.',
+    // The form cannot satisfy this: the vendor field is hard-disabled and inherited from the base
+    // transaction, so the fix is on the transaction, not here.
+    missing_vendor: 'This transaction has no vendor and cannot be scheduled. Add a vendor to the transaction first.',
+};
+export const saveNewScheduleEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(saveNewSchedule.match), mergeMap((action) => {
+    const { scheduleType } = action.payload;
+    const state = state$.value;
+    const localData = state.expenseAutomationJESchedulesViewState.newSchedule
+        .newScheduleState[scheduleType];
+    const { selectedBaseTransactionId } = localData;
+    const transaction = selectedBaseTransactionId != null
+        ? getScheduleTransactionById(state.transactionState, getJEScheduleTransactionKey(selectedBaseTransactionId))
+        : undefined;
+    if (transaction == null) {
+        return from([
+            saveNewScheduleFailure({
+                status: createZeniAPIStatus('Unexpected Error', 'No base transaction selected for this schedule.'),
+            }),
+            openSnackbar({
+                messageSection: 'create_schedule',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: 'No base transaction selected.',
+                    },
+                ],
+            }),
+        ]);
+    }
+    const result = prepareNewSchedulePayload(transaction, localData, scheduleType);
+    if (!result.ok) {
+        const message = FAILURE_REASON_MESSAGES[result.reason];
+        return from([
+            saveNewScheduleFailure({
+                status: createZeniAPIStatus('Unexpected Error', message),
+            }),
+            openSnackbar({
+                messageSection: 'create_schedule',
+                messageText: 'failed',
+                type: 'error',
+                variables: [{ variableName: '_api-error_', variableValue: message }],
+            }),
+        ]);
+    }
+    const vendorName = localData.selectedVendor?.name ?? transaction.vendorName ?? '';
+    const queryParam = {
+        je_schedule_type: scheduleType,
+    };
+    const payload = { ...result.payload };
+    // convertToPeriod destructures, so an unset period would throw here and take the epic
+    // subscription down for the whole session -- a missed refresh is the cheaper failure.
+    const selectedMonthYear = state.expenseAutomationViewState.selectedPeriodByTenantId[getCurrentTenant(state).tenantId];
+    const selectedPeriod = selectedMonthYear != null
+        ? convertToPeriod(selectedMonthYear)
+        : undefined;
+    const periodStart = selectedPeriod != null
+        ? toAbsoluteDay(selectedPeriod.start)
+        : undefined;
+    const periodEnd = selectedPeriod != null ? toAbsoluteDay(selectedPeriod.end) : undefined;
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/schedules?query=${encodeURIComponent(JSON.stringify(queryParam))}`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const successActions = [
+                updateJESchedules(response.data.je_schedules),
+                updateJESchedulesDetails(response.data.je_schedules, response.data.scheduled_journal_entries),
+                resetNewScheduleLocalData({ scheduleType }),
+                saveNewScheduleSuccess(),
+                openSnackbar({
+                    messageSection: 'create_schedule',
+                    messageText: 'success',
+                    type: 'success',
+                    variables: [
+                        { variableName: '_vendor_name_', variableValue: vendorName },
+                    ],
+                }),
+            ];
+            // Writing the entity is not enough: the list reads
+            // jeScheduleTransactionKeysByPeriodAndTab, which is rebuilt wholesale per fetch, so
+            // without this the new schedule stays invisible until some later fetch. The page
+            // only refetches when the save also changes tab, so saving from the tab the row
+            // lands on showed nothing. Same reasoning as createOneTimeAccrualEpic.
+            if (periodStart != null && periodEnd != null) {
+                successActions.push(fetchJeSchedules({ start: periodStart, end: periodEnd }, true));
+            }
+            return from(successActions);
+        }
+        return from([
+            saveNewScheduleFailure({ status: response.status }),
+            openSnackbar({
+                messageSection: 'create_schedule',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }),
+        ]);
+    }), catchError((error) => from([
+        openSnackbar({
+            messageSection: 'create_schedule',
+            messageText: 'failed',
+            type: 'error',
+            variables: [
+                {
+                    variableName: '_api-error_',
+                    variableValue: JSON.stringify(error),
+                },
+            ],
+        }),
+        saveNewScheduleFailure({
+            status: createZeniAPIStatus('Unexpected Error', `Save New Schedule REST API call errored out ${JSON.stringify(error)}`),
+        }),
+    ])), 
+    // A tenant switch clears the store while this request is still in flight.
+    // Without this the old tenant's response is written back into the freshly
+    // cleared store and stays on screen under the new tenant.
+    takeUntil(actions$.pipe(filter(clearAll.match))));
+}));

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/newSchedule/searchTransactionsForNewScheduleEpic.js

@@ -0,0 +1,79 @@
+import { EMPTY, from, merge, of } from 'rxjs';
+import { catchError, debounceTime, filter, mergeMap, switchMap, } from 'rxjs/operators';
+import { getJEScheduleTransactionKey } from '../../../../../entity/jeSchedules/jeSchedulesTypes';
+import { toTransactionType } from '../../../../../entity/transaction/stateTypes/transactionType';
+import { updateScheduleTransactions } from '../../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
+import { searchTransactionsForNewSchedule, searchTransactionsForNewScheduleFailure, searchTransactionsForNewScheduleSuccess, } from '../../../reducers/jeSchedulesViewReducer';
+import { MIN_NEW_SCHEDULE_SEARCH_LENGTH } from '../../../types/jeSchedulesViewState';
+/**
+ * Dropdown-sized result set. The endpoint is paginated — it takes a `page_token` $skip offset and
+ * returns `next_page_token` — but nothing here reads or sends those, so this is the whole result
+ * set the form ever sees. 20 rather than the backend's default of 10 because a text search for one
+ * known transaction was running out of room; the cap server-side is 100 if this needs raising again
+ * before infinite scroll is wired up.
+ */
+const NEW_SCHEDULE_SEARCH_PAGE_SIZE = 20;
+/** Fallback when the backend sends a null currency for a search result. */
+const DEFAULT_CURRENCY_CODE = 'USD';
+const DEFAULT_CURRENCY_SYMBOL = '$';
+export const searchTransactionsForNewScheduleEpic = (actions$, _state$, zeniAPI) => {
+    const searchActions$ = actions$.pipe(filter(searchTransactionsForNewSchedule.match));
+    /** No API for empty or 1-char queries; immediate merge so switchMap cancels any in-flight HTTP. */
+    const newSearchTooShortOrClear$ = searchActions$.pipe(filter((action) => action.payload.query.trim().length < MIN_NEW_SCHEDULE_SEARCH_LENGTH));
+    const newSearchDebounced$ = searchActions$.pipe(filter((action) => action.payload.query.trim().length >= MIN_NEW_SCHEDULE_SEARCH_LENGTH), debounceTime(300));
+    return merge(newSearchTooShortOrClear$, newSearchDebounced$).pipe(switchMap((action) => {
+        const query = action.payload.query.trim();
+        if (query.length < MIN_NEW_SCHEDULE_SEARCH_LENGTH) {
+            return EMPTY;
+        }
+        const queryParam = {
+            page_size: NEW_SCHEDULE_SEARCH_PAGE_SIZE,
+            search_text: query,
+            je_schedule_type: action.payload.scheduleType,
+        };
+        return zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/schedules/base_transaction_search?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
+            .pipe(mergeMap((response) => {
+            if (isSuccessResponse(response) && response.data != null) {
+                const { transactions } = response.data;
+                const transactionsPerCurrency = {};
+                transactions.forEach((transaction) => {
+                    const { currency_code, currency_symbol } = transaction;
+                    const currencyCode = currency_code ?? DEFAULT_CURRENCY_CODE;
+                    const existing = transactionsPerCurrency[currencyCode];
+                    transactionsPerCurrency[currencyCode] =
+                        existing != null
+                            ? {
+                                currencySymbol: existing.currencySymbol,
+                                transactions: [...existing.transactions, transaction],
+                            }
+                            : {
+                                currencySymbol: currency_code == null
+                                    ? DEFAULT_CURRENCY_SYMBOL
+                                    : currency_symbol,
+                                transactions: [transaction],
+                            };
+                });
+                const actionsOut = Object.keys(transactionsPerCurrency).map((currencyCode) => {
+                    const perCurrency = transactionsPerCurrency[currencyCode];
+                    return updateScheduleTransactions(perCurrency.transactions, currencyCode, perCurrency.currencySymbol, 'merge');
+                });
+                actionsOut.push(searchTransactionsForNewScheduleSuccess({
+                    searchResults: transactions.map((transaction) => getJEScheduleTransactionKey({
+                        id: transaction.transaction_id,
+                        type: toTransactionType(transaction.transaction_type),
+                        lineId: transaction.line_id,
+                    })),
+                }));
+                return from(actionsOut);
+            }
+            return of(searchTransactionsForNewScheduleFailure({
+                status: response.status,
+            }));
+        }), catchError((error) => of(searchTransactionsForNewScheduleFailure({
+            status: createZeniAPIStatus('Unexpected Error', 'Search transactions for new schedule errored: ' +
+                JSON.stringify(error)),
+        }))));
+    }));
+};