@zeniai/client-epic-state 5.2.88 → 5.2.89-beta0KB

package/lib/esm/view/invoicing/settingsView/settingsViewReducer.js

@@ -1,4 +1,5 @@
 import { createSlice } from '@reduxjs/toolkit';
+import { INVOICING_QBO_SALES_TAX_POSTING_ACCOUNT_SLOT, } from '../../../entity/invoicing/invoicingCommonPayload';
 import { clearAll } from '../../../rootActions';
 import { entityToInvoicingQboSettingsLocalData, } from './invoicingQboSettingsFormConfig';
 export const initialState = {
@@ -40,7 +41,24 @@ const settingsView = createSlice({
         saveInvoicingSettings(draft, action) {
             draft.saveFetchState = { fetchState: 'In-Progress', error: undefined };
             if (draft.settings != null) {
-                draft.settings = { ...draft.settings, ...action.payload.settings };
+                // The display-only sales tax posting account is never in a save body,
+                // so carry it over rather than blank it until the response lands.
+                const postingAccount = draft.settings.qbo?.account_mappings?.[INVOICING_QBO_SALES_TAX_POSTING_ACCOUNT_SLOT];
+                const settings = { ...draft.settings, ...action.payload.settings };
+                const accountMappings = settings.qbo?.account_mappings;
+                draft.settings =
+                    postingAccount != null && accountMappings != null
+                        ? {
+                            ...settings,
+                            qbo: {
+                                ...settings.qbo,
+                                account_mappings: {
+                                    ...accountMappings,
+                                    [INVOICING_QBO_SALES_TAX_POSTING_ACCOUNT_SLOT]: postingAccount,
+                                },
+                            },
+                        }
+                        : settings;
             }
         },
         saveInvoicingSettingsSuccess(draft, action) {

package/lib/esm/view/invoicing/settingsView/settingsViewSelector.js

@@ -1,6 +1,6 @@
-import { getInvoicingQboAccountMappingId, } from '../../../entity/invoicing/invoicingCommonPayload';
 import { getAddressByAddressId } from '../../../entity/address/addressSelector';
 import { getFileByFileId } from '../../../entity/file/fileSelector';
+import { INVOICING_QBO_SALES_TAX_POSTING_ACCOUNT_SLOT, getInvoicingQboAccountMappingId, } from '../../../entity/invoicing/invoicingCommonPayload';
 import { getFormattedAddress } from '../../addressView/addressViewSelector';
 import { getInvoicingConfigView, invoicingFieldHelpForGroup, } from '../invoicingConfigView/invoicingConfigViewSelector';
 import { getInvoicingQboView, isInvoicingAccountingPickerDataLoading, } from '../invoicingQboView/invoicingQboViewSelector';
@@ -102,6 +102,19 @@ export const getInvoicingSettingsHubView = (state) => {
         status,
     };
 };
+/**
+ * The name of the account the service posts sales tax to. Read from the whole
+ * account the settings carry, or looked up by id in the account list for a
+ * payload that sends only the id.
+ */
+const invoicingSalesTaxPostingAccountName = (accountMappings, accounts) => {
+    const slot = accountMappings?.[INVOICING_QBO_SALES_TAX_POSTING_ACCOUNT_SLOT];
+    const name = typeof slot === 'string'
+        ? accounts.find((account) => account.id === slot)?.name
+        : slot?.account_name;
+    const trimmed = name?.trim() ?? '';
+    return trimmed !== '' ? trimmed : undefined;
+};
 /**
  * Bundled view for the QBO configuration page: the draft it edits, the accounts
  * and option lists its dropdowns render, the connection and sync health it
@@ -135,6 +148,7 @@ export const getInvoicingQboSettingsFormView = (state) => {
         localData: qboDraft ?? initialInvoicingQboSettingsLocalData,
         nestedAccountHierarchy: qboView.nestedAccountHierarchy,
         retryFetchStateByTaskId: qboView.retryFetchStateByTaskId,
+        salesTaxPostingAccountName: invoicingSalesTaxPostingAccountName(settings?.qbo?.account_mappings, qboView.accounts),
         saveState: saveFetchState.fetchState === 'Not-Started' && error != null
             ? { fetchState, error }
             : saveFetchState,

package/lib/esm/view/transactionDetail/createTransaction/createTransactionLocalDataHelper.js

@@ -0,0 +1,157 @@
+import { dateNow } from '../../../zeniDayJS';
+import { ALL_CREATABLE_TRANSACTION_TYPES, } from './createTransactionState';
+/**
+ * Monotonic counter for line row keys. These never leave the client -- the payload builder
+ * drops them -- so a counter is enough, and it keeps reducer tests deterministic in a way
+ * randomUUID would not.
+ */
+let lineIdCounter = 0;
+export const nextCreateTransactionLineId = () => `create-transaction-line-${lineIdCounter++}`;
+/** Test-only: makes line ids predictable from the start of each case. */
+export const resetCreateTransactionLineIdCounter = () => {
+    lineIdCounter = 0;
+};
+export const createEmptyCreateTransactionLine = (postingType) => ({
+    id: nextCreateTransactionLineId(),
+    postingType,
+});
+/**
+ * The lines a freshly-opened form starts with. A journal entry is invalid with fewer than one
+ * debit and one credit, so it opens with both rather than making the user add the second row.
+ * Transfer has no lines at all.
+ */
+export const getDefaultCreateTransactionLines = (transactionType) => {
+    if (transactionType === 'transfer') {
+        return [];
+    }
+    if (transactionType === 'journal_entry') {
+        return [
+            createEmptyCreateTransactionLine('debit'),
+            createEmptyCreateTransactionLine('credit'),
+        ];
+    }
+    return [createEmptyCreateTransactionLine()];
+};
+/**
+ * A blank working copy for one type. Note this does NOT seed the date -- the reducer's initial
+ * state has to stay a pure constant so `clearAll` restores something stable. The date is seeded
+ * by initializeCreateTransactionLocalDataEpic, which runs when the form opens.
+ */
+export const getEmptyCreateTransactionLocalData = (transactionType) => ({
+    lines: [],
+    transactionType,
+});
+export const getInitialCreateTransactionLocalDataByType = () => ALL_CREATABLE_TRANSACTION_TYPES.reduce((acc, transactionType) => {
+    acc[transactionType] =
+        getEmptyCreateTransactionLocalData(transactionType);
+    return acc;
+}, {});
+/**
+ * The payment_type the backend insists on for some types: a check needs `check`, and a
+ * credit_card_credit (sent as expense + is_credit) needs a card type -- qbo_purchase.py raises
+ * without them.
+ */
+const SEEDED_PAYMENT_TYPE = {
+    check: 'check',
+    credit_card_credit: 'credit_card',
+};
+/**
+ * What the form opens with: a blank copy plus today's date, the default line set, and the
+ * payment_type the backend insists on for the type.
+ */
+export const getSeededCreateTransactionLocalData = (transactionType) => ({
+    ...getEmptyCreateTransactionLocalData(transactionType),
+    lines: getDefaultCreateTransactionLines(transactionType),
+    paymentType: SEEDED_PAYMENT_TYPE[transactionType],
+    transactionDate: dateNow(),
+});
+/**
+ * Merges a partial edit into the working copy. Lines are replaced wholesale when present --
+ * a partial line array would silently truncate the form.
+ */
+export const mergeCreateTransactionLocalData = (current, update) => ({
+    ...current,
+    ...update,
+    lines: update.lines ?? current.lines,
+    // The type is keyed by the slice, never edited through a merge.
+    transactionType: current.transactionType,
+});
+/**
+ * A user edit to a prefilled account or class makes it theirs, so its flag is dropped and a
+ * later vendor switch no longer clears it.
+ */
+export const updateCreateTransactionLine = (lines, lineId, update) => lines.map((line) => line.id === lineId
+    ? {
+        ...line,
+        ...update,
+        id: line.id,
+        isAccountPreFilled: 'accountQboId' in update ? undefined : line.isAccountPreFilled,
+        isClassPreFilled: 'classId' in update ? undefined : line.isClassPreFilled,
+    }
+    : line);
+/**
+ * Recommendation -> RecommendationWithCOT. Chain-of-thought and recommendation feedback both
+ * need an existing transaction, so cot/reasoning are empty here by design; the dropdown only
+ * needs the entities to build its "Recommended" group.
+ */
+export const toRecommendationsWithCOT = (recommendations) => recommendations.map((recommendation) => ({
+    account: recommendation.account != null
+        ? { ...recommendation.account, cot: [], reasoning: '' }
+        : undefined,
+    class: recommendation.class != null
+        ? { ...recommendation.class, cot: [], reasoning: '' }
+        : undefined,
+    vendor: recommendation.vendor != null
+        ? { ...recommendation.vendor, cot: [], reasoning: '' }
+        : undefined,
+}));
+/**
+ * Applies a vendor's recommendations to one line: always refreshes the dropdown's "Recommended"
+ * group, but only prefills account/class when the field is still empty. Callers switching
+ * vendors clear the previous prefill first, so "empty" includes what the last vendor filled. Anything the user
+ * picked wins -- this follows the transaction-categorization helper, which prefills, rather
+ * than the detail-page helper, which only suggests.
+ */
+export const applyRecommendationsToCreateTransactionLine = (line, recommendations, isAccountingClassesEnabled) => {
+    const top = recommendations[0];
+    const updated = {
+        ...line,
+        recommendationsWithCOT: toRecommendationsWithCOT(recommendations),
+    };
+    if (line.accountQboId == null && top?.account?.qboId != null) {
+        updated.accountQboId = top.account.qboId;
+        updated.accountName = top.account.accountName;
+        updated.isAccountPreFilled = true;
+    }
+    if (isAccountingClassesEnabled &&
+        line.classId == null &&
+        top?.class?.classId != null) {
+        updated.classId = top.class.classId;
+        updated.className = top.class.className;
+        updated.isClassPreFilled = true;
+    }
+    return updated;
+};
+/**
+ * Undoes a prefill when the vendor is cleared. Only the fields the prefill wrote are removed --
+ * the per-field flags are what make the user's own choices distinguishable from ours, which is
+ * why they are not a single line-level boolean: a hand-picked account alongside a prefilled
+ * class is an ordinary state, and clearing must not take the account with it.
+ */
+export const clearRecommendationsFromCreateTransactionLine = (line) => {
+    const cleared = {
+        ...line,
+        recommendationsWithCOT: undefined,
+    };
+    if (line.isAccountPreFilled === true) {
+        cleared.accountQboId = undefined;
+        cleared.accountName = undefined;
+        cleared.isAccountPreFilled = undefined;
+    }
+    if (line.isClassPreFilled === true) {
+        cleared.classId = undefined;
+        cleared.className = undefined;
+        cleared.isClassPreFilled = undefined;
+    }
+    return cleared;
+};

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

@@ -0,0 +1,164 @@
+import { DEFAULT_DATE_FORMAT } from '../../../commonStateTypes/timePeriod';
+import { getAccountBaseForTransferAccounts } from '../../../entity/account/accountSelector';
+import { getClassById } from '../../../entity/class/classSelector';
+import { toProjectBasePayload, } from '../../../entity/project/projectPayload';
+import { getProjectById } from '../../../entity/project/projectSelector';
+import { getVendorByQboId, getVendorByVendorId, } from '../../../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 (line.projectId != null) {
+        lineDetail.project = toProjectBasePayload(getProjectById(state.projectState, line.projectId) ?? {
+            projectId: line.projectId,
+            projectName: '',
+        });
+    }
+    if (transactionType === 'journal_entry') {
+        lineDetail.posting_type = line.postingType;
+        const vendorQboId = toQboLineVendorId(state, line.vendorQboId);
+        if (vendorQboId != null) {
+            lineDetail.vendor = { qbo_id: 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,
+    };
+};
+/**
+ * Thrown when a picked id has no QBO id to send. Sending the Zeni id instead would reach QBO as
+ * an unknown reference and come back as an opaque error, so the create is stopped here and the
+ * epic shows this message instead.
+ */
+export class UnresolvedCreateTransactionIdError extends Error {
+}
+/**
+ * Resolves a transfer account (the Zeni account id from the transfer pools) to its QBO id. The
+ * header and line account dropdowns already hold the QBO id, so they are sent as-is.
+ */
+const toQboTransferAccountId = (state, accountId) => {
+    if (accountId == null) {
+        return undefined;
+    }
+    const qboId = getAccountBaseForTransferAccounts(state.accountState, accountId)?.qboId;
+    if (qboId == null || qboId === '') {
+        throw new UnresolvedCreateTransactionIdError('The selected transfer account could not be found in QuickBooks.');
+    }
+    return qboId;
+};
+/** 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;
+    }
+    const qboId = getClassById(state.classState, {
+        classId,
+        reportId: 'class_list',
+    })?.qboId;
+    if (qboId == null || qboId === '') {
+        throw new UnresolvedCreateTransactionIdError('The selected class could not be found in QuickBooks.');
+    }
+    return qboId;
+};
+/** A vendor not yet synced to QBO carries `qboId === name`, which QBO would reject. */
+const toSyncedVendorQboId = (vendor) => {
+    if (vendor == null || vendor.qboId === '' || vendor.qboId === vendor.name) {
+        throw new UnresolvedCreateTransactionIdError('The selected vendor is not synced to QuickBooks yet.');
+    }
+    return vendor.qboId;
+};
+/** Resolves a Zeni vendor id to its QBO id -- `vendor_id` on the wire is a QBO id. */
+const toQboVendorId = (state, vendorId) => vendorId == null
+    ? undefined
+    : toSyncedVendorQboId(getVendorByVendorId(state.vendorState, vendorId));
+/** A journal entry line holds the QBO id already, so it is only checked against the store. */
+const toQboLineVendorId = (state, vendorQboId) => vendorQboId == null
+    ? undefined
+    : toSyncedVendorQboId(getVendorByQboId(state.vendorState, vendorQboId));
+/**
+ * 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.
+ *
+ * Throws UnresolvedCreateTransactionIdError when a picked vendor (header or journal entry line),
+ * class or transfer account has no QBO id.
+ */
+export const prepareCreateTransactionPayload = (state, localData) => {
+    const { transactionType } = localData;
+    const base = {
+        transaction_type: transactionType,
+        transaction_date: localData.transactionDate?.format(DEFAULT_DATE_FORMAT) ?? '',
+        transaction_memo: localData.transactionMemo,
+    };
+    if (transactionType === 'transfer') {
+        return {
+            ...base,
+            from_account_id: toQboTransferAccountId(state, localData.fromAccountId),
+            to_account_id: toQboTransferAccountId(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: 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. The seed sets
+        // payment_type to credit_card, since qbo_purchase.py raises on is_credit without a card type.
+        return {
+            ...purchaseBase,
+            transaction_type: 'expense',
+            is_credit: true,
+            document_number: localData.documentNumber,
+        };
+    }
+    return purchaseBase;
+};

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

@@ -0,0 +1,47 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { getNestedAccountListHierarchy } from '../../accountList/accountListSelector';
+import { getNestedClassListHierarchy } from '../../classList/classListSelector';
+import { getResolvedTransferAccounts } from '../../createTransferEntry/createTransferEntrySelector';
+import { getRecommendationsForEntity } from '../../recommendation/recommendationSelector';
+export const getCreateTransactionLocalData = (state, transactionType) => state.transactionDetailState.createTransactionsState.newTransactionState[transactionType];
+export const getCreateTransactionStatus = (state) => state.transactionDetailState.createTransactionsState.createStatus;
+/**
+ * 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 const getCreateTransactionVendorRecommendations = (state, vendorQboId) => {
+    if (vendorQboId == null || vendorQboId === '') {
+        return { fetchState: 'Not-Started' };
+    }
+    const view = getRecommendationsForEntity(state, vendorQboId, 'vendor');
+    return {
+        fetchState: view.fetchState,
+        recommendations: view.recommendations,
+    };
+};
+/**
+ * Memoized: app-ui reads this straight from useSelector, and the vendor list and hierarchies are
+ * rebuilt on every call, so an unmemoized version re-renders the page on every store action.
+ */
+export const getCreateTransactionView = createSelector([
+    (state) => state.transactionDetailState.createTransactionsState,
+    (state) => state.vendorState.vendorByID,
+    (state) => state.accountListState,
+    (state) => state.classListState,
+    (state) => getResolvedTransferAccounts(state).transferAccountsList,
+    (_state, transactionType) => transactionType,
+], (createTransactionsState, vendorByID, accountListState, classListState, transferAccountsList, transactionType) => ({
+    transactionType,
+    localData: createTransactionsState.newTransactionState[transactionType],
+    createStatus: createTransactionsState.createStatus,
+    createdTransactionId: createTransactionsState.createdTransactionId,
+    vendorList: Object.values(vendorByID),
+    accountListNestedAccountHierarchy: getNestedAccountListHierarchy(accountListState, 'accountList'),
+    classListNestedAccountHierarchy: getNestedClassListHierarchy(classListState),
+    transferAccountsList: transactionType === 'transfer' ? transferAccountsList : [],
+    fetchState: createTransactionsState.createStatus.fetchState,
+    error: createTransactionsState.createStatus.error,
+}));

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

@@ -0,0 +1,11 @@
+/**
+ * The transaction types the Create Transaction flow can originate. A narrow subset of
+ * TransactionType -- everything else is read-only and arrives via sync.
+ */
+export const ALL_CREATABLE_TRANSACTION_TYPES = [
+    'expense',
+    'check',
+    'credit_card_credit',
+    'transfer',
+    'journal_entry',
+];

package/lib/esm/view/transactionDetail/createTransaction/epics/createTransactionAttachmentUploadFailureEpic.js

@@ -0,0 +1,19 @@
+import { filter, map } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { createTransactionAttachmentUploadFailure } from '../../transactionDetailReducer';
+/**
+ * Attachments upload from the page after the create succeeds, so a failure is reported back here
+ * rather than by createTransactionEpic.
+ */
+export const createTransactionAttachmentUploadFailureEpic = (actions$) => actions$.pipe(filter(createTransactionAttachmentUploadFailure.match), filter((action) => action.payload.failedAttachmentFileNames.length > 0), map((action) => openSnackbar({
+    messageSection: 'missing_receipts_attachment',
+    messageText: 'failed',
+    type: 'error',
+    showStatusIcon: true,
+    variables: [
+        {
+            variableName: '__message__',
+            variableValue: ` - ${action.payload.failedAttachmentFileNames.join(', ')},`,
+        },
+    ],
+})));

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

@@ -0,0 +1,81 @@
+import { defer, from } from 'rxjs';
+import { catchError, exhaustMap, filter, mergeMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { toTransactionID } from '../../../../entity/transaction/payloadTypes/transactionIDPayload';
+import { updateTransaction } from '../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { createTransaction, createTransactionSuccessOrFailure, initializeTransactionDetailLocalData, } from '../../transactionDetailReducer';
+import { getTransactionDetailKey } from '../../transactionDetailState';
+import { UnresolvedCreateTransactionIdError, prepareCreateTransactionPayload, } from '../createTransactionPayload';
+export const createTransactionEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(createTransaction.match), 
+// exhaustMap, not mergeMap: a second submit while one is in flight is dropped here rather
+// than relying only on the disabled Save button, so it cannot create a duplicate in QBO.
+exhaustMap((action) => {
+    const { transactionType } = action.payload;
+    const state = state$.value;
+    const localData = state.transactionDetailState.createTransactionsState
+        .newTransactionState[transactionType];
+    // Deferred so a payload that cannot be built (an id with no QBO id) lands in catchError
+    // below as a failure, instead of throwing out of the epic.
+    return defer(() => zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/transactions/manage`, prepareCreateTransactionPayload(state, localData))).pipe(mergeMap((response) => {
+        const created = isSuccessResponse(response)
+            ? response.data?.transactions[0]
+            : undefined;
+        if (created == null) {
+            const status = isSuccessResponse(response)
+                ? createZeniAPIStatus('Unexpected Error', 'Transaction was created but returned no details.')
+                : response.status;
+            return from([
+                createTransactionSuccessOrFailure('Error', undefined, status),
+                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.
+                    variables: [
+                        { variableName: '_api-error_', variableValue: status.message },
+                    ],
+                }),
+            ]);
+        }
+        const newTransactionId = 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 from([
+            updateTransaction(getTransactionDetailKey(newTransactionId), created),
+            // No reset here: it would clear createdTransactionId in the same tick, before the
+            // screen renders it to upload pending attachments and navigate. The screen resets
+            // the working copy on unmount instead.
+            // Before the local-data init: it seeds the detail entry that init writes into.
+            createTransactionSuccessOrFailure('Completed', newTransactionId),
+            initializeTransactionDetailLocalData({
+                transactionId: newTransactionId,
+                vendorId: created.vendor_id ?? undefined,
+            }),
+            openSnackbar({
+                messageSection: 'create_transaction',
+                messageText: 'success',
+                type: 'success',
+            }),
+        ]);
+    }), catchError((error) => {
+        const message = error instanceof UnresolvedCreateTransactionIdError
+            ? error.message
+            : JSON.stringify(error);
+        return from([
+            createTransactionSuccessOrFailure('Error', undefined, createZeniAPIStatus('Unexpected Error', `Create Transaction REST API call errored out ${message}`)),
+            openSnackbar({
+                messageSection: 'create_transaction',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    { variableName: '_api-error_', variableValue: message },
+                ],
+            }),
+        ]);
+    }));
+}));

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

@@ -0,0 +1,53 @@
+import { concat, from, of } from 'rxjs';
+import { filter, mergeMap, switchMap, take } from 'rxjs/operators';
+import { getIsAccountingClassesEnabled } from '../../../../entity/tenant/tenantSelector';
+import { fetchRecommendationByEntityId, fetchRecommendationByEntityName, indicateReadyToInitializeRecommendation, } from '../../../recommendation/recommendationReducer';
+import { getRecommendationsForEntity } from '../../../recommendation/recommendationSelector';
+import { clearRecommendationsForCreateTransactionLines, fetchVendorRecommendationsForCreateTransaction, setRecommendationsForCreateTransactionLines, } from '../../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.
+ */
+export const fetchVendorRecommendationsForCreateTransactionEpic = (actions$, state$) => actions$.pipe(filter(fetchVendorRecommendationsForCreateTransaction.match), switchMap((action) => {
+    const { transactionType, entity, lineIds } = action.payload;
+    if (entity == null) {
+        return of(clearRecommendationsForCreateTransactionLines(transactionType, lineIds));
+    }
+    const entityIdOrName = toEntityIdOrName(entity);
+    const state = state$.value;
+    const isAccountingClassesEnabled = getIsAccountingClassesEnabled(state);
+    const cached = getRecommendationsForEntity(state, entityIdOrName, 'vendor');
+    // Cache hit: apply straight away, no request and no wait.
+    if (cached.fetchState === 'Completed') {
+        return of(setRecommendationsForCreateTransactionLines(transactionType, lineIds, cached.recommendations ?? [], isAccountingClassesEnabled));
+    }
+    const waitThenApply = actions$.pipe(filter(indicateReadyToInitializeRecommendation.match), filter((ready) => ready.payload.entityType === 'vendor' &&
+        ready.payload.entityIdOrName === entityIdOrName), take(1), // don't listen forever! IMPORTANT!
+    mergeMap(() => from([
+        setRecommendationsForCreateTransactionLines(transactionType, lineIds, getRecommendationsForEntity(state$.value, entityIdOrName, 'vendor').recommendations ?? [], getIsAccountingClassesEnabled(state$.value)),
+    ])));
+    // A fetch already in flight needs no second request, only the wait.
+    if (cached.fetchState === 'In-Progress') {
+        return waitThenApply;
+    }
+    return concat(of((isUnsyncedVendor(entity)
+        ? fetchRecommendationByEntityName(entityIdOrName, 'vendor')
+        : fetchRecommendationByEntityId(entityIdOrName, 'vendor'))), waitThenApply);
+}));

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

@@ -0,0 +1,10 @@
+import { filter, map } from 'rxjs/operators';
+import { initializeCreateTransactionLocalData, resetCreateTransactionLocalData, } from '../../transactionDetailReducer';
+/**
+ * Seeds the working copy when the Create form opens: today's date, the default line set for the
+ * type, and the payment_type the backend insists on.
+ *
+ * The seed replaces the whole working copy rather than merging into it, so a second initialize
+ * for the same type can't leave the previous draft's vendor, memo or account behind.
+ */
+export const initializeCreateTransactionLocalDataEpic = (actions$) => actions$.pipe(filter(initializeCreateTransactionLocalData.match), map((action) => resetCreateTransactionLocalData(action.payload.transactionType)));