@zeniai/client-epic-state 5.2.4 → 5.2.6

package/lib/esm/view/aiCfoView/epics/fetchSkillVersionsEpic.js

@@ -0,0 +1,37 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchSkillVersions, fetchSkillVersionsFailure, fetchSkillVersionsSuccess, } from '../aiCfoViewReducer';
+const toVersion = (payload) => ({
+    version: payload.version,
+    semver: payload.semver ?? null,
+    displayName: payload.display_name ?? null,
+    updatedAt: payload.updated_at ?? null,
+    // Defaulted defensively: these are booleans the server always sends, but a malformed
+    // 2xx should render a row as inactive-and-not-latest rather than as the live one.
+    isActive: payload.is_active === true,
+    isLatest: payload.is_latest === true,
+    instructionsCharCount: payload.instructions_char_count ?? 0,
+});
+/** GET /1.0/skills/{macroId}/versions — the history panel. */
+export const fetchSkillVersionsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchSkillVersions.match), 
+// switchMap: a read, and only the skill currently open matters. The reducer also
+// drops responses whose macroId no longer matches, so a cancelled-but-in-flight
+// request cannot render one skill's history under another's title.
+switchMap((action) => {
+    const { macroId } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}/versions`;
+    return zeniAPI.getJSON(url).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return of(fetchSkillVersionsSuccess({
+                macroId,
+                // Guard the array: a malformed 2xx without `versions` must not crash .map.
+                versions: (response.data.versions ?? []).map(toVersion),
+            }));
+        }
+        return of(fetchSkillVersionsFailure({ macroId, error: response.status }));
+    }), catchError((error) => of(fetchSkillVersionsFailure({
+        macroId,
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch skill versions REST API call failed', error instanceof Error ? { message: error.message } : undefined),
+    }))));
+}));

package/lib/esm/view/aiCfoView/epics/fetchSkillsEpic.js

@@ -2,6 +2,7 @@ import { of } from 'rxjs';
 import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
 import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
 import { fetchSkills, fetchSkillsFailure, fetchSkillsSuccess, } from '../aiCfoViewReducer';
+import { toBaseSkill } from './toSkillDetail';
 const isNonBlankString = (value) => typeof value === 'string' && value.trim() !== '';
 // parameter_hints is a free-form {param: exampleValue(s)} map; flatten its non-blank
 // string values (a single string or an array of them) into display-ready "try: …"
@@ -27,14 +28,12 @@ const toExampleHints = (parameterHints) => {
     // a broken duplicate to the user — dedupe across parameter keys and array entries.
     return Array.from(new Set(hints));
 };
+// Only the LIST route returns parameter_hints, so this is the one call site that has
+// hints to spread in. Everything else about a summary comes from the shared base mapper,
+// so a new `Skill` field cannot land here and be missed on the detail path.
 const toSkill = (skillSummaryPayload) => ({
-    macroId: skillSummaryPayload.macro_id,
-    name: skillSummaryPayload.name,
-    displayName: skillSummaryPayload.display_name,
-    description: skillSummaryPayload.description,
-    semver: skillSummaryPayload.semver,
+    ...toBaseSkill(skillSummaryPayload),
     exampleHints: toExampleHints(skillSummaryPayload.parameter_hints),
-    hasScripts: skillSummaryPayload.has_scripts,
 });
 /** GET {aiCfoMicroServiceBaseUrl}/1.0/skills — chat-visible skills for the `/` menu. */
 export const fetchSkillsEpic = (actions$, 
@@ -52,6 +51,12 @@ switchMap(() => {
             // Guard the array: a malformed 2xx body without `skills` must not crash .map.
             return of(fetchSkillsSuccess({
                 skills: (response.data.skills ?? []).map(toSkill),
+                // === true, not a truthy check: a body missing the field entirely
+                // must read as "off" so the Skills entry stays hidden by default.
+                skillsEnabled: response.data.skills_enabled === true,
+                // Same discipline: a body without the field must withhold the publish
+                // control, not grant it.
+                canPublish: response.data.can_publish === true,
             }));
         }
         return of(fetchSkillsFailure(response.status));

package/lib/esm/view/aiCfoView/epics/saveSkillEpic.js

@@ -0,0 +1,72 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchSkillVersions, fetchSkills, saveSkill, saveSkillFailure, saveSkillSuccess, } from '../aiCfoViewReducer';
+import { getSkillDetail } from '../aiCfoViewSelector';
+import { isSkillDetailPayload, toSkillDetail } from './toSkillDetail';
+/**
+ * POST /1.0/skills (create) or PUT /1.0/skills/{macroId} (new version).
+ *
+ * One epic for both because they are the same action to a user — "save what I wrote" —
+ * and the server answers both with the detail payload. Splitting them would duplicate
+ * the payload mapping and the error handling for a difference the form does not have.
+ */
+export const saveSkillEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(saveSkill.match), 
+// mergeMap, NOT switchMap: a save is a write. Cancelling an in-flight one because
+// another started does not un-send it, it just hides the outcome — and for a
+// create that means a skill exists that the user was never told about.
+mergeMap((action) => {
+    const { draft, macroId } = action.payload;
+    const base = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills`;
+    const body = {
+        name: draft.name,
+        instructions: draft.instructions,
+        description: draft.description,
+        // Sent as the menu name too. The server derives the unique `/` slug from it, so
+        // letting the two drift would make the command stop matching the row's title.
+        display_name: draft.name,
+        // Spread, not `visibility: draft.visibility`: the server distinguishes an ABSENT
+        // visibility ("leave it alone") from an explicit null or 'private' ("make it
+        // private"). Sending the key with a null value would unpublish a tenant-wide
+        // skill on any edit by someone who cannot publish.
+        //
+        // `!= null`, not `!== null`: the type says this is always present, but the value
+        // arrives from a component, and an untyped caller omitting it would spread
+        // `{visibility: undefined}` — a key present with no value, which is the one shape
+        // the rule above is about. The looser check costs nothing and closes it.
+        ...(draft.visibility != null && { visibility: draft.visibility }),
+    };
+    const request$ = macroId != null && macroId !== ''
+        ? zeniAPI.putAndGetJSON(`${base}/${encodeURIComponent(macroId)}`, body)
+        : zeniAPI.postAndGetJSON(base, body);
+    return request$.pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) &&
+            isSkillDetailPayload(response.data)) {
+            const saved = response.data;
+            const savedMacroId = saved.skill.macro_id;
+            const emitted = [
+                saveSkillSuccess({
+                    macroId: savedMacroId,
+                    // The response is a full detail read — carried through so an editor left
+                    // on this skill shows what it just saved rather than the previous prompt.
+                    detail: toSkillDetail(saved),
+                }),
+                // Refetch rather than splice the response in: a create changes the list's
+                // ordering and an update can change the name it is sorted by, so a local
+                // insert would put the row somewhere the next load moves it away from.
+                fetchSkills(),
+            ];
+            // A save adds a version, so the history panel is one behind — but only
+            // refetch when this skill is still the one on screen. `fetchSkillVersions`
+            // takes ownership of the versions slice, so firing it for a skill the user
+            // has already left would cancel the history of whatever they opened next.
+            if (getSkillDetail(state$.value).macroId === savedMacroId) {
+                emitted.push(fetchSkillVersions({ macroId: savedMacroId }));
+            }
+            return of(...emitted);
+        }
+        // A malformed 2xx is a failure, not a silent success: reporting "saved" when
+        // no skill came back leaves the user believing work was persisted.
+        return of(saveSkillFailure(response.status));
+    }), catchError((error) => of(saveSkillFailure(createZeniAPIStatus('Unexpected Error', 'Save skill REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));

package/lib/esm/view/aiCfoView/epics/setSkillVisibilityEpic.js

@@ -0,0 +1,32 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchSkills, setSkillVisibility, setSkillVisibilityFailure, setSkillVisibilitySuccess, } from '../aiCfoViewReducer';
+import { isSkillDetailPayload, toSkillDetail } from './toSkillDetail';
+/**
+ * PUT /1.0/skills/{macroId}/visibility — publish or unpublish, without a new version.
+ *
+ * Its own route rather than the prompt PUT: that one requires name and instructions, so a
+ * visibility-only change cannot be expressed through it, and sending the whole prompt back
+ * to flip one field would create a version whose prompt is identical to its parent's.
+ */
+export const setSkillVisibilityEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(setSkillVisibility.match), 
+// mergeMap, like the other writes: cancelling a write in flight does not un-send it,
+// it only hides the outcome — and for a publish that means a skill sitting in every
+// colleague's menu with nobody told it got there.
+mergeMap((action) => {
+    const { macroId, visibility } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}/visibility`;
+    return zeniAPI.putAndGetJSON(url, { visibility }).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) &&
+            isSkillDetailPayload(response.data)) {
+            return of(setSkillVisibilitySuccess({
+                macroId,
+                detail: toSkillDetail(response.data),
+            }), 
+            // The list carries the badge that shows the audience, so it is now stale.
+            fetchSkills());
+        }
+        return of(setSkillVisibilityFailure(response.status));
+    }), catchError((error) => of(setSkillVisibilityFailure(createZeniAPIStatus('Unexpected Error', 'Set skill visibility REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));

package/lib/esm/view/aiCfoView/epics/toSkillDetail.js

@@ -0,0 +1,102 @@
+/**
+ * Every value `SkillVisibility` admits, as data so the converter below cannot drift from
+ * the type. Adding a tier to the union without adding it here is a compile error.
+ */
+const SKILL_VISIBILITIES = ['private', 'tenant'];
+/**
+ * A wire string narrowed to {@link SkillVisibility}, or null.
+ *
+ * A converter rather than passing the raw string through, because `Skill.visibility` is a
+ * union on the state type and this is the boundary where an unvalidated payload becomes
+ * it — the repo's rule about explicit converters at scalar boundaries instead of a bare
+ * cast.
+ *
+ * Unrecognised maps to NULL, not to `'private'`. Null already means "does not apply" for a
+ * Zeni default, and consumers show no audience badge for it — so an unknown tier renders
+ * as no badge. Defaulting to `'private'` would instead label a skill the whole tenant can
+ * run as author-only, which is a confident lie rather than a visible gap.
+ */
+export const toSkillVisibility = (raw) => SKILL_VISIBILITIES.find((known) => known === raw) ?? null;
+/**
+ * Everything about a skill summary EXCEPT `exampleHints`, which no shared mapper can
+ * honestly supply.
+ *
+ * Only the LIST route returns `parameter_hints`; the detail and write routes do not. A
+ * shared mapper hardcoding `exampleHints: []` would put a "try: …" line under a skill
+ * that has hints, or drop them from the menu — so the field is `Omit`ted and each caller
+ * spreads in what its own route actually knows.
+ *
+ * Returning `Omit<Skill, 'exampleHints'>` rather than duplicating the mapper is what
+ * makes a new `Skill` field land in one place: this function stops compiling until the
+ * field is mapped, and both callers inherit it. The previous shape — two full copies —
+ * is how `isMine` was nearly added to only one of them, which would have silently
+ * withheld the edit and delete controls on whichever surface was missed.
+ */
+export const toBaseSkill = (payload) => ({
+    macroId: payload.macro_id,
+    name: payload.name,
+    displayName: payload.display_name,
+    description: payload.description,
+    semver: payload.semver,
+    hasScripts: payload.has_scripts === true,
+    // === true, so an absent field withholds the write controls rather than offering ones
+    // the API refuses.
+    isMine: payload.is_mine === true,
+    isOwnedByTenant: payload.is_owned_by_tenant === true,
+    updatedAt: payload.updated_at ?? null,
+    visibility: toSkillVisibility(payload.visibility),
+});
+/**
+ * Whether a 2xx body carries a prompt.
+ *
+ * Narrows to {@link PromptBody} and NOT to the whole payload, because the only consumer —
+ * the version-body read — dereferences `instructions` and nothing else. Asserting the
+ * whole shape here would claim `skill` was checked when it was not, and tying the read to
+ * it would fail a response whose prompt was fine and whose `skill` block was malformed,
+ * which is exactly what happened when this was one predicate instead of two.
+ *
+ * Takes `unknown`: the input is an unvalidated network body, and typing the parameter as
+ * the payload interface would assume the very thing being checked.
+ */
+export const hasPromptBody = (data) => typeof data?.instructions ===
+    'string';
+/**
+ * Whether a 2xx body can build a whole {@link SkillDetail}.
+ *
+ * Narrows to the payload type itself, which is now truthful: the two fields this checks
+ * are the two the interface still declares required, and the other three are optional
+ * there. Stricter than {@link hasPromptBody} by exactly one field. Four epics read this shape
+ * and each used to guard it differently — `data != null`, `data?.skill != null`, and a
+ * real `instructions` check — so one malformed response became a failure in one place, an
+ * empty prompt in another, and `undefined` in a third.
+ */
+export const isSkillDetailPayload = (data) => hasPromptBody(data) && data.skill != null;
+/**
+ * The detail payload every write route answers with.
+ *
+ * Shared because three epics need it — save, visibility, and the detail read — and a
+ * fourth copy is how one of them quietly stops carrying a field the others do.
+ *
+ * The coercions are not defensive habit; the payload type makes them mandatory — the
+ * three optional fields cannot be assigned to a non-optional `SkillDetail` without one.
+ * Which fields get coerced and which do not is the deliberate part:
+ *
+ * - `instructions` is load-bearing and already proven, so it passes through. Defaulting a
+ *   missing prompt to `''` is the one thing this module exists to prevent: the user
+ *   cannot tell an empty prompt from a skill that has one, and may save over the real
+ *   thing.
+ * - `instructionsCharCount` falls back to the prompt's own length, NOT to 0. A 12,000
+ *   character prompt displayed as "0 characters" is a lie the user can see, and the
+ *   prompt is right here to measure. Approximate only for astral-plane characters, where
+ *   UTF-16 units and the server's count differ — a rounding error, against a guaranteed
+ *   wrong answer.
+ * - `artifact` and `artifactTitle` degrade to empty. They render a preview card, so
+ *   losing them costs a card; failing the whole read would cost the user the skill.
+ */
+export const toSkillDetail = (payload) => ({
+    skill: { ...toBaseSkill(payload.skill), exampleHints: [] },
+    instructions: payload.instructions,
+    instructionsCharCount: payload.instructions_char_count ?? payload.instructions.length,
+    artifact: payload.artifact ?? '',
+    artifactTitle: payload.artifact_title ?? '',
+});

package/lib/esm/view/invoicing/editInvoicingCatalogItemDetailView/editInvoicingCatalogItemDetailViewSelector.js

@@ -1,6 +1,7 @@
 import { createSelector } from '@reduxjs/toolkit';
 import { getInvoicingPlanById, getInvoicingPlansByIds, } from '../../../entity/invoicing/plan/planSelector';
 import { getInvoicingConfigView, invoicingFieldHelpForGroup, } from '../invoicingConfigView/invoicingConfigViewSelector';
+import { INVOICING_INCOME_ACCOUNT_TYPES, getInvoicingQboView, invoicingAccountHierarchyForTypes, isInvoicingQboConnected, } from '../invoicingQboView/invoicingQboViewSelector';
 import { INVOICING_CATALOG_APPLICABILITY_VALUES, INVOICING_CATALOG_PRICING_MODEL_VALUES, INVOICING_CATALOG_PRORATION_VALUES, INVOICING_CATALOG_TIER_TYPE_VALUES, entityToInvoicingCatalogItemFormLocalData, } from './invoicingCatalogItemFormConfig';
 export const getEditInvoicingCatalogItemDetailViewState = (state) => ({
     fetchState: state.editInvoicingCatalogItemDetailViewState.fetchState,
@@ -48,9 +49,16 @@ export const getInvoicingCatalogItemFormView = (state, id) => {
     const applicableItemOptions = id != null
         ? allApplicableItemOptions.filter((option) => option.id !== id)
         : allApplicableItemOptions;
+    const isQboConnected = isInvoicingQboConnected(state);
     const { billingPeriodUnitOptions, catalogItemTypeOptions, catalogTierTypeOptionsByPricingModel, catalogTrialEndActionOptions, catalogTrialUnitOptions, } = getInvoicingConfigView(state);
     return {
         fieldHelp: invoicingFieldHelpForGroup(state, 'catalog'),
+        qboClassHierarchy: isQboConnected
+            ? getInvoicingQboView(state).nestedClassHierarchy
+            : [],
+        qboIncomeAccountHierarchy: isQboConnected
+            ? invoicingAccountHierarchyForTypes(state, INVOICING_INCOME_ACCOUNT_TYPES)
+            : [],
         applicabilityValues: INVOICING_CATALOG_APPLICABILITY_VALUES,
         applicableItemOptions,
         localData,

package/lib/esm/view/invoicing/invoicingQboView/epics/fetchInvoicingAccountingPickersEpic.js

@@ -0,0 +1,29 @@
+import { EMPTY, from } from 'rxjs';
+import { filter, mergeMap, withLatestFrom } from 'rxjs/operators';
+import { fetchAccountList } from '../../../accountList/accountListReducer';
+import { fetchClassList } from '../../../classList/classListReducer';
+import { fetchInvoicingAccountingPickers } from '../invoicingQboViewReducer';
+import { INVOICING_ACCOUNT_LIST_KEY } from '../invoicingQboViewSelector';
+// Tops up the shared account and class lists, skipping either when the store
+// already holds it or has it in flight.
+export const fetchInvoicingAccountingPickersEpic = (actions$, state$) => actions$.pipe(filter(fetchInvoicingAccountingPickers.match), withLatestFrom(state$), mergeMap(([, state]) => {
+    const actions = [];
+    const accountList = state.accountListState.byReportId[INVOICING_ACCOUNT_LIST_KEY];
+    if (accountList.hasValidState() === false &&
+        accountList.fetchState !== 'In-Progress') {
+        // AP/AR accounts cannot back an invoicing mapping, so they are excluded
+        // here — which is why this uses invoicing's own bucket rather than the
+        // general `accountList` other screens fill without those exclusions.
+        actions.push(fetchAccountList(INVOICING_ACCOUNT_LIST_KEY, true, true, true));
+    }
+    const classList = state.classListState;
+    if (classList.hasValidState() === false &&
+        classList.fetchState !== 'In-Progress') {
+        // Without deleted classes, matching almost every other caller of this
+        // single global slice. Asking for deleted rows here would have handed
+        // them to the vendor and transaction screens too — and the picker
+        // filters deleted classes out anyway, so there is nothing to gain.
+        actions.push(fetchClassList());
+    }
+    return actions.length > 0 ? from(actions) : EMPTY;
+}));

package/lib/esm/view/invoicing/invoicingQboView/invoicingQboViewPayload.js

@@ -6,29 +6,6 @@ export function mapInvoicingQboConnection(payload) {
         realmId: payload.realm_id ?? undefined,
     };
 }
-export function mapInvoicingQboAccountOptions(rows) {
-    return rows.flatMap((row) => {
-        // Only qbo_id is a valid QBO AccountRef/ClassRef value — platform-internal
-        // ids (account_id / id) are display metadata and must never be submitted.
-        const accountId = row.qbo_id ?? row.id ?? row.account_id ?? '';
-        if (accountId === '') {
-            return [];
-        }
-        const accountName = row.name ??
-            row.account_name ??
-            row.accounting_class_name ??
-            row.qbo_accounting_class_name ??
-            row.fully_qualified_name ??
-            accountId;
-        return [
-            {
-                id: accountId,
-                name: accountName,
-                accountType: row.account_type ?? undefined,
-            },
-        ];
-    });
-}
 export function mapInvoicingQboSyncHealth(payload) {
     return {
         connection: payload.connection != null

package/lib/esm/view/invoicing/invoicingQboView/invoicingQboViewReducer.js

@@ -1,11 +1,7 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { clearAll } from '../../../rootActions';
 export const initialState = {
-    accountsByAccountTypes: {},
-    accountsFetchStateByAccountTypes: {},
     backfillFetchState: { fetchState: 'Not-Started', error: undefined },
-    classes: [],
-    classesFetchState: { fetchState: 'Not-Started', error: undefined },
     connection: undefined,
     connectionFetchState: { fetchState: 'Not-Started', error: undefined },
     retryFetchStateByTaskId: {},
@@ -29,41 +25,8 @@ const invoicingQboView = createSlice({
         updateInvoicingQboConnectionFailure(draft, action) {
             draft.connectionFetchState = { fetchState: 'Error', error: action.payload };
         },
-        fetchInvoicingQboAccounts: {
-            reducer(draft, action) {
-                draft.accountsFetchStateByAccountTypes[action.payload.accountTypes] = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            },
-            prepare(accountTypes) {
-                return { payload: { accountTypes } };
-            },
-        },
-        updateInvoicingQboAccounts(draft, action) {
-            draft.accountsByAccountTypes[action.payload.accountTypes] =
-                action.payload.accounts;
-            draft.accountsFetchStateByAccountTypes[action.payload.accountTypes] = {
-                fetchState: 'Completed',
-                error: undefined,
-            };
-        },
-        updateInvoicingQboAccountsFailure(draft, action) {
-            draft.accountsFetchStateByAccountTypes[action.payload.accountTypes] = {
-                fetchState: 'Error',
-                error: action.payload.status,
-            };
-        },
-        fetchInvoicingQboClasses(draft) {
-            draft.classesFetchState = { fetchState: 'In-Progress', error: undefined };
-        },
-        updateInvoicingQboClasses(draft, action) {
-            draft.classes = action.payload;
-            draft.classesFetchState = { fetchState: 'Completed', error: undefined };
-        },
-        updateInvoicingQboClassesFailure(draft, action) {
-            draft.classesFetchState = { fetchState: 'Error', error: action.payload };
-        },
+        // No state of its own: the epic decides which shared lists to load.
+        fetchInvoicingAccountingPickers() { },
         fetchInvoicingQboSyncHealth(draft) {
             draft.syncHealthFetchState = {
                 fetchState: 'In-Progress',
@@ -127,5 +90,5 @@ const invoicingQboView = createSlice({
         });
     },
 });
-export const { fetchInvoicingQboConnection, updateInvoicingQboConnection, updateInvoicingQboConnectionFailure, fetchInvoicingQboAccounts, updateInvoicingQboAccounts, updateInvoicingQboAccountsFailure, fetchInvoicingQboClasses, updateInvoicingQboClasses, updateInvoicingQboClassesFailure, fetchInvoicingQboSyncHealth, updateInvoicingQboSyncHealth, updateInvoicingQboSyncHealthFailure, retryInvoicingQboSyncTask, retryInvoicingQboSyncTaskSuccess, retryInvoicingQboSyncTaskFailure, startInvoicingQboBackfill, startInvoicingQboBackfillSuccess, startInvoicingQboBackfillFailure, } = invoicingQboView.actions;
+export const { fetchInvoicingQboConnection, updateInvoicingQboConnection, updateInvoicingQboConnectionFailure, fetchInvoicingAccountingPickers, fetchInvoicingQboSyncHealth, updateInvoicingQboSyncHealth, updateInvoicingQboSyncHealthFailure, retryInvoicingQboSyncTask, retryInvoicingQboSyncTaskSuccess, retryInvoicingQboSyncTaskFailure, startInvoicingQboBackfill, startInvoicingQboBackfillSuccess, startInvoicingQboBackfillFailure, } = invoicingQboView.actions;
 export default invoicingQboView.reducer;

package/lib/esm/view/invoicing/invoicingQboView/invoicingQboViewSelector.js

@@ -1,16 +1,134 @@
+import { getAccountList, getNestedAccountListHierarchy, } from '../../accountList/accountListSelector';
+import { getClassList, getNestedClassListHierarchy, } from '../../classList/classListSelector';
+// Its own bucket: invoicing needs the AP/AR exclusions that the vendor and
+// transaction screens sharing `accountList` do not pass.
+export const INVOICING_ACCOUNT_LIST_KEY = 'invoicingAccountList';
+/** Whether QBO is connected, without building the option lists to find out. */
+export const isInvoicingQboConnected = (state) => state.invoicingQboViewState.connection?.connected === true;
+/**
+ * Account types that can back invoicing revenue. Named here so screens ask for
+ * "income accounts" rather than repeating the accounting service's vocabulary.
+ */
+export const INVOICING_INCOME_ACCOUNT_TYPES = [
+    'income',
+    'other_income',
+];
+/**
+ * Accounts and classes as the invoicing pickers need them. Both come from the
+ * shared accounting-service lists, so whatever another screen already loaded
+ * is reused. `qboId` is the submitted value because that is what the invoicing
+ * API stores; an account without one cannot be posted, so it is dropped rather
+ * than offered.
+ */
+const invoicingAccountingOptions = (state, accountTypes) => {
+    const { accounts } = getAccountList(state.accountState, state.accountListState, INVOICING_ACCOUNT_LIST_KEY);
+    return accounts.flatMap((account) => {
+        if (account.qboId == null || account.isDeleted === true) {
+            return [];
+        }
+        if (accountTypes != null &&
+            (account.accountType == null ||
+                !accountTypes.includes(account.accountType))) {
+            return [];
+        }
+        return [
+            {
+                id: String(account.qboId),
+                name: account.accountName,
+                accountType: account.accountType,
+            },
+        ];
+    });
+};
+/**
+ * Normalises an account-type name for comparison. The config's mapping kinds
+ * name QuickBooks types the way QuickBooks displays them ("Other Current
+ * Asset", "Expense"), while the accounting service uses snake_case and
+ * sometimes pluralises ("other_current_assets", "expenses"). Comparing the
+ * normalised, de-pluralised forms keeps a picker from silently emptying because
+ * of a trailing "s".
+ */
+const normalizeAccountTypeName = (value) => {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_');
+    // Singularise so "Other Current Liability" meets `other_current_liabilities`
+    // and "Expense" meets `expenses`. `-ies` needs its own case: stripping the
+    // trailing "s" alone would leave "liabilitie", matching nothing.
+    return normalized.replace(/ies$/, 'y').replace(/([^s])s$/, '$1');
+};
+/**
+ * The accounts valid for one QBO mapping kind, whose `accountTypes` is a
+ * comma-separated list of QuickBooks type names. An unrecognised list yields no
+ * accounts rather than every account: offering a bank account where income is
+ * required would post a mapping QuickBooks rejects.
+ */
+export const invoicingAccountsForQboAccountTypes = (accounts, accountTypes) => {
+    const wanted = new Set(accountTypes
+        .split(',')
+        .map(normalizeAccountTypeName)
+        .filter((accountType) => accountType !== ''));
+    if (wanted.size === 0) {
+        return accounts;
+    }
+    return accounts.filter((account) => account.accountType != null &&
+        wanted.has(normalizeAccountTypeName(account.accountType)));
+};
+/** Classes as the invoicing pickers need them, from the shared class list. */
+const invoicingAccountingClassOptions = (state) => {
+    const { classes } = getClassList(state.classState, state.classListState);
+    return classes.flatMap((accountingClass) => accountingClass.qboId == null || accountingClass.isDeleted === true
+        ? []
+        : [
+            {
+                id: String(accountingClass.qboId),
+                name: accountingClass.className,
+            },
+        ]);
+};
+/**
+ * The account tree narrowed to the given account types. The tree itself carries
+ * no account type, so the flat account list supplies that and the matching
+ * `qboId`s are kept — which is why callers that only need "income accounts, as a
+ * tree" do not have to hold a second flat list to filter with.
+ */
+export const invoicingAccountHierarchyForTypes = (state, accountTypes) => {
+    const allowedQboIds = new Set(invoicingAccountingOptions(state, accountTypes).map((account) => account.id));
+    const keepMatching = (nodes) => nodes.flatMap((node) => {
+        const children = keepMatching(node.children);
+        const isMatch = node.qboId != null && allowedQboIds.has(String(node.qboId));
+        // A parent that is not itself a match is still kept when it holds one, so
+        // the tree's shape survives the filter.
+        if (!isMatch && children.length === 0) {
+            return [];
+        }
+        return [{ ...node, children }];
+    });
+    return keepMatching(getNestedAccountListHierarchy(state.accountListState, INVOICING_ACCOUNT_LIST_KEY));
+};
 /**
  * Single bundled view for the QBO integration settings screen — the
- * connection, per-account-types account options, classes, sync health, and the
- * fetch/action states for each of them.
+ * connection, the account and class options, sync health, and the fetch/action
+ * states for each of them.
  */
 export const getInvoicingQboView = (state) => {
     const qboState = state.invoicingQboViewState;
+    const accountList = state.accountListState.byReportId[INVOICING_ACCOUNT_LIST_KEY];
     return {
-        accountsByAccountTypes: qboState.accountsByAccountTypes,
-        accountsFetchStateByAccountTypes: qboState.accountsFetchStateByAccountTypes,
+        accounts: invoicingAccountingOptions(state),
+        accountsFetchState: {
+            fetchState: accountList.fetchState,
+            error: accountList.error,
+        },
+        nestedAccountHierarchy: getNestedAccountListHierarchy(state.accountListState, INVOICING_ACCOUNT_LIST_KEY),
+        nestedClassHierarchy: getNestedClassListHierarchy(state.classListState),
         backfillState: qboState.backfillFetchState,
-        classes: qboState.classes,
-        classesFetchState: qboState.classesFetchState,
+        classes: invoicingAccountingClassOptions(state),
+        classesFetchState: {
+            fetchState: state.classListState.fetchState,
+            error: state.classListState.error,
+        },
         connection: qboState.connection,
         connectionFetchState: qboState.connectionFetchState,
         retryFetchStateByTaskId: qboState.retryFetchStateByTaskId,

package/lib/index.d.ts

@@ -968,12 +968,12 @@ export { AiAccountantCustomerViewState, AiAccountantSortKey, AiAccountantUIState
 export { AiAccountantFilterCategoryField } from './view/companyView/types/cockpitTypes';
 export { cancelAiAccountantOnboarding, fetchAiAccountantCustomers, fetchAiAccountantJobs, setSelectedTenantIdsForJobTrigger, triggerAiAccountantJob, updateAiAccountantUIState, } from './view/aiAccountantView/aiAccountantViewReducer';
 export { AiAccountantCockpitView, getAiAccountantCockpitView, } from './view/aiAccountantView/aiAccountantViewSelector';
-export { fetchChatSessionsForUser, createSession, submitQuestion, updateAiCfoViewScrollPosition, updateCurrentInput, updateCotCollapsedState, setSession, clearCurrentSessionId, clearDeleteChatSessionStatus, clearLastContextMessage, createSessionAndSubmit, stopSubmit, stopSubmitQuestion, fetchChatHistory, acceptMasterTOS, deleteChatSession, submitFeedback, updateResponseState, fetchSuggestedQuestions, fetchSuggestedQuestionsSuccess, fetchSuggestedQuestionsFailure, fetchSkills, fetchSkillsSuccess, fetchSkillsFailure, applyAiCfoSidePanelHostPageTransition, clearAiCfoSidePanelHostPageContext, } from './view/aiCfoView/aiCfoViewReducer';
-export { AiCfoViewState, AiCfoViewUIState, Skill, SkillsState, SuggestedQuestionsForPageContext, } from './view/aiCfoView/aiCfoViewState';
+export { fetchChatSessionsForUser, createSession, submitQuestion, updateAiCfoViewScrollPosition, updateCurrentInput, updateCotCollapsedState, setSession, clearCurrentSessionId, clearDeleteChatSessionStatus, clearLastContextMessage, createSessionAndSubmit, stopSubmit, stopSubmitQuestion, fetchChatHistory, acceptMasterTOS, deleteChatSession, submitFeedback, updateResponseState, fetchSuggestedQuestions, fetchSuggestedQuestionsSuccess, fetchSuggestedQuestionsFailure, fetchSkills, fetchSkillsSuccess, fetchSkillsFailure, fetchSkillDetail, clearSkillDetail, clearSkillMutation, deleteSkill, fetchSkillVersionBody, fetchSkillVersions, saveSkill, setSkillVisibility, openSkillsBrowser, closeSkillsBrowser, applyAiCfoSidePanelHostPageTransition, clearAiCfoSidePanelHostPageContext, } from './view/aiCfoView/aiCfoViewReducer';
+export { AiCfoViewState, AiCfoViewUIState, Skill, SkillDetail, SkillDetailState, SkillDraft, SkillMutationState, SkillVersion, SkillVersionBodyState, SkillVersionsState, SkillVisibility, SkillsState, SuggestedQuestionsForPageContext, } from './view/aiCfoView/aiCfoViewState';
 export { FetchSuggestedQuestionsResponse, SuggestedQuestionsDataPayload, FetchSkillsResponse, SkillSummaryPayload, SkillListDataPayload, } from './view/aiCfoView/aiCfoViewPayload';
 export type { FeedbackType, SubmitFeedbackPayload, } from './view/aiCfoView/aiCfoViewPayload';
 export type { AiCfoSuggestedQuestionsPageContext } from './common/aiCfo/aiCfoSuggestedQuestionsPageContext';
-export { AiCfoViewSelector, getAiCfoView, getSuggestedQuestionsForPageContext, getSkills, } from './view/aiCfoView/aiCfoViewSelector';
+export { AiCfoViewSelector, getAiCfoView, getSuggestedQuestionsForPageContext, getSkills, getSkillDetail, getSkillMutation, getSkillVersionBody, getSkillVersions, getSkillsEnabled, } from './view/aiCfoView/aiCfoViewSelector';
 export { MessagePayload, ChatSessionPayload, AiCfoAnswerPayload, } from './entity/aiCfo/aiCfoPayload';
 export { setNewSession, setSessions, updateAiCfoAnswerCardPolicyWizardPlan, upsertAnswerPayload, upsertOrAddQuestionAnswerPayload, addQuestionPayload, clearSession, toAiCfoExports, toAiCfoVisualization, appendSyntheticAiCfoAnswer, updateSyntheticAiCfoAnswer, removeSyntheticAiCfoAnswer, } from './entity/aiCfo/aiCfoReducer';
 export { AiCfoSelectorView, getAllQuestionAnswersForChatSession, getQuestionAnswerByIdForChatSession, getAllQuestionsForChatSession, getAiCfoSelectorView, getSyntheticAiCfoAnswersForChatSession, getSyntheticAiCfoAnswerByQuestionAnswerId, ChatSessionWithOrderedQuestionAnswers, } from './entity/aiCfo/aiCfoSelector';
@@ -1240,10 +1240,12 @@ export type { InvoicingBrandingFormView, InvoicingSettingsHubView, InvoicingSett
 export type { InvoicingBrandingFormLocalData } from './view/invoicing/settingsView/invoicingBrandingFormConfig';
 export { INVOICING_BUSINESS_ADDRESS_TYPE, entityToInvoicingBrandingFormLocalData, initialInvoicingBrandingFormLocalData, } from './view/invoicing/settingsView/invoicingBrandingFormConfig';
 export { isStripeConnectedFromSettings } from './view/invoicing/settingsView/invoicingSettingsHelpers';
-export { fetchInvoicingQboAccounts, fetchInvoicingQboClasses, fetchInvoicingQboConnection, fetchInvoicingQboSyncHealth, retryInvoicingQboSyncTask, startInvoicingQboBackfill, } from './view/invoicing/invoicingQboView/invoicingQboViewReducer';
+export { fetchInvoicingAccountingPickers, fetchInvoicingQboConnection, fetchInvoicingQboSyncHealth, retryInvoicingQboSyncTask, startInvoicingQboBackfill, } from './view/invoicing/invoicingQboView/invoicingQboViewReducer';
+export { INVOICING_INCOME_ACCOUNT_TYPES, invoicingAccountsForQboAccountTypes, } from './view/invoicing/invoicingQboView/invoicingQboViewSelector';
+export type { InvoicingAccountingOption } from './view/invoicing/invoicingQboView/invoicingQboViewSelector';
 export { getInvoicingQboView } from './view/invoicing/invoicingQboView/invoicingQboViewSelector';
 export type { InvoicingQboView } from './view/invoicing/invoicingQboView/invoicingQboViewSelector';
-export type { InvoicingQboAccountOption, InvoicingQboConnection, InvoicingQboFailedTask, InvoicingQboSyncHealth, } from './view/invoicing/invoicingQboView/invoicingQboViewPayload';
+export type { InvoicingQboConnection, InvoicingQboFailedTask, InvoicingQboSyncHealth, } from './view/invoicing/invoicingQboView/invoicingQboViewPayload';
 export { INVOICING_QBO_CUSTOMER_MATCHING_MODES, getInvoicingQboAccountMappingId, toInvoicingNamedOptionsByKey, toInvoicingQboCustomerMatchingMode, withInvoicingQboAccountMappingId, } from './entity/invoicing/invoicingCommonPayload';
 export type { InvoicingNamedOption, InvoicingFieldHelp, InvoicingFieldHelpByCode, InvoicingFieldHelpGroup, InvoicingNamedOptionsByKey, InvoicingQboAccountMappingKindOption, InvoicingQboAccountMappingsPayload, InvoicingQboCustomerMatchingMode, InvoicingQboSettingsPayload, } from './entity/invoicing/invoicingCommonPayload';
 export { acceptInvoicingTerms, enableInvoicing, fetchInvoicingConfig, resetInvoicingConfigActionStates, updateInvoicingConfig, } from './view/invoicing/invoicingConfigView/invoicingConfigViewReducer';