@zeniai/client-epic-state 5.0.73 → 5.0.75

package/lib/view/expenseAutomationView/transactionFilterHelpers.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTransactionFilters = exports.TRANSACTION_FILTER_CATEGORIES = void 0;
+/**
+ * Narrowing type-guard for "has a non-empty string here". Used in place of
+ * raw `if (foo)` truthiness checks on `string | null | undefined` values so
+ * the `@typescript-eslint/strict-boolean-expressions` lint stays clean —
+ * empty strings should explicitly fall through to the next candidate
+ * (vendorName → customerName → localData.vendor.name → ...) rather than
+ * being implicitly coerced to falsy.
+ */
+const isNonEmptyString = (s) => s != null && s !== '';
+/**
+ * First line item in UI order. `lineItemById` is a Record whose iteration
+ * order is not guaranteed to match what the user sees; `sortedLineItems`
+ * is the canonical ordering used by the categorization list/detail views.
+ */
+const getFirstLineItemFromReviewLocalData = (localData) => {
+    const { sortedLineItems, lineItemById } = localData;
+    if (sortedLineItems.length > 0) {
+        return lineItemById[sortedLineItems[0]];
+    }
+    const lineItems = Object.values(lineItemById);
+    return lineItems.length > 0 ? lineItems[0] : undefined;
+};
+exports.TRANSACTION_FILTER_CATEGORIES = [
+    { value: 'payment_account_name', type: 'dropdown' },
+    { value: 'payment_account_type', type: 'dropdown' },
+    { value: 'payee', type: 'searchAutocomplete' },
+    { value: 'category', type: 'dropdown' },
+    { value: 'class', type: 'dropdown' },
+    { value: 'amount', type: 'numberRange' },
+];
+/**
+ * Resolve the comparable value for a transaction against a given filter field.
+ * Returns undefined when the transaction doesn't carry the field — callers
+ * decide whether absence counts as a match (for 'not_equal' it does).
+ */
+const getCategoryValueForTransaction = (key, transaction) => {
+    switch (key) {
+        case 'amount': {
+            // Prefer transactionLocalData line items (sum). Fall back to lines on
+            // the transaction itself. Final fallback: transaction-level amount.
+            const localDataForAmount = transaction.transactionLocalData?.transactionReviewLocalData;
+            if (localDataForAmount?.lineItemById) {
+                const lineItems = Object.values(localDataForAmount.lineItemById);
+                if (lineItems.length > 0) {
+                    return lineItems.reduce((sum, lineItem) => sum + (lineItem.amount?.amount ?? 0), 0);
+                }
+            }
+            if (transaction.transaction.lines &&
+                transaction.transaction.lines.length > 0) {
+                return transaction.transaction.lines.reduce((sum, line) => sum + (line.amount?.amount ?? 0), 0);
+            }
+            return transaction.amount.amount;
+        }
+        case 'payee': {
+            if (isNonEmptyString(transaction.vendorName)) {
+                return transaction.vendorName;
+            }
+            if (isNonEmptyString(transaction.customerName)) {
+                return transaction.customerName;
+            }
+            const localData = transaction.transactionLocalData?.transactionReviewLocalData;
+            const vendorName = localData?.vendor?.name;
+            if (isNonEmptyString(vendorName)) {
+                return vendorName;
+            }
+            const customerName = localData?.customer?.name;
+            if (isNonEmptyString(customerName)) {
+                return customerName;
+            }
+            return undefined;
+        }
+        case 'payment_account_name': {
+            // Match what TransactionCategorizationListRow renders for the cell.
+            return transaction.transaction.account?.accountName;
+        }
+        case 'payment_account_type': {
+            // Raw `paymentType` enum ("credit_card" / "check" / "cash"). Dropdown
+            // option values use the same enum; row uses `paymentTypeName` for the
+            // human label.
+            return transaction.transaction.paymentType;
+        }
+        case 'category': {
+            const localDataForCategory = transaction.transactionLocalData?.transactionReviewLocalData;
+            if (localDataForCategory != null) {
+                const firstLineItem = getFirstLineItemFromReviewLocalData(localDataForCategory);
+                const accountId = firstLineItem?.account?.accountId;
+                if (isNonEmptyString(accountId)) {
+                    return accountId;
+                }
+                const qboId = firstLineItem?.account?.qboId;
+                if (isNonEmptyString(qboId)) {
+                    return qboId;
+                }
+                const accountName = firstLineItem?.account?.accountName;
+                if (isNonEmptyString(accountName)) {
+                    return accountName;
+                }
+            }
+            const firstLineForCategory = transaction.transaction.lines?.[0];
+            if (firstLineForCategory?.type ===
+                'transaction_with_account_and_class_line' ||
+                firstLineForCategory?.type ===
+                    'transaction_with_product_or_service_line' ||
+                firstLineForCategory?.type === 'journal_entry_transaction_line') {
+                const account = firstLineForCategory.account;
+                return account?.accountId ?? account?.qboId ?? account?.accountName;
+            }
+            return undefined;
+        }
+        case 'class': {
+            const localDataForClass = transaction.transactionLocalData?.transactionReviewLocalData;
+            if (localDataForClass != null) {
+                const firstLineItemForClass = getFirstLineItemFromReviewLocalData(localDataForClass);
+                const classId = firstLineItemForClass?.class?.classId;
+                if (isNonEmptyString(classId)) {
+                    return classId;
+                }
+                const qboId = firstLineItemForClass?.class?.qboId;
+                if (isNonEmptyString(qboId)) {
+                    return qboId;
+                }
+                const className = firstLineItemForClass?.class?.className;
+                if (isNonEmptyString(className)) {
+                    return className;
+                }
+            }
+            const firstLineForClass = transaction.transaction.lines?.[0];
+            if (firstLineForClass?.type === 'transaction_with_account_and_class_line' ||
+                firstLineForClass?.type ===
+                    'transaction_with_product_or_service_line' ||
+                firstLineForClass?.type === 'journal_entry_transaction_line') {
+                const classData = firstLineForClass.class;
+                return classData?.classId ?? classData?.qboId ?? classData?.className;
+            }
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+};
+/**
+ * TC-only amount matcher. Supports all five operators TC defines, including
+ * the legacy "1000<->5000" range-string form (kept for backward compatibility
+ * with persisted filter state that may still contain that encoding).
+ *
+ * The `'equal' | 'not_equal'` branch matches if `amount` equals ANY of the
+ * configured values (consistent with how non-amount filters interpret a
+ * multi-value `values` array). `.some()` over the values array also makes
+ * the empty-values case behave correctly — empty array → `matched = false`
+ * — though in practice `applyTransactionFilters` strips empty-values
+ * categories before they reach this matcher. The trailing
+ * `op === 'not_equal' ? !matched : matched` line inverts for `not_equal`.
+ */
+const matchAmount = (amount, category) => {
+    const op = category.matchingOperator;
+    const values = category.values;
+    let matched = false;
+    if (op === 'in_between') {
+        if (values.length >= 2) {
+            const min = Number(values[0]);
+            const max = Number(values[1]);
+            matched = amount >= min && amount <= max;
+        }
+    }
+    else if (op === 'less_than') {
+        if (values.length >= 1) {
+            matched = amount < Number(values[0]);
+        }
+    }
+    else if (op === 'greater_than') {
+        if (values.length >= 1) {
+            matched = amount > Number(values[0]);
+        }
+    }
+    else if (op === 'equal' || op === 'not_equal') {
+        matched = values.some((v) => {
+            const s = String(v);
+            // Backward compatibility: legacy "low<->high" range-string form
+            // persisted under `matchingOperator: 'equal'`.
+            if (s.includes('<->')) {
+                const parts = s.split('<->');
+                return (amount >= Number(parts[0] ?? '') && amount <= Number(parts[1] ?? ''));
+            }
+            return amount === Number(v);
+        });
+    }
+    return op === 'not_equal' ? !matched : matched;
+};
+const transactionMatchesCategory = (transaction, category) => {
+    const value = getCategoryValueForTransaction(category.field, transaction);
+    if (value == null) {
+        // Absent-value semantics — pinning these down explicitly so the
+        // asymmetry isn't surprising:
+        //
+        //   not_equal: a missing value IS NOT EQUAL to any candidate, so the
+        //              transaction matches the filter (passes through).
+        //   equal:     a missing value is not equal to any candidate, so the
+        //              transaction does NOT match (filtered out).
+        //   less_than / greater_than: SQL-style three-valued logic — comparing
+        //              against a missing value is "unknown", which we treat as
+        //              "does not match" (filtered out). A user setting
+        //              "amount < $1000" probably wants transactions with a
+        //              concrete amount that satisfies the bound, not rows
+        //              where the amount can't be determined.
+        //   in_between: same as the single-sided comparators — missing values
+        //              are filtered out.
+        //
+        // Only the `not_equal` branch returns `true` here; everything else
+        // falls through to the `false` below.
+        return category.matchingOperator === 'not_equal';
+    }
+    if (category.field === 'amount') {
+        return matchAmount(Number(value), category);
+    }
+    const valueStr = value.toString();
+    const valueInList = category.values.some((v) => v.toString() === valueStr);
+    return category.matchingOperator === 'not_equal' ? !valueInList : valueInList;
+};
+/**
+ * TC-only equivalent of `applyAdvancedFiltersOnList`. Filters a list of
+ * `TransactionView` items against a `TransactionFilters` object using the
+ * AND/OR combination semantics from `categoryCombinationOperator`.
+ *
+ * Independent of `view/spendManagement` — keeps the TC filter pipeline cleanly
+ * inside the Expense Automation feature group.
+ */
+const applyTransactionFilters = (transactions, filters) => {
+    if (filters?.categories == null || filters.categories.length === 0) {
+        return transactions;
+    }
+    // Mirrors the predicate used by `getTransactionAppliedFiltersCount` on the
+    // webc side. A half-filled category — e.g. `in_between` with only the
+    // `min` typed — would otherwise survive the filter pass and produce zero
+    // matches because `Number("")` collapses to `0`, artificially emptying
+    // the list while editing. Skipping such categories keeps the filtered
+    // view stable while the user finishes typing.
+    const activeCategories = filters.categories.filter((c) => {
+        if (c.field == null || c.values.length === 0) {
+            return false;
+        }
+        if (c.field === 'amount' && c.matchingOperator === 'in_between') {
+            return (c.values.length >= 2 &&
+                String(c.values[0] ?? '').trim() !== '' &&
+                String(c.values[1] ?? '').trim() !== '');
+        }
+        return String(c.values[0] ?? '').trim() !== '';
+    });
+    if (activeCategories.length === 0) {
+        return transactions;
+    }
+    const op = filters.categoryCombinationOperator;
+    return transactions.filter((txn) => {
+        if (op === 'AND') {
+            return activeCategories.every((cat) => transactionMatchesCategory(txn, cat));
+        }
+        return activeCategories.some((cat) => transactionMatchesCategory(txn, cat));
+    });
+};
+exports.applyTransactionFilters = applyTransactionFilters;

package/lib/view/expenseAutomationView/types/transactionsViewState.d.ts

@@ -16,6 +16,7 @@ import { VendorBase } from '../../../entity/vendor/vendorState';
 import { ZeniAPIStatus } from '../../../responsePayload';
 import { ZeniDate } from '../../../zeniDayJS';
 import { EntityRecommendationKey } from '../../recommendation/recommendationState';
+import { TransactionFilters } from '../transactionFilterHelpers';
 import { TransactionDetailKey } from '../../transactionDetail/transactionDetailState';
 import { CompletedSubTab } from './completedSubTab';
 export declare const toTransactionsSortKey: (v: string) => "date" | "amount" | "vendor" | "project" | "category" | "class" | "payment_account" | "transaction_type" | "memo_and_receipt";
@@ -48,6 +49,7 @@ export interface TransactionCategorizationLineItemData extends TransactionLineBa
     transactionId: ID;
     account?: AccountBase;
     categorizationStatus?: CategorizationStatusType;
+    categoryClassRecommendationsFetchState?: FetchStateAndError;
     class?: ClassBase;
     customer?: CustomerBase;
     item?: ProductOrService;
@@ -93,6 +95,7 @@ export interface SupportedTransactionCategorization {
 }
 export declare const initialSupportedTransactionCategorization: SupportedTransactionCategorization;
 export interface TransactionsTabViewState extends FetchedState {
+    filters: TransactionFilters;
     markAsNotMiscategorizedStatus: FetchStateAndError;
     refreshStatus: FetchStateAndError;
     saveStatus: FetchStateAndError;

package/lib/view/recommendation/fetchEntityRecommendationsForLineUpdateEpic.d.ts

@@ -0,0 +1,9 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../reducer';
+import { ZeniAPI } from '../../zeniAPI';
+import { markCategoryClassRecommendationsCompletedForCategorization, markCategoryClassRecommendationsFailureForCategorization, markCategoryClassRecommendationsInProgressForCategorization, setEntityRecommendationForLineIdsForCategorization } from '../expenseAutomationView/reducers/transactionsViewReducer';
+import { markCategoryClassRecommendationsCompletedForTransactionDetail, markCategoryClassRecommendationsFailureForTransactionDetail, markCategoryClassRecommendationsInProgressForTransactionDetail, setEntityRecommendationForLineIdsForTransactionDetail } from '../transactionDetail/transactionDetailReducer';
+import { fetchEntityRecommendationsForLineUpdate } from './recommendationReducer';
+export type ActionType = ReturnType<typeof fetchEntityRecommendationsForLineUpdate> | ReturnType<typeof markCategoryClassRecommendationsInProgressForCategorization> | ReturnType<typeof markCategoryClassRecommendationsCompletedForCategorization> | ReturnType<typeof markCategoryClassRecommendationsFailureForCategorization> | ReturnType<typeof markCategoryClassRecommendationsInProgressForTransactionDetail> | ReturnType<typeof markCategoryClassRecommendationsCompletedForTransactionDetail> | ReturnType<typeof markCategoryClassRecommendationsFailureForTransactionDetail> | ReturnType<typeof setEntityRecommendationForLineIdsForCategorization> | ReturnType<typeof setEntityRecommendationForLineIdsForTransactionDetail>;
+export declare const fetchEntityRecommendationsForLineUpdateEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/recommendation/fetchEntityRecommendationsForLineUpdateEpic.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchEntityRecommendationsForLineUpdateEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const tenantSelector_1 = require("../../entity/tenant/tenantSelector");
+const transactionHelper_1 = require("../../entity/transaction/transactionHelper");
+const responsePayload_1 = require("../../responsePayload");
+const accountListSelector_1 = require("../accountList/accountListSelector");
+const transactionsViewReducer_1 = require("../expenseAutomationView/reducers/transactionsViewReducer");
+const transactionDetailReducer_1 = require("../transactionDetail/transactionDetailReducer");
+const recommendationHelper_1 = require("./recommendationHelper");
+const recommendationReducer_1 = require("./recommendationReducer");
+// Close the per-target groupBy bucket after this much idle time so inactive
+// groups don't accumulate forever (each group holds a Subject + a chain of
+// active subscribers; without a duration selector groupBy retains them for
+// the lifetime of the source observable, which is the lifetime of the app).
+// Picked at 60s to leave a generous window for re-fetches on the same
+// payee/transaction/line target while still bounding memory.
+const GROUP_INACTIVITY_TIMEOUT_MS = 60000;
+// Build the groupBy key. Same flow + same transaction + same line set
+// share a target so switchMap can cancel an in-flight prior fetch. Use
+// NUL (\u0000) as separator because it can never appear in transaction
+// or line ids (vs the `|` used in an earlier WIP which collides with
+// pipe-delimited synthetic ids).
+const SEPARATOR = '\u0000';
+const toGroupKey = (flowType, transactionId, lineIds) => `${flowType}${SEPARATOR}${transactionId}${SEPARATOR}${[...lineIds]
+    .sort((a, b) => a.localeCompare(b))
+    .join(SEPARATOR)}`;
+// Targeted recommendations fetch that drives the per-line skeleton, the
+// list-page row-checkbox uncheck/recheck, and the page-level Save
+// disable.
+//
+// Concurrency model:
+//   - groupBy by (flowType, transactionId, sorted lineIds) so distinct
+//     targets run in parallel.
+//   - inside each group, switchMap so a re-fetch on the SAME target
+//     cancels any prior in-flight request for that target.
+//   - groupBy duration selector closes idle groups to bound memory.
+const fetchEntityRecommendationsForLineUpdateEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(recommendationReducer_1.fetchEntityRecommendationsForLineUpdate.match), (0, operators_1.groupBy)((action) => toGroupKey(action.payload.flowType, action.payload.transactionDetails.transactionId.id, action.payload.transactionDetails.lineIds), undefined, (group$) => group$.pipe((0, operators_1.debounce)(() => (0, rxjs_1.timer)(GROUP_INACTIVITY_TIMEOUT_MS)))), (0, operators_1.mergeMap)((group$) => group$.pipe((0, operators_1.switchMap)((action) => {
+    const payload = action.payload;
+    const { transactionId, transaction, lineIds } = payload.transactionDetails;
+    const { entity, amount, isFetchCOT, isUncategorizedExpenseCategoryEnabled, } = payload;
+    // Synchronously emit the start arm so the per-line skeleton +
+    // row uncheck happen before the HTTP request begins. The
+    // discriminated-union payload narrows `payload.selectedTab` to
+    // a non-optional `TransactionsTab` inside the `'categorization'`
+    // branch, so no defensive fallthrough is needed.
+    const startAction = payload.flowType === 'categorization'
+        ? (0, transactionsViewReducer_1.markCategoryClassRecommendationsInProgressForCategorization)(payload.selectedTab, transactionId, lineIds)
+        : (0, transactionDetailReducer_1.markCategoryClassRecommendationsInProgressForTransactionDetail)(transactionId, lineIds);
+    const url = (0, recommendationHelper_1.buildRecommendationUrl)(zeniAPI.apiEndPoints.accountMicroServiceBaseUrl, entity, amount, payload.transactionDetails, isFetchCOT === true);
+    const httpStream$ = zeniAPI
+        .getJSON(url)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if (!(0, responsePayload_1.isSuccessResponse)(response) || response.data == null) {
+            return (0, rxjs_1.of)(payload.flowType === 'categorization'
+                ? (0, transactionsViewReducer_1.markCategoryClassRecommendationsFailureForCategorization)(payload.selectedTab, transactionId, lineIds, response.status)
+                : (0, transactionDetailReducer_1.markCategoryClassRecommendationsFailureForTransactionDetail)(transactionId, lineIds, response.status));
+        }
+        const recommendationWithCOTByLineId = (0, recommendationHelper_1.getRecommendationByLineIdWithCOTFromRecommendationPayloadWithCOT)(response.data.recommendations, lineIds);
+        // HTTP 200 with no per-line recommendations: NOT an error.
+        // Flip lines to Completed so the skeleton resolves and
+        // downstream UI can treat this as "we tried, nothing to
+        // apply".
+        if (recommendationWithCOTByLineId == null) {
+            return (0, rxjs_1.of)(payload.flowType === 'categorization'
+                ? (0, transactionsViewReducer_1.markCategoryClassRecommendationsCompletedForCategorization)(payload.selectedTab, transactionId, lineIds)
+                : (0, transactionDetailReducer_1.markCategoryClassRecommendationsCompletedForTransactionDetail)(transactionId, lineIds));
+        }
+        const transactionWithCOT = isFetchCOT === true
+            ? (0, transactionHelper_1.getTransactionWithCOTFromRecommendations)(transaction, recommendationWithCOTByLineId)
+            : (0, transactionHelper_1.getTransactionWithCOT)(transaction);
+        const uncategorizedIncomeExpense = (0, accountListSelector_1.getUncategorizedAccounts)(state$.value.accountState, state$.value.accountListState, 'accountList');
+        if (payload.flowType === 'categorization') {
+            return (0, rxjs_1.of)((0, transactionsViewReducer_1.setEntityRecommendationForLineIdsForCategorization)(payload.selectedTab, transactionId, transactionWithCOT, lineIds, entity, amount, recommendationWithCOTByLineId, uncategorizedIncomeExpense, isUncategorizedExpenseCategoryEnabled, (0, tenantSelector_1.getIsAccountingClassesEnabled)(state$.value)));
+        }
+        return (0, rxjs_1.of)((0, transactionDetailReducer_1.setEntityRecommendationForLineIdsForTransactionDetail)(transactionId, transactionWithCOT, lineIds, entity, amount, recommendationWithCOTByLineId, uncategorizedIncomeExpense));
+    }), (0, operators_1.catchError)((error) => {
+        const errorMessage = 'fetchEntityRecommendationsForLineUpdate failed: ' +
+            (error instanceof Error
+                ? error.message
+                : JSON.stringify(error));
+        const status = (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', errorMessage);
+        return (0, rxjs_1.of)(payload.flowType === 'categorization'
+            ? (0, transactionsViewReducer_1.markCategoryClassRecommendationsFailureForCategorization)(payload.selectedTab, transactionId, lineIds, status)
+            : (0, transactionDetailReducer_1.markCategoryClassRecommendationsFailureForTransactionDetail)(transactionId, lineIds, status));
+    }));
+    return (0, rxjs_1.concat)((0, rxjs_1.of)(startAction), httpStream$);
+}))));
+exports.fetchEntityRecommendationsForLineUpdateEpic = fetchEntityRecommendationsForLineUpdateEpic;

package/lib/view/recommendation/recommendationHelper.d.ts

@@ -1,8 +1,17 @@
 import { RecommendationPayload, RecommendationPayloadWithCOT } from '../../commonPayloadTypes/recommendationPayload';
 import { ID } from '../../commonStateTypes/common';
 import { Recommendation, RecommendationWithCOT } from '../../commonStateTypes/recommendationBase';
+import { Entity } from '../../entity/genericEntity/entity';
 import { RecommendationByLineId, RecommendationWithCOTByLineId } from '../../entity/transaction/stateTypes/transaction';
+import { SupportedTransaction } from '../../entity/transaction/transactionState';
 export declare const getRecommendationFromRecommendationPayload: (payload: RecommendationPayload[]) => Recommendation[] | undefined;
 export declare const getRecommendationByLineIdFromRecommendationPayload: (recommendationPayload: RecommendationPayload[], lineIds: ID[]) => RecommendationByLineId | undefined;
 export declare const getRecommendationWithCOTFromRecommendationPayloadWithCOT: (payload: RecommendationPayloadWithCOT[]) => RecommendationWithCOT[] | undefined;
+export declare const buildRecommendationUrl: (accountMicroServiceBaseUrl: string, entity: Entity, amount: number, transactionDetails: {
+    lineIds: ID[];
+    transaction: SupportedTransaction;
+    transactionId: {
+        id: string;
+    };
+}, isFetchCOT: boolean) => string;
 export declare const getRecommendationByLineIdWithCOTFromRecommendationPayloadWithCOT: (recommendationPayload: RecommendationPayloadWithCOT[], lineIds: ID[]) => RecommendationWithCOTByLineId | undefined;

package/lib/view/recommendation/recommendationHelper.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRecommendationByLineIdWithCOTFromRecommendationPayloadWithCOT = exports.getRecommendationWithCOTFromRecommendationPayloadWithCOT = exports.getRecommendationByLineIdFromRecommendationPayload = exports.getRecommendationFromRecommendationPayload = void 0;
+exports.getRecommendationByLineIdWithCOTFromRecommendationPayloadWithCOT = exports.buildRecommendationUrl = exports.getRecommendationWithCOTFromRecommendationPayloadWithCOT = exports.getRecommendationByLineIdFromRecommendationPayload = exports.getRecommendationFromRecommendationPayload = void 0;
 const transactionPayload_1 = require("../../entity/transaction/payloadTypes/transactionPayload");
+const transactionDetailState_1 = require("../transactionDetail/transactionDetailState");
 const getRecommendationFromRecommendationPayload = (payload) => {
     if (payload == null || payload.length === 0) {
         return undefined;
@@ -43,6 +44,35 @@ const getRecommendationWithCOTFromRecommendationPayloadWithCOT = (payload) => {
     return recommendations;
 };
 exports.getRecommendationWithCOTFromRecommendationPayloadWithCOT = getRecommendationWithCOTFromRecommendationPayloadWithCOT;
+// Pluralized URL segment for entity types. Mirrors the legacy
+// fetchEntityRecommendationsByTransactionIdEpic.toEntityTypeURL.
+const toEntityTypeUrlSegment = (entityType) => `${entityType}s`;
+// Build the recommendations URL for a single entity + transaction target.
+// Centralizes the URL shape so the legacy
+// fetchEntityRecommendationsByTransactionIdEpic and the new
+// fetchEntityRecommendationsForLineUpdateEpic stay in lockstep.
+const buildRecommendationUrl = (accountMicroServiceBaseUrl, entity, amount, transactionDetails, isFetchCOT) => {
+    const entityQuery = {
+        entity_name: entity.name,
+        entity_type: entity.type,
+    };
+    // Entity-id-null case: server expects entity_name / entity_type query
+    // instead of the {entityType}/{qboId}/recommendations path.
+    if (entity.qboId === entity.name) {
+        return `${accountMicroServiceBaseUrl}/1.0/recommendations?query=${encodeURIComponent(JSON.stringify(entityQuery))}`;
+    }
+    const query = {
+        amount,
+        transaction_id: (0, transactionDetailState_1.getActualTransactionID)(transactionDetails.transactionId.id),
+        transaction_type: transactionDetails.transaction.type,
+        line_ids: transactionDetails.lineIds,
+    };
+    if (isFetchCOT === true) {
+        query.include_cot = true;
+    }
+    return `${accountMicroServiceBaseUrl}/1.0/${toEntityTypeUrlSegment(entity.type)}/${entity.qboId}/recommendations?query=${encodeURIComponent(JSON.stringify(query))}`;
+};
+exports.buildRecommendationUrl = buildRecommendationUrl;
 const getRecommendationByLineIdWithCOTFromRecommendationPayloadWithCOT = (recommendationPayload, lineIds) => {
     if (recommendationPayload.length === 0) {
         return undefined;

package/lib/view/recommendation/recommendationReducer.d.ts

@@ -4,7 +4,26 @@ import { Entity, EntityType } from '../../entity/genericEntity/entity';
 import { TransactionID } from '../../entity/transaction/stateTypes/transaction';
 import { SupportedTransaction } from '../../entity/transaction/transactionState';
 import { ZeniAPIStatus } from '../../responsePayload';
+import { TransactionsTab } from '../expenseAutomationView/types/transactionsViewState';
 import { EntityRecommendationState } from './recommendationState';
+export type RecommendationLineUpdateFlowType = 'categorization' | 'detail';
+type FetchEntityRecommendationsForLineUpdateCommonPayload = {
+    amount: number;
+    entity: Entity;
+    transactionDetails: {
+        lineIds: ID[];
+        transaction: SupportedTransaction;
+        transactionId: TransactionID;
+    };
+    isFetchCOT?: boolean;
+    isUncategorizedExpenseCategoryEnabled?: boolean;
+};
+export type FetchEntityRecommendationsForLineUpdatePayload = (FetchEntityRecommendationsForLineUpdateCommonPayload & {
+    flowType: 'categorization';
+    selectedTab: TransactionsTab;
+}) | (FetchEntityRecommendationsForLineUpdateCommonPayload & {
+    flowType: 'detail';
+});
 export declare const initialState: EntityRecommendationState;
 export declare const fetchEntityRecommendationsByTransactionId: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[entity: Entity, amount: number, transactionDetails: {
     lineIds: ID[];
@@ -22,7 +41,7 @@ export declare const fetchEntityRecommendationsByTransactionId: import("@reduxjs
     isTransactionCategorizationFlow: any;
     isFetchCOT: any;
     isUncategorizedExpenseCategoryEnabled: boolean | undefined;
-}, "recommendation/fetchEntityRecommendationsByTransactionId", never, never>, fetchRecommendationByEntityName: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[entityName: string, entityType: EntityType], {
+}, "recommendation/fetchEntityRecommendationsByTransactionId", never, never>, fetchEntityRecommendationsForLineUpdate: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[args: FetchEntityRecommendationsForLineUpdatePayload], FetchEntityRecommendationsForLineUpdatePayload, "recommendation/fetchEntityRecommendationsForLineUpdate", never, never>, fetchRecommendationByEntityName: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[entityName: string, entityType: EntityType], {
     entityName: string;
     entityType: EntityType;
 }, "recommendation/fetchRecommendationByEntityName", never, never>, fetchRecommendationByEntityId: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[entityId: string, entityType: EntityType], {

package/lib/view/recommendation/recommendationReducer.js

@@ -1,7 +1,7 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearRecommendation = exports.indicateReadyToInitializeRecommendation = exports.updateRecommendationForEntityFailure = exports.updateRecommendationForEntity = exports.fetchRecommendationByEntityId = exports.fetchRecommendationByEntityName = exports.fetchEntityRecommendationsByTransactionId = exports.initialState = void 0;
+exports.clearRecommendation = exports.indicateReadyToInitializeRecommendation = exports.updateRecommendationForEntityFailure = exports.updateRecommendationForEntity = exports.fetchRecommendationByEntityId = exports.fetchRecommendationByEntityName = exports.fetchEntityRecommendationsForLineUpdate = exports.fetchEntityRecommendationsByTransactionId = exports.initialState = void 0;
 const toolkit_1 = require("@reduxjs/toolkit");
 const recommendationState_1 = require("./recommendationState");
 exports.initialState = {
@@ -37,6 +37,31 @@ const recommendation = (0, toolkit_1.createSlice)({
                 };
             },
         },
+        // Targeted recommendations fetch fired when the user changes the
+        // payee/customer on a single transaction line (or the JE sibling set
+        // for that change). Routed by `fetchEntityRecommendationsForLineUpdateEpic`
+        // which uses groupBy + switchMap to keep fetches for distinct targets
+        // running in parallel while same-target re-fetches still cancel each
+        // other. The flowType discriminator selects the categorization vs
+        // detail slice for the per-line In-Progress / Completed / Error state.
+        fetchEntityRecommendationsForLineUpdate: {
+            reducer(draft, action) {
+                const { entity } = action.payload;
+                const key = (0, recommendationState_1.getEntityRecommendationKey)(entity.type, entity.id);
+                // Unconditional flip to In-Progress; the previous variant only
+                // seeded when missing, which left stale fetchStates when a prior
+                // fetch had already populated the entity entry.
+                draft.recommendationByEntity[key] = {
+                    ...(draft.recommendationByEntity[key] ??
+                        recommendationState_1.initialEntityRecommendationState),
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(args) {
+                return { payload: args };
+            },
+        },
         fetchRecommendationByEntityName: {
             reducer(draft, action) {
                 const { entityName, entityType } = action.payload;
@@ -115,7 +140,7 @@ const recommendation = (0, toolkit_1.createSlice)({
         },
     },
 });
-_a = recommendation.actions, exports.fetchEntityRecommendationsByTransactionId = _a.fetchEntityRecommendationsByTransactionId, exports.fetchRecommendationByEntityName = _a.fetchRecommendationByEntityName, exports.fetchRecommendationByEntityId = _a.fetchRecommendationByEntityId, exports.updateRecommendationForEntity = _a.updateRecommendationForEntity, exports.updateRecommendationForEntityFailure = _a.updateRecommendationForEntityFailure, exports.indicateReadyToInitializeRecommendation = _a.indicateReadyToInitializeRecommendation, exports.clearRecommendation = _a.clearRecommendation;
+_a = recommendation.actions, exports.fetchEntityRecommendationsByTransactionId = _a.fetchEntityRecommendationsByTransactionId, exports.fetchEntityRecommendationsForLineUpdate = _a.fetchEntityRecommendationsForLineUpdate, exports.fetchRecommendationByEntityName = _a.fetchRecommendationByEntityName, exports.fetchRecommendationByEntityId = _a.fetchRecommendationByEntityId, exports.updateRecommendationForEntity = _a.updateRecommendationForEntity, exports.updateRecommendationForEntityFailure = _a.updateRecommendationForEntityFailure, exports.indicateReadyToInitializeRecommendation = _a.indicateReadyToInitializeRecommendation, exports.clearRecommendation = _a.clearRecommendation;
 exports.default = recommendation.reducer;
 const doUpdateRecommendationForEntity = (draft, entityId, entityType, payload) => {
     const key = (0, recommendationState_1.getEntityRecommendationKey)(entityType, entityId);

package/lib/view/spendManagement/billPay/billList/billListState.d.ts

@@ -45,7 +45,7 @@ export interface BillPayFilters {
 }
 export interface BillPayFilterCategory {
     field: BillListViewFilterCategoryField;
-    matchingOperator: 'equal' | 'not-equal';
+    matchingOperator: 'equal' | 'not_equal';
     values: (string | ZeniDate)[];
     valuesCombinationOperator: 'ANY';
 }

package/lib/view/spendManagement/chargeCards/chargeCardPaymentHistory/chargeCardPaymentHistory.d.ts

@@ -36,7 +36,7 @@ export interface PaymentHistoryFilters {
 }
 export interface PaymentHistoryFilterCategory {
     field: PaymentHistoryFilterCategoryField;
-    matchingOperator: 'equal' | 'not-equal';
+    matchingOperator: 'equal' | 'not_equal';
     values: (string | ZeniDate)[];
     valuesCombinationOperator: 'ANY';
 }

package/lib/view/spendManagement/reimbursement/remiListView/remiListState.d.ts

@@ -46,7 +46,7 @@ export interface ReimbursementFilters {
 }
 export interface ReimbursementFilterCategory {
     field: RemiListViewFilterCategoryField;
-    matchingOperator: 'equal' | 'not-equal';
+    matchingOperator: 'equal' | 'not_equal';
     values: (string | ZeniDate)[];
     valuesCombinationOperator: 'ANY';
 }

package/lib/view/spendManagement/spendManagementFilterHelpers.d.ts

@@ -1,3 +1,4 @@
+import { CategoryCombinationOperator, FilterCategoryType } from '../../commonStateTypes/filterPrimitives';
 import { TimePeriod } from '../../commonStateTypes/timePeriod';
 import { UserRoleType } from '../../entity/userRole/userRoleType';
 import { RootState } from '../../reducer';
@@ -12,12 +13,20 @@ import { ReimbursementView } from './reimbursement/remiListView/remiListSelector
 import { ReimbursementFilters, RemiListViewFilterCategoryField } from './reimbursement/remiListView/remiListState';
 export type SpendManagementFiltersType = BillPayFilters | ReimbursementFilters | TaskListFilters | PaymentHistoryFilters;
 export type SpendManagementFilterEntityType = 'bill_pay' | 'reimbursement' | 'task_management' | 'charge_card_payment_history';
-export type FilterCategoryType = 'searchAutocomplete' | 'user' | 'dateRange' | 'numberRange' | 'dropdown';
+/**
+ * Re-exported here so consumers of `spendManagementFilterHelpers` keep
+ * their existing import path stable after the primitives moved to
+ * `commonStateTypes/filterPrimitives`. Downstream files (`taskList`,
+ * `remiListState`, `chargeCardPaymentHistory`, `billListState`) and the
+ * CES barrel still pull `CategoryCombinationOperator` / `FilterCategoryType`
+ * from this module — the source of truth is upstream but the surface is
+ * unchanged.
+ */
+export type { CategoryCombinationOperator, FilterCategoryType };
 export interface MatchingOperatorDropdownOption {
     label: 'is' | 'is not';
-    value: 'equal' | 'not-equal';
+    value: 'equal' | 'not_equal';
 }
-export type CategoryCombinationOperator = 'AND' | 'OR';
 export interface BillPayFilterCategoryDropdownOption {
     value: BillListViewFilterCategoryField;
     multiple?: boolean;

package/lib/view/spendManagement/spendManagementFilterHelpers.js

@@ -14,6 +14,8 @@ const helpers_1 = require("./helpers");
 const remiListSelector_1 = require("./reimbursement/remiListView/remiListSelector");
 const remiListState_1 = require("./reimbursement/remiListView/remiListState");
 //filters items against filter values representing a range. ex: date (from-to), amount(1k<-->5k)
+// Spend Management uses only equal/not_equal — TC amount operators
+// (inBetween, lessThan, greaterThan) live in the TC filter pipeline.
 const filterItemOnRangeCategoryType = (valueForItem, currentFilter) => {
     let doesItemFallInValueRange = false;
     const filterField = currentFilter.field;
@@ -47,7 +49,7 @@ const filterItemOnCategoriesWithSingleValue = (categoryValue, currentFilter, ran
         return filterItemOnRangeCategoryType(categoryValue, currentFilter);
     }
     // if filter category is not rangeType
-    if (currentFilter.matchingOperator === 'not-equal') {
+    if (currentFilter.matchingOperator === 'not_equal') {
         return currentFilter.values.indexOf(categoryValue.toString()) === -1;
     }
     return currentFilter.values.indexOf(categoryValue.toString()) > -1;
@@ -121,7 +123,7 @@ const applyAdvancedFiltersOnList = (entity, allItems, filters, filteredItems = [
                     ? getCategoryValueForTaskList(key, item)
                     : getCategoryValueForPaymentHistory(key, item);
         if (categoryValue == null) {
-            if (currentFilter.matchingOperator === 'not-equal') {
+            if (currentFilter.matchingOperator === 'not_equal') {
                 return true;
             }
             return false;

package/lib/view/subscriptionView/subscriptionViewSelector.js

@@ -217,7 +217,7 @@ const applyAdvancedFiltersOnCompaniesList = (allCompanies, filters, filteredComp
         const key = currentFilter.field;
         const categoryValue = getCategoryValueForCompany(key, company);
         if (categoryValue == null) {
-            if (currentFilter.matchingOperator === 'not-equal') {
+            if (currentFilter.matchingOperator === 'not_equal') {
                 return true;
             }
             return false;