@zeniai/client-epic-state 5.2.62-beta0MM → 5.2.62-beta1KB

package/lib/view/transactionDetail/createTransaction/createTransactionPayload.d.ts

@@ -0,0 +1,82 @@
+import { ID } from '../../../commonStateTypes/common';
+import { TransactionPayload } from '../../../entity/transaction/payloadTypes/transactionPayload';
+import { ZeniAPIResponse } from '../../../responsePayload';
+import { RootState } from '../../../rootStateTypes';
+import { CreateTransactionLocalData } from './createTransactionState';
+/**
+ * Wire types for POST /1.0/transactions/manage.
+ *
+ * Two things here are easy to get wrong and are deliberately explicit:
+ *
+ * 1. `line_detail_type` is snake_case. The PascalCase strings in the backend are Python
+ *    constant NAMES; ZENI_LINE_DETAIL_TYPE_TO_QBO_LINE_DETAIL_TYPE_MAP converts them for the
+ *    body the backend sends on to QuickBooks, never for ours.
+ * 2. The reference number uses two different keys depending on the QBO entity. check and
+ *    expense are Purchases and take `document_number`; everything else takes `document_id`.
+ */
+export interface CreateTransactionAccountPayload {
+    qbo_id: ID;
+    account_name?: string;
+}
+export interface CreateTransactionLineDetailPayload {
+    account?: CreateTransactionAccountPayload;
+    class?: Record<string, never> | {
+        qbo_id: ID;
+    };
+    /**
+     * journal_entry only, and it MUST sit inside line_detail. The write validator's docstring
+     * warns that a misplaced posting_type is silently dropped and then rejected by QBO.
+     */
+    posting_type?: 'credit' | 'debit';
+    vendor?: {
+        qbo_id: ID;
+    };
+}
+export interface CreateTransactionLinePayload {
+    amount: number;
+    line_detail: CreateTransactionLineDetailPayload;
+    line_detail_type: 'account_based_expense_line_detail' | 'item_based_expense_line_detail' | 'journal_entry_line_detail';
+    line_description?: string;
+}
+export interface CreateTransactionRemitToAddressPayload {
+    city?: string;
+    country?: string;
+    line1?: string;
+    postal_code?: string;
+    state?: string;
+}
+export interface CreateTransactionRequest extends Record<string, unknown> {
+    transaction_date: string;
+    transaction_type: string;
+    /** journal_entry reference number. */
+    document_id?: string;
+    /** check / credit_card_credit reference number (QBO Purchase). */
+    document_number?: string;
+    from_account_id?: ID;
+    /** credit_card_credit is modelled as a Purchase with Credit: true. */
+    is_credit?: boolean;
+    lines?: CreateTransactionLinePayload[];
+    payment_type?: string;
+    print_status?: string;
+    qbo_account_id?: ID;
+    remit_to_address?: CreateTransactionRemitToAddressPayload;
+    to_account_id?: ID;
+    total_amount?: number;
+    transaction_memo?: string;
+    vendor_id?: ID;
+}
+/**
+ * The create endpoint writes to QBO and returns the created entity; Zeni's own mirror is
+ * populated by the delta sync that runs afterwards, so this response is the only view of the
+ * new transaction the client gets immediately.
+ */
+export interface CreateTransactionPayload {
+    transactions: TransactionPayload[];
+}
+export type CreateTransactionResponse = ZeniAPIResponse<CreateTransactionPayload>;
+/**
+ * Builds the request body for one transaction type. One branch per type rather than a shared
+ * body with optional keys, because the types genuinely diverge -- transfer carries no lines at
+ * all, and journal_entry carries no header account.
+ */
+export declare const prepareCreateTransactionPayload: (state: RootState, localData: CreateTransactionLocalData) => CreateTransactionRequest;

package/lib/view/transactionDetail/createTransaction/createTransactionPayload.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareCreateTransactionPayload = void 0;
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const accountSelector_1 = require("../../../entity/account/accountSelector");
+const classSelector_1 = require("../../../entity/class/classSelector");
+const vendorSelector_1 = require("../../../entity/vendor/vendorSelector");
+const toRemitToAddressPayload = (address) => {
+    if (address == null) {
+        return undefined;
+    }
+    return {
+        line1: address.line1,
+        city: address.city,
+        state: address.state,
+        postal_code: address.postalCode,
+        country: address.country,
+    };
+};
+const toLinePayload = (state, line, transactionType) => {
+    const lineDetail = {};
+    if (line.accountQboId != null) {
+        lineDetail.account = {
+            qbo_id: line.accountQboId,
+            account_name: line.accountName,
+        };
+    }
+    // An empty object is what the confirmed payloads send when no class is chosen; sending the
+    // key with a qbo_id only once one is picked.
+    const classQboId = toQboClassId(state, line.classId);
+    lineDetail.class = classQboId != null ? { qbo_id: classQboId } : {};
+    if (transactionType === 'journal_entry') {
+        lineDetail.posting_type = line.postingType;
+        if (line.vendorQboId != null) {
+            lineDetail.vendor = { qbo_id: line.vendorQboId };
+        }
+    }
+    return {
+        // The backend rejects a bool here, so this is always coerced to a number.
+        amount: line.amount?.amount ?? 0,
+        line_description: line.lineDescription,
+        line_detail_type: transactionType === 'journal_entry'
+            ? 'journal_entry_line_detail'
+            : 'account_based_expense_line_detail',
+        line_detail: lineDetail,
+    };
+};
+/** Resolves a Zeni account id to the QBO id the endpoint expects. */
+const toQboAccountId = (state, accountId) => {
+    if (accountId == null) {
+        return undefined;
+    }
+    return ((0, accountSelector_1.getAccountBase)(state.accountState, accountId, 'account_list')?.qboId ??
+        accountId);
+};
+/** Resolves a Zeni class id (`class_<uuid>`) to the QBO id `line_detail.class.qbo_id` expects. */
+const toQboClassId = (state, classId) => {
+    if (classId == null) {
+        return undefined;
+    }
+    return ((0, classSelector_1.getClassById)(state.classState, { classId, reportId: 'class_list' })
+        ?.qboId ?? classId);
+};
+/** Resolves a Zeni vendor id to its QBO id -- `vendor_id` on the wire is a QBO id. */
+const toQboVendorId = (state, vendorId) => {
+    if (vendorId == null) {
+        return undefined;
+    }
+    return (0, vendorSelector_1.getVendorByVendorId)(state.vendorState, vendorId)?.qboId ?? vendorId;
+};
+/**
+ * Builds the request body for one transaction type. One branch per type rather than a shared
+ * body with optional keys, because the types genuinely diverge -- transfer carries no lines at
+ * all, and journal_entry carries no header account.
+ */
+const prepareCreateTransactionPayload = (state, localData) => {
+    const { transactionType } = localData;
+    const base = {
+        transaction_type: transactionType,
+        transaction_date: localData.transactionDate?.format(timePeriod_1.DEFAULT_DATE_FORMAT) ?? '',
+        transaction_memo: localData.transactionMemo,
+    };
+    if (transactionType === 'transfer') {
+        return {
+            ...base,
+            from_account_id: toQboAccountId(state, localData.fromAccountId),
+            to_account_id: toQboAccountId(state, localData.toAccountId),
+            total_amount: localData.totalAmount?.amount ?? 0,
+        };
+    }
+    const lines = localData.lines.map((line) => toLinePayload(state, line, transactionType));
+    if (transactionType === 'journal_entry') {
+        return {
+            ...base,
+            document_id: localData.documentId,
+            lines,
+        };
+    }
+    const purchaseBase = {
+        ...base,
+        payment_type: localData.paymentType,
+        qbo_account_id: toQboAccountId(state, localData.qboAccountId),
+        vendor_id: toQboVendorId(state, localData.vendorId),
+        lines,
+    };
+    if (transactionType === 'check') {
+        return {
+            ...purchaseBase,
+            document_number: localData.documentNumber,
+            print_status: localData.printStatus,
+            remit_to_address: toRemitToAddressPayload(localData.remitToAddress),
+        };
+    }
+    if (transactionType === 'credit_card_credit') {
+        // credit_card_credit is not in the backend's SUPPORTED_TRANSACTION_WRITE_TYPES. QBO models
+        // it as a Purchase with Credit: true and qbo_purchase.py already honours is_credit for
+        // card payment types, so this sends `expense` + is_credit rather than a type the validator
+        // rejects outright. Confirm with backend before enabling the menu item.
+        return {
+            ...purchaseBase,
+            transaction_type: 'expense',
+            is_credit: true,
+            document_number: localData.documentNumber,
+        };
+    }
+    return purchaseBase;
+};
+exports.prepareCreateTransactionPayload = prepareCreateTransactionPayload;

package/lib/view/transactionDetail/createTransaction/createTransactionSelector.d.ts

@@ -0,0 +1,40 @@
+import { FetchState, FetchStateAndError } from '../../../commonStateTypes/common';
+import { Recommendation } from '../../../commonStateTypes/recommendationBase';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { AccountBase } from '../../../entity/account/accountState';
+import { TransactionID } from '../../../entity/transaction/stateTypes/transactionID';
+import { Vendor } from '../../../entity/vendor/vendorState';
+import { RootState } from '../../../rootStateTypes';
+import { NestedAccountHierarchyForReport } from '../../../commonStateTypes/accountView/nestedAccountID';
+import { NestedClassHierarchyForReport } from '../../../commonStateTypes/classesView/nestedClassID';
+import { CreatableTransactionType, CreateTransactionLocalData } from './createTransactionState';
+export interface CreateTransactionView extends SelectorView {
+    /**
+     * COA and class trees for the header account and the line dropdowns. The hierarchies rather
+     * than flat lists, because the create page builds its grouped "Recommended" / "All" options
+     * with the same helpers the detail page uses.
+     */
+    accountListNestedAccountHierarchy: NestedAccountHierarchyForReport[];
+    classListNestedAccountHierarchy: NestedClassHierarchyForReport[];
+    createStatus: FetchStateAndError;
+    localData: CreateTransactionLocalData;
+    transactionType: CreatableTransactionType;
+    /** Populated for transfer only; the COA would offer ineligible accounts. */
+    transferAccountsList: AccountBase[];
+    vendorList: Vendor[];
+    createdTransactionId?: TransactionID;
+}
+export declare const getCreateTransactionLocalData: (state: RootState, transactionType: CreatableTransactionType) => CreateTransactionLocalData;
+export declare const getCreateTransactionStatus: (state: RootState) => FetchStateAndError;
+/**
+ * The vendor recommendations backing the category/class dropdowns on the create page.
+ *
+ * No new state field is needed for this: getRecommendationsForEntity already returns
+ * fetchState alongside recommendations, so composing it here is enough for the page to show a
+ * line skeleton and hold Save while a fetch is in flight.
+ */
+export declare const getCreateTransactionVendorRecommendations: (state: RootState, vendorQboId?: string) => {
+    fetchState: FetchState;
+    recommendations?: Recommendation[];
+};
+export declare const getCreateTransactionView: (state: RootState, transactionType: CreatableTransactionType) => CreateTransactionView;

package/lib/view/transactionDetail/createTransaction/createTransactionSelector.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCreateTransactionView = exports.getCreateTransactionVendorRecommendations = exports.getCreateTransactionStatus = exports.getCreateTransactionLocalData = void 0;
+const accountListSelector_1 = require("../../accountList/accountListSelector");
+const classListSelector_1 = require("../../classList/classListSelector");
+const createTransferEntrySelector_1 = require("../../createTransferEntry/createTransferEntrySelector");
+const recommendationSelector_1 = require("../../recommendation/recommendationSelector");
+const getCreateTransactionLocalData = (state, transactionType) => state.transactionDetailState.createTransactionsState.newTransactionState[transactionType];
+exports.getCreateTransactionLocalData = getCreateTransactionLocalData;
+const getCreateTransactionStatus = (state) => state.transactionDetailState.createTransactionsState.createStatus;
+exports.getCreateTransactionStatus = getCreateTransactionStatus;
+/**
+ * The vendor recommendations backing the category/class dropdowns on the create page.
+ *
+ * No new state field is needed for this: getRecommendationsForEntity already returns
+ * fetchState alongside recommendations, so composing it here is enough for the page to show a
+ * line skeleton and hold Save while a fetch is in flight.
+ */
+const getCreateTransactionVendorRecommendations = (state, vendorQboId) => {
+    if (vendorQboId == null || vendorQboId === '') {
+        return { fetchState: 'Not-Started' };
+    }
+    const view = (0, recommendationSelector_1.getRecommendationsForEntity)(state, vendorQboId, 'vendor');
+    return {
+        fetchState: view.fetchState,
+        recommendations: view.recommendations,
+    };
+};
+exports.getCreateTransactionVendorRecommendations = getCreateTransactionVendorRecommendations;
+const getCreateTransactionView = (state, transactionType) => {
+    const { accountListState, classListState, transactionDetailState, vendorState, } = state;
+    const { createTransactionsState } = transactionDetailState;
+    return {
+        transactionType,
+        localData: createTransactionsState.newTransactionState[transactionType],
+        createStatus: createTransactionsState.createStatus,
+        createdTransactionId: createTransactionsState.createdTransactionId,
+        vendorList: Object.values(vendorState.vendorByID),
+        accountListNestedAccountHierarchy: (0, accountListSelector_1.getNestedAccountListHierarchy)(accountListState, 'accountList'),
+        classListNestedAccountHierarchy: (0, classListSelector_1.getNestedClassListHierarchy)(classListState),
+        transferAccountsList: transactionType === 'transfer'
+            ? (0, createTransferEntrySelector_1.getResolvedTransferAccounts)(state).transferAccountsList
+            : [],
+        fetchState: createTransactionsState.createStatus.fetchState,
+        error: createTransactionsState.createStatus.error,
+    };
+};
+exports.getCreateTransactionView = getCreateTransactionView;

package/lib/view/transactionDetail/createTransaction/createTransactionState.d.ts

@@ -0,0 +1,81 @@
+import { Amount } from '../../../commonStateTypes/amount';
+import { ID } from '../../../commonStateTypes/common';
+import { RecommendationWithCOT } from '../../../commonStateTypes/recommendationBase';
+import { PaymentType } from '../../../entity/transaction/stateTypes/paymentType';
+import { PrintStatus } from '../../../entity/transaction/stateTypes/printStatus';
+import { TransactionCategory, TransactionType } from '../../../entity/transaction/stateTypes/transactionType';
+import { ZeniDate } from '../../../zeniDayJS';
+/**
+ * The transaction types the Create Transaction flow can originate. A narrow subset of
+ * TransactionType -- everything else is read-only and arrives via sync.
+ */
+export declare const ALL_CREATABLE_TRANSACTION_TYPES: readonly ["expense", "check", "credit_card_credit", "transfer", "journal_entry"];
+export type CreatableTransactionType = (typeof ALL_CREATABLE_TRANSACTION_TYPES)[number];
+/**
+ * The wire shape the create endpoint expects for a check's remit-to address. Deliberately not
+ * the CES AddressPayload, which carries `street: string[]` plus address_id/create_time/
+ * update_time that the create endpoint does not accept.
+ */
+export interface RemitToAddress {
+    city?: string;
+    country?: string;
+    line1?: string;
+    postalCode?: string;
+    state?: string;
+}
+export interface CreateTransactionLineLocalData {
+    /** Client-side row key only -- never sent. */
+    id: string;
+    accountName?: string;
+    accountQboId?: ID;
+    amount?: Amount;
+    classId?: ID;
+    /**
+     * Tracked per field, not per line. A line can have a hand-picked account and a prefilled
+     * class at the same time, and clearing the vendor must undo only the latter.
+     */
+    isAccountPreFilled?: boolean;
+    isClassPreFilled?: boolean;
+    lineDescription?: string;
+    /** journal_entry only. */
+    postingType?: TransactionCategory;
+    projectId?: ID;
+    /**
+     * Backs the "Recommended" group in the category/class dropdowns. Carries the COT shape the
+     * line-table row already expects, with empty cot/reasoning -- chain-of-thought needs an
+     * existing transaction, which a create does not have.
+     */
+    recommendationsWithCOT?: RecommendationWithCOT[];
+    /** journal_entry only -- the per-line name. */
+    vendorQboId?: ID;
+}
+export interface CreateTransactionLocalData {
+    /** Empty for transfer, which has no lines at all. */
+    lines: CreateTransactionLineLocalData[];
+    transactionType: CreatableTransactionType;
+    /** journal_entry reference number. */
+    documentId?: string;
+    /** check / credit_card_credit reference number. */
+    documentNumber?: string;
+    /** transfer */
+    fromAccountId?: ID;
+    paymentType?: PaymentType;
+    /** check only. */
+    printStatus?: PrintStatus;
+    qboAccountId?: ID;
+    /** check only. */
+    remitToAddress?: RemitToAddress;
+    toAccountId?: ID;
+    /** transfer only -- every other type derives its total from the lines. */
+    totalAmount?: Amount;
+    transactionDate?: ZeniDate;
+    transactionMemo?: string;
+    vendorId?: ID;
+}
+export type CreateTransactionLocalDataByType = Record<CreatableTransactionType, CreateTransactionLocalData>;
+/**
+ * Type-level guarantee that CreatableTransactionType stays a subset of TransactionType. If a
+ * value is ever added here that the entity layer does not know about, this line fails to
+ * compile rather than failing at the payload boundary.
+ */
+export type CreatableTransactionTypeIsTransactionType = CreatableTransactionType extends TransactionType ? true : never;

package/lib/view/transactionDetail/createTransaction/createTransactionState.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_CREATABLE_TRANSACTION_TYPES = void 0;
+/**
+ * The transaction types the Create Transaction flow can originate. A narrow subset of
+ * TransactionType -- everything else is read-only and arrives via sync.
+ */
+exports.ALL_CREATABLE_TRANSACTION_TYPES = [
+    'expense',
+    'check',
+    'credit_card_credit',
+    'transfer',
+    'journal_entry',
+];

package/lib/view/transactionDetail/createTransaction/epics/createTransactionEpic.d.ts

@@ -0,0 +1,9 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { updateTransaction } from '../../../../entity/transaction/transactionReducer';
+import { RootState } from '../../../../rootStateTypes';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { createTransaction, createTransactionSuccessOrFailure, initializeTransactionDetailLocalData, resetCreateTransactionLocalData } from '../../transactionDetailReducer';
+export type ActionType = ReturnType<typeof createTransaction> | ReturnType<typeof createTransactionSuccessOrFailure> | ReturnType<typeof resetCreateTransactionLocalData> | ReturnType<typeof initializeTransactionDetailLocalData> | ReturnType<typeof updateTransaction> | ReturnType<typeof openSnackbar>;
+export declare const createTransactionEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/transactionDetail/createTransaction/epics/createTransactionEpic.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransactionEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const snackbarReducer_1 = require("../../../../entity/snackbar/snackbarReducer");
+const transactionIDPayload_1 = require("../../../../entity/transaction/payloadTypes/transactionIDPayload");
+const transactionReducer_1 = require("../../../../entity/transaction/transactionReducer");
+const responsePayload_1 = require("../../../../responsePayload");
+const transactionDetailReducer_1 = require("../../transactionDetailReducer");
+const transactionDetailState_1 = require("../../transactionDetailState");
+const createTransactionPayload_1 = require("../createTransactionPayload");
+const failureActions = (message, status) => [
+    (0, transactionDetailReducer_1.createTransactionSuccessOrFailure)('Error', undefined, status),
+    (0, snackbarReducer_1.openSnackbar)({
+        messageSection: 'create_transaction',
+        messageText: 'failed',
+        type: 'error',
+        // This variable is how the server's own message reaches the user. Per-type required
+        // fields live in the QBO entity classes, so a rejection comes back as a QBO error with no
+        // field name -- the message text is the only useful content we get.
+        variables: [{ variableName: '_api-error_', variableValue: message }],
+    }),
+];
+const createTransactionEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(transactionDetailReducer_1.createTransaction.match), (0, operators_1.mergeMap)((action) => {
+    const { transactionType } = action.payload;
+    const state = state$.value;
+    const localData = state.transactionDetailState.createTransactionsState
+        .newTransactionState[transactionType];
+    const payload = (0, createTransactionPayload_1.prepareCreateTransactionPayload)(state, localData);
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/transactions/manage`, payload)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if (!(0, responsePayload_1.isSuccessResponse)(response) || response.data == null) {
+            return (0, rxjs_1.from)(failureActions(response.status.message, response.status));
+        }
+        const created = response.data.transactions[0];
+        if (created == null) {
+            return (0, rxjs_1.from)(failureActions('Transaction was created but returned no details.', (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Create transaction returned an empty transactions array.')));
+        }
+        const newTransactionId = (0, transactionIDPayload_1.toTransactionID)(created);
+        // The write is QBO-only: transaction_write_handler.py touches no local storage, and
+        // Zeni's mirror is populated by the delta sync that runs afterwards. Refetching here
+        // would come back without the new row, so the 200 body is inserted optimistically
+        // instead -- the same approach createTransferEntryEpic takes.
+        return (0, rxjs_1.from)([
+            (0, transactionReducer_1.updateTransaction)((0, transactionDetailState_1.getTransactionDetailKey)(newTransactionId), created),
+            (0, transactionDetailReducer_1.initializeTransactionDetailLocalData)({
+                transactionId: newTransactionId,
+                vendorId: created.vendor_id ?? undefined,
+            }),
+            (0, transactionDetailReducer_1.createTransactionSuccessOrFailure)('Completed', newTransactionId),
+            (0, transactionDetailReducer_1.resetCreateTransactionLocalData)(transactionType),
+            (0, snackbarReducer_1.openSnackbar)({
+                messageSection: 'create_transaction',
+                messageText: 'success',
+                type: 'success',
+            }),
+        ]);
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.from)(failureActions(JSON.stringify(error), (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', `Create Transaction REST API call errored out ${JSON.stringify(error)}`)))));
+}));
+exports.createTransactionEpic = createTransactionEpic;

package/lib/view/transactionDetail/createTransaction/epics/fetchVendorRecommendationsForCreateTransactionEpic.d.ts

@@ -0,0 +1,20 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../../rootStateTypes';
+import { fetchRecommendationByEntityId, fetchRecommendationByEntityName, indicateReadyToInitializeRecommendation } from '../../../recommendation/recommendationReducer';
+import { clearRecommendationsForCreateTransactionLines, fetchVendorRecommendationsForCreateTransaction, setRecommendationsForCreateTransactionLines } from '../../transactionDetailReducer';
+export type ActionType = ReturnType<typeof fetchVendorRecommendationsForCreateTransaction> | ReturnType<typeof setRecommendationsForCreateTransactionLines> | ReturnType<typeof clearRecommendationsForCreateTransactionLines> | ReturnType<typeof fetchRecommendationByEntityId> | ReturnType<typeof fetchRecommendationByEntityName> | ReturnType<typeof indicateReadyToInitializeRecommendation>;
+/**
+ * On vendor select, populates the category/class dropdowns from that vendor's recommendations.
+ *
+ * Deliberately NOT the detail page's fetchEntityRecommendationsForLineUpdate: that one sends
+ * transaction_id / line_ids and writes into transactionDetailById[key], which no-ops when the
+ * entry does not exist. A transaction being created has neither.
+ *
+ * Two differences from the reimbursement epic this is modelled on:
+ *  1. the wait filters on the matching entityIdOrName before take(1), so an unrelated
+ *     recommendation landing first cannot satisfy this request, and
+ *  2. switchMap, so changing the vendor again cancels the earlier wait rather than letting a
+ *     stale result overwrite the newer vendor's prefill.
+ */
+export declare const fetchVendorRecommendationsForCreateTransactionEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>) => Observable<ActionType>;

package/lib/view/transactionDetail/createTransaction/epics/fetchVendorRecommendationsForCreateTransactionEpic.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchVendorRecommendationsForCreateTransactionEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const tenantSelector_1 = require("../../../../entity/tenant/tenantSelector");
+const recommendationReducer_1 = require("../../../recommendation/recommendationReducer");
+const recommendationSelector_1 = require("../../../recommendation/recommendationSelector");
+const transactionDetailReducer_1 = require("../../transactionDetailReducer");
+/**
+ * The entity-level recommendation fetch, keyed by whatever identifier the endpoint can resolve.
+ *
+ * A vendor that has not synced to QBO carries `qboId === name`; the id endpoint has nothing to
+ * look up in that case, so the by-name variant is used instead.
+ */
+const toEntityIdOrName = (entity) => entity.qboId !== '' && entity.qboId !== entity.name
+    ? entity.qboId
+    : entity.name;
+const isUnsyncedVendor = (entity) => entity.qboId === '' || entity.qboId === entity.name;
+/**
+ * On vendor select, populates the category/class dropdowns from that vendor's recommendations.
+ *
+ * Deliberately NOT the detail page's fetchEntityRecommendationsForLineUpdate: that one sends
+ * transaction_id / line_ids and writes into transactionDetailById[key], which no-ops when the
+ * entry does not exist. A transaction being created has neither.
+ *
+ * Two differences from the reimbursement epic this is modelled on:
+ *  1. the wait filters on the matching entityIdOrName before take(1), so an unrelated
+ *     recommendation landing first cannot satisfy this request, and
+ *  2. switchMap, so changing the vendor again cancels the earlier wait rather than letting a
+ *     stale result overwrite the newer vendor's prefill.
+ */
+const fetchVendorRecommendationsForCreateTransactionEpic = (actions$, state$) => actions$.pipe((0, operators_1.filter)(transactionDetailReducer_1.fetchVendorRecommendationsForCreateTransaction.match), (0, operators_1.switchMap)((action) => {
+    const { transactionType, entity, lineIds } = action.payload;
+    if (entity == null) {
+        return (0, rxjs_1.of)((0, transactionDetailReducer_1.clearRecommendationsForCreateTransactionLines)(transactionType, lineIds));
+    }
+    const entityIdOrName = toEntityIdOrName(entity);
+    const state = state$.value;
+    const isAccountingClassesEnabled = (0, tenantSelector_1.getIsAccountingClassesEnabled)(state);
+    const cached = (0, recommendationSelector_1.getRecommendationsForEntity)(state, entityIdOrName, 'vendor');
+    // Cache hit: apply straight away, no request and no wait.
+    if (cached.fetchState === 'Completed') {
+        return (0, rxjs_1.of)((0, transactionDetailReducer_1.setRecommendationsForCreateTransactionLines)(transactionType, lineIds, cached.recommendations ?? [], isAccountingClassesEnabled));
+    }
+    const waitThenApply = actions$.pipe((0, operators_1.filter)(recommendationReducer_1.indicateReadyToInitializeRecommendation.match), (0, operators_1.filter)((ready) => ready.payload.entityType === 'vendor' &&
+        ready.payload.entityIdOrName === entityIdOrName), (0, operators_1.take)(1), // don't listen forever! IMPORTANT!
+    (0, operators_1.mergeMap)(() => (0, rxjs_1.from)([
+        (0, transactionDetailReducer_1.setRecommendationsForCreateTransactionLines)(transactionType, lineIds, (0, recommendationSelector_1.getRecommendationsForEntity)(state$.value, entityIdOrName, 'vendor').recommendations ?? [], (0, tenantSelector_1.getIsAccountingClassesEnabled)(state$.value)),
+    ])));
+    // A fetch already in flight needs no second request, only the wait.
+    if (cached.fetchState === 'In-Progress') {
+        return waitThenApply;
+    }
+    return (0, rxjs_1.concat)((0, rxjs_1.of)((isUnsyncedVendor(entity)
+        ? (0, recommendationReducer_1.fetchRecommendationByEntityName)(entityIdOrName, 'vendor')
+        : (0, recommendationReducer_1.fetchRecommendationByEntityId)(entityIdOrName, 'vendor'))), waitThenApply);
+}));
+exports.fetchVendorRecommendationsForCreateTransactionEpic = fetchVendorRecommendationsForCreateTransactionEpic;

package/lib/view/transactionDetail/createTransaction/epics/initializeCreateTransactionLocalDataEpic.d.ts

@@ -0,0 +1,12 @@
+import { ActionsObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { initializeCreateTransactionLocalData, updateCreateTransactionLocalData } from '../../transactionDetailReducer';
+export type ActionType = ReturnType<typeof initializeCreateTransactionLocalData> | ReturnType<typeof updateCreateTransactionLocalData>;
+/**
+ * Seeds the working copy when the Create form opens: today's date, the default line set for the
+ * type, and a check's mandatory payment_type.
+ *
+ * Mirrors the `else` branch of initializeScheduleDetailLocalDataEpic -- a create has no
+ * existing entity to read from, so there is nothing to merge, only defaults to apply.
+ */
+export declare const initializeCreateTransactionLocalDataEpic: (actions$: ActionsObservable<ActionType>) => Observable<ActionType>;

package/lib/view/transactionDetail/createTransaction/epics/initializeCreateTransactionLocalDataEpic.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeCreateTransactionLocalDataEpic = void 0;
+const operators_1 = require("rxjs/operators");
+const transactionDetailReducer_1 = require("../../transactionDetailReducer");
+const createTransactionLocalDataHelper_1 = require("../createTransactionLocalDataHelper");
+/**
+ * Seeds the working copy when the Create form opens: today's date, the default line set for the
+ * type, and a check's mandatory payment_type.
+ *
+ * Mirrors the `else` branch of initializeScheduleDetailLocalDataEpic -- a create has no
+ * existing entity to read from, so there is nothing to merge, only defaults to apply.
+ */
+const initializeCreateTransactionLocalDataEpic = (actions$) => actions$.pipe((0, operators_1.filter)(transactionDetailReducer_1.initializeCreateTransactionLocalData.match), (0, operators_1.map)((action) => {
+    const { transactionType } = action.payload;
+    return (0, transactionDetailReducer_1.updateCreateTransactionLocalData)(transactionType, (0, createTransactionLocalDataHelper_1.getSeededCreateTransactionLocalData)(transactionType));
+}));
+exports.initializeCreateTransactionLocalDataEpic = initializeCreateTransactionLocalDataEpic;

package/lib/view/transactionDetail/transactionDetailReducer.d.ts

@@ -9,6 +9,7 @@ import { TransactionID } from '../../entity/transaction/stateTypes/transactionID
 import { SupportedTransaction, SupportedTransactionPayload } from '../../entity/transaction/transactionState';
 import { ZeniAPIStatus } from '../../responsePayload';
 import { UncategorizedAccounts } from '../accountList/accountListSelector';
+import { CreateTransactionLineLocalData, CreateTransactionLocalData } from './createTransaction/createTransactionState';
 import { TransactionDetailState, TransactionSaveUpdates } from './transactionDetailState';
 import { TransactionDetailLineItemData, TransactionDetailLocalData, TransactionVendorUpdates } from './transactionDetailTypes';
 export declare const initialState: TransactionDetailState;
@@ -176,6 +177,41 @@ export declare const downloadAccountingProviderAttachment: import("@reduxjs/tool
 }, "transactionDetail/deleteSplitLine", never, never>, toggleSplitEditMode: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionId: TransactionID, editMode: boolean], {
     transactionId: TransactionID;
     editMode: boolean;
-}, "transactionDetail/toggleSplitEditMode", never, never>;
+}, "transactionDetail/toggleSplitEditMode", never, never>, initializeCreateTransactionLocalData: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry"], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+}, "transactionDetail/initializeCreateTransactionLocalData", never, never>, updateCreateTransactionLocalData: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", localData: Partial<CreateTransactionLocalData>], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    localData: Partial<CreateTransactionLocalData>;
+}, "transactionDetail/updateCreateTransactionLocalData", never, never>, updateCreateTransactionLineLocalData: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", lineId: string, lineUpdates: Partial<CreateTransactionLineLocalData>], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    lineId: string;
+    lineUpdates: Partial<CreateTransactionLineLocalData>;
+}, "transactionDetail/updateCreateTransactionLineLocalData", never, never>, addCreateTransactionLine: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", line?: Partial<CreateTransactionLineLocalData> | undefined], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    line: Partial<CreateTransactionLineLocalData> | undefined;
+}, "transactionDetail/addCreateTransactionLine", never, never>, removeCreateTransactionLine: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", lineId: string], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    lineId: string;
+}, "transactionDetail/removeCreateTransactionLine", never, never>, resetCreateTransactionLocalData: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry"], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+}, "transactionDetail/resetCreateTransactionLocalData", never, never>, createTransaction: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry"], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+}, "transactionDetail/createTransaction", never, never>, createTransactionSuccessOrFailure: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[fetchState: FetchState, createdTransactionId?: TransactionID | undefined, error?: ZeniAPIStatus<Record<string, unknown>> | undefined], {
+    fetchState: FetchState;
+    createdTransactionId: TransactionID | undefined;
+    error: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, "transactionDetail/createTransactionSuccessOrFailure", never, never>, setRecommendationsForCreateTransactionLines: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", lineIds: string[], recommendations: Recommendation[], isAccountingClassesEnabled: boolean], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    lineIds: string[];
+    recommendations: Recommendation[];
+    isAccountingClassesEnabled: boolean;
+}, "transactionDetail/setRecommendationsForCreateTransactionLines", never, never>, clearRecommendationsForCreateTransactionLines: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", lineIds: string[]], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    lineIds: string[];
+}, "transactionDetail/clearRecommendationsForCreateTransactionLines", never, never>, fetchVendorRecommendationsForCreateTransaction: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", lineIds: string[], entity?: Entity | undefined], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    lineIds: string[];
+    entity: Entity | undefined;
+}, "transactionDetail/fetchVendorRecommendationsForCreateTransaction", never, never>;
 declare const _default: import("redux").Reducer<TransactionDetailState>;
 export default _default;