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

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

@@ -0,0 +1,95 @@
+import { ID } from '../../../commonStateTypes/common';
+import { ProjectBasePayload } from '../../../entity/project/projectPayload';
+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';
+    /** Same shape the transaction update sends on a vendor line. */
+    project?: ProjectBasePayload;
+    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>;
+/**
+ * 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 declare class UnresolvedCreateTransactionIdError extends Error {
+}
+/**
+ * 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 declare const prepareCreateTransactionPayload: (state: RootState, localData: CreateTransactionLocalData) => CreateTransactionRequest;

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

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareCreateTransactionPayload = exports.UnresolvedCreateTransactionIdError = void 0;
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const accountSelector_1 = require("../../../entity/account/accountSelector");
+const classSelector_1 = require("../../../entity/class/classSelector");
+const projectPayload_1 = require("../../../entity/project/projectPayload");
+const projectSelector_1 = require("../../../entity/project/projectSelector");
+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 (line.projectId != null) {
+        lineDetail.project = (0, projectPayload_1.toProjectBasePayload)((0, projectSelector_1.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.
+ */
+class UnresolvedCreateTransactionIdError extends Error {
+}
+exports.UnresolvedCreateTransactionIdError = UnresolvedCreateTransactionIdError;
+/**
+ * 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 = (0, accountSelector_1.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 = (0, classSelector_1.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((0, vendorSelector_1.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((0, vendorSelector_1.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.
+ */
+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: 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;
+};
+exports.prepareCreateTransactionPayload = prepareCreateTransactionPayload;

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

@@ -0,0 +1,44 @@
+import { NestedAccountHierarchyForReport } from '../../../commonStateTypes/accountView/nestedAccountID';
+import { NestedClassHierarchyForReport } from '../../../commonStateTypes/classesView/nestedClassID';
+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 { 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[];
+};
+/**
+ * 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 declare const getCreateTransactionView: (state: RootState, transactionType: CreatableTransactionType) => CreateTransactionView;

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCreateTransactionView = exports.getCreateTransactionVendorRecommendations = exports.getCreateTransactionStatus = exports.getCreateTransactionLocalData = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+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;
+/**
+ * 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.
+ */
+exports.getCreateTransactionView = (0, toolkit_1.createSelector)([
+    (state) => state.transactionDetailState.createTransactionsState,
+    (state) => state.vendorState.vendorByID,
+    (state) => state.accountListState,
+    (state) => state.classListState,
+    (state) => (0, createTransferEntrySelector_1.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: (0, accountListSelector_1.getNestedAccountListHierarchy)(accountListState, 'accountList'),
+    classListNestedAccountHierarchy: (0, classListSelector_1.getNestedClassListHierarchy)(classListState),
+    transferAccountsList: transactionType === 'transfer' ? transferAccountsList : [],
+    fetchState: createTransactionsState.createStatus.fetchState,
+    error: createTransactionsState.createStatus.error,
+}));

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

@@ -0,0 +1,82 @@
+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;
+    className?: string;
+    /**
+     * 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/createTransactionAttachmentUploadFailureEpic.d.ts

@@ -0,0 +1,10 @@
+import { ActionsObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { createTransactionAttachmentUploadFailure } from '../../transactionDetailReducer';
+export type ActionType = ReturnType<typeof createTransactionAttachmentUploadFailure> | ReturnType<typeof openSnackbar>;
+/**
+ * Attachments upload from the page after the create succeeds, so a failure is reported back here
+ * rather than by createTransactionEpic.
+ */
+export declare const createTransactionAttachmentUploadFailureEpic: (actions$: ActionsObservable<ActionType>) => Observable<ActionType>;

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

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

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 } from '../../transactionDetailReducer';
+export type ActionType = ReturnType<typeof createTransaction> | ReturnType<typeof createTransactionSuccessOrFailure> | 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,85 @@
+"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 createTransactionEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(transactionDetailReducer_1.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.
+(0, operators_1.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 (0, rxjs_1.defer)(() => zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/transactions/manage`, (0, createTransactionPayload_1.prepareCreateTransactionPayload)(state, localData))).pipe((0, operators_1.mergeMap)((response) => {
+        const created = (0, responsePayload_1.isSuccessResponse)(response)
+            ? response.data?.transactions[0]
+            : undefined;
+        if (created == null) {
+            const status = (0, responsePayload_1.isSuccessResponse)(response)
+                ? (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Transaction was created but returned no details.')
+                : response.status;
+            return (0, rxjs_1.from)([
+                (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.
+                    variables: [
+                        { variableName: '_api-error_', variableValue: status.message },
+                    ],
+                }),
+            ]);
+        }
+        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),
+            // 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.
+            (0, transactionDetailReducer_1.createTransactionSuccessOrFailure)('Completed', newTransactionId),
+            (0, transactionDetailReducer_1.initializeTransactionDetailLocalData)({
+                transactionId: newTransactionId,
+                vendorId: created.vendor_id ?? undefined,
+            }),
+            (0, snackbarReducer_1.openSnackbar)({
+                messageSection: 'create_transaction',
+                messageText: 'success',
+                type: 'success',
+            }),
+        ]);
+    }), (0, operators_1.catchError)((error) => {
+        const message = error instanceof createTransactionPayload_1.UnresolvedCreateTransactionIdError
+            ? error.message
+            : JSON.stringify(error);
+        return (0, rxjs_1.from)([
+            (0, transactionDetailReducer_1.createTransactionSuccessOrFailure)('Error', undefined, (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', `Create Transaction REST API call errored out ${message}`)),
+            (0, snackbarReducer_1.openSnackbar)({
+                messageSection: 'create_transaction',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    { variableName: '_api-error_', variableValue: message },
+                ],
+            }),
+        ]);
+    }));
+}));
+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>;