@open-mercato/core 0.7.1-develop.7113.1.9d83dca10c → 0.7.1-develop.7120.1.a0154ac412

package/src/modules/customers/lib/dealStatus.ts

@@ -1,25 +1,36 @@
 // Single source of truth for deal open/closed (terminal) semantics.
 //
 // `customer_deals.status` is a lenient text column and the supported writers do not agree on
-// one spelling: the closure hooks and the kanban board persist `win` / `loose`, the AI tool
-// `customers.update_deal_stage` persists `won` / `lost`, and the seeded vocabulary also carries
-// `closed`. The terminal set below therefore covers every spelling a status writer persists, so
-// status-based readers can share one classification. `closureOutcome` is a separate signal and
-// callers that combine both columns must handle it explicitly.
+// one spelling: the closure hooks and the kanban board persist `win` / `lost`, the AI tool
+// `customers.update_deal_stage` persists `won` / `lost`, the seeded vocabulary also carries
+// `closed`, and rows written before 0.7.1 carry the misspelled `loose`. The terminal set
+// below therefore covers every spelling a status writer persists, so status-based readers
+// can share one classification. `closureOutcome` is a separate signal, and callers that
+// combine both columns must handle it explicitly.
 //
 // A status not known to code counts as OPEN. Deal stages are configurable per tenant, so the
 // lenient column can hold values this module has never seen — treating them as open keeps them
 // visible in active-deal counts instead of silently reclassifying them as closed.
 
 export const DEAL_STATUS_WIN = 'win' as const
-export const DEAL_STATUS_LOSE = 'loose' as const
+export const DEAL_STATUS_LOST = 'lost' as const
 export const DEAL_STATUS_CLOSED = 'closed' as const
 
-// `won` / `lost` are the spellings the AI stage tool writes; `win` / `loose` are what the UI
-// closure flows persist. Both are accepted so neither writer produces an unreadable status.
+/**
+ * @deprecated Misspelling of the lost-deal status, canonical until 0.7.0. Writers now
+ * persist {@link DEAL_STATUS_LOST}. This export stays so downstream modules keep
+ * compiling and readers keep matching rows written before the 0.7.1 migration; it is
+ * scheduled for removal no earlier than 0.9.0.
+ */
+export const DEAL_STATUS_LOSE = 'loose' as const
+
+// `won` is the spelling the AI stage tool writes; `win` is what the UI closure flows
+// persist. Both are accepted so neither writer produces an unreadable status.
 export const WON_DEAL_STATUS_LIST: readonly string[] = [DEAL_STATUS_WIN, 'won']
 
-export const LOST_DEAL_STATUS_LIST: readonly string[] = [DEAL_STATUS_LOSE, 'lost']
+// `lost` is canonical. `loose` is the pre-0.7.1 spelling the UI closure flows and the
+// kanban board persisted; unmigrated rows and tenant dictionaries still carry it.
+export const LOST_DEAL_STATUS_LIST: readonly string[] = [DEAL_STATUS_LOST, DEAL_STATUS_LOSE]
 
 export const CLOSED_DEAL_STATUS_LIST: readonly string[] = [
   ...WON_DEAL_STATUS_LIST,
@@ -50,10 +61,10 @@ export function isOpenDealStatus(value: string | null | undefined): boolean {
 export function canonicalDealStatus(value: string): string {
   const lower = value.toLowerCase()
   if (lower === 'won') return DEAL_STATUS_WIN
-  if (lower === 'lost') return DEAL_STATUS_LOSE
+  if (lower === 'loose') return DEAL_STATUS_LOST
   // Canonical spellings normalize to lower-case too, so an upper-case selection still
   // matches the lower-case persisted values and dictionary options.
-  if (lower === 'win' || lower === 'loose' || lower === 'open' || lower === 'closed') return lower
+  if (lower === 'win' || lower === 'lost' || lower === 'open' || lower === 'closed') return lower
   return value
 }
 
@@ -61,7 +72,7 @@ export function canonicalDealStatus(value: string): string {
  * Expand operator-selected status filter values into the canonical vocabulary so a
  * single selection matches every spelling the supported writers persist (#5107).
  *
- * Alias groups (`win`/`won`, `loose`/`lost`, `closed`) are matched case-insensitively,
+ * Alias groups (`win`/`won`, `lost`/`loose`, `closed`) are matched case-insensitively,
  * expanded to their canonical spellings, and also keep the caller's original token so
  * the result is always a strict superset of a verbatim match. Unknown values emit both
  * the trimmed original and its lower-case form — mixed-case tenant dictionary statuses

package/src/modules/customers/lib/dealsSummaryQueries.ts

@@ -146,9 +146,9 @@ export async function loadDealsSummaryQueryRows(input: DealsSummaryQueryInput):
   const winLossRows = await connection.execute<WinLossRow[]>(
     `SELECT
         COUNT(*) FILTER (WHERE (status = 'win' OR closure_outcome = 'won') AND updated_at >= ? AND updated_at < ?) AS current_won,
-        COUNT(*) FILTER (WHERE (status = 'loose' OR closure_outcome = 'lost') AND updated_at >= ? AND updated_at < ?) AS current_lost,
+        COUNT(*) FILTER (WHERE (status IN ('lost', 'loose') OR closure_outcome = 'lost') AND updated_at >= ? AND updated_at < ?) AS current_lost,
         COUNT(*) FILTER (WHERE (status = 'win' OR closure_outcome = 'won') AND updated_at >= ? AND updated_at < ?) AS previous_won,
-        COUNT(*) FILTER (WHERE (status = 'loose' OR closure_outcome = 'lost') AND updated_at >= ? AND updated_at < ?) AS previous_lost
+        COUNT(*) FILTER (WHERE (status IN ('lost', 'loose') OR closure_outcome = 'lost') AND updated_at >= ? AND updated_at < ?) AS previous_lost
       FROM customer_deals
       WHERE ${scopeWhere}`,
     [
@@ -168,7 +168,7 @@ export async function loadDealsSummaryQueryRows(input: DealsSummaryQueryInput):
     `SELECT
         to_char(date_trunc('month', updated_at AT TIME ZONE 'UTC'), 'YYYY-MM') AS period,
         COUNT(*) FILTER (WHERE status = 'win' OR closure_outcome = 'won') AS won,
-        COUNT(*) FILTER (WHERE status = 'loose' OR closure_outcome = 'lost') AS lost
+        COUNT(*) FILTER (WHERE status IN ('lost', 'loose') OR closure_outcome = 'lost') AS lost
       FROM customer_deals
       WHERE ${scopeWhere} AND updated_at >= ?
       GROUP BY 1`,

package/src/modules/customers/migrations/Migration20260824180000_deal_status_lost.ts

@@ -0,0 +1,55 @@
+import { Migration } from '@mikro-orm/migrations';
+
+/**
+ * Rename the misspelled lost-deal vocabulary `loose` to `lost`.
+ *
+ * `loose` was the canonical spelling the UI closure flows, the kanban board and the seeded
+ * dictionaries persisted up to 0.7.0. `lost` is what every other surface already used
+ * (`closure_outcome`, the AI stage tool, every operator-facing label), so the two spellings
+ * had to be reconciled anywhere a reader joined them.
+ *
+ * Forward-only and conservative. Nothing is deleted, and a row is left alone whenever
+ * renaming it would collide with an entry the tenant already has:
+ *
+ *   - `customer_deals.status` / `pipeline_stage`: `loose` -> `lost`.
+ *   - `customer_dictionary_entries` (`deal_status`, `pipeline_stage`): the `loose` entry is
+ *     renamed only when the same scope has no `lost` entry, since
+ *     `customer_dictionary_entries_unique` covers (org, tenant, kind, normalized_value).
+ *     Its label is corrected only when it is still the seeded `Loose`, so a tenant that
+ *     renamed the option keeps its own wording.
+ *   - `customer_pipeline_stages.name`: the seeded `Loose` label becomes `Lost`.
+ *
+ * Readers keep accepting `loose` (see `lib/dealStatus.ts`), so an instance that skips this
+ * migration, or a row this migration deliberately leaves behind, still classifies correctly.
+ */
+export class Migration20260824180000_deal_status_lost extends Migration {
+  override async up(): Promise<void> {
+    this.addSql(`update "customer_deals" set "status" = 'lost' where lower("status") = 'loose';`);
+    this.addSql(`update "customer_deals" set "pipeline_stage" = 'lost' where lower("pipeline_stage") = 'loose';`);
+
+    this.addSql(`
+      update "customer_dictionary_entries" as e
+      set "value" = 'lost',
+          "normalized_value" = 'lost',
+          "label" = case when e."label" = 'Loose' then 'Lost' else e."label" end,
+          "updated_at" = now()
+      where e."kind" in ('deal_status', 'pipeline_stage')
+        and e."normalized_value" = 'loose'
+        and not exists (
+          select 1 from "customer_dictionary_entries" as other
+          where other."organization_id" = e."organization_id"
+            and other."tenant_id" = e."tenant_id"
+            and other."kind" = e."kind"
+            and other."normalized_value" = 'lost'
+        );
+    `);
+
+    this.addSql(`update "customer_pipeline_stages" set "name" = 'Lost', "updated_at" = now() where "name" = 'Loose';`);
+  }
+
+  override async down(): Promise<void> {
+    // Reverting is lossy: an instance may have carried `lost` rows before this migration ran,
+    // and those are indistinguishable afterwards from the ones it renamed. Readers accept
+    // both spellings, so leaving the data on the canonical `lost` is the safe no-op.
+  }
+}

package/src/modules/dashboards/widgets/dashboard/pipeline-summary/config.ts

@@ -9,7 +9,7 @@ import type { WidgetDataRequest } from '../../../services/widgetDataService'
 // `customers/lib/interactionStatus.ts`, which treats an unknown interaction status as open.
 //
 // Every vocabulary that reaches the column has to be listed here:
-//   - `win` / `loose` are written by the deal closure UI and the kanban board.
+//   - `win` / `lost` are written by the deal closure UI and the kanban board.
 //   - `won` / `lost` are written verbatim by the `customers.update_deal_stage` AI tool, whose
 //     free-form `toStage` is passed straight through to `status`.
 //   - `closed` is a seeded `deal_status` dictionary value, persisted by the dashboards

package/src/modules/eudr/notifications.ts

@@ -4,6 +4,7 @@ export const notificationTypes: NotificationTypeDefinition[] = [
   {
     type: 'eudr.statement.submitted',
     module: 'eudr',
+    channels: ['in_app', 'email'],
     titleKey: 'eudr.notifications.statement.submitted.title',
     bodyKey: 'eudr.notifications.statement.submitted.body',
     icon: 'file-check',
@@ -14,6 +15,7 @@ export const notificationTypes: NotificationTypeDefinition[] = [
   {
     type: 'eudr.statement.reference_issued',
     module: 'eudr',
+    channels: ['in_app', 'email'],
     titleKey: 'eudr.notifications.statement.referenceIssued.title',
     bodyKey: 'eudr.notifications.statement.referenceIssued.body',
     icon: 'badge-check',
@@ -24,6 +26,7 @@ export const notificationTypes: NotificationTypeDefinition[] = [
   {
     type: 'eudr.statement.withdrawn',
     module: 'eudr',
+    channels: ['in_app', 'email'],
     titleKey: 'eudr.notifications.statement.withdrawn.title',
     bodyKey: 'eudr.notifications.statement.withdrawn.body',
     icon: 'undo',
@@ -34,6 +37,7 @@ export const notificationTypes: NotificationTypeDefinition[] = [
   {
     type: 'eudr.risk.non_negligible',
     module: 'eudr',
+    channels: ['in_app', 'email'],
     titleKey: 'eudr.notifications.risk.nonNegligible.title',
     bodyKey: 'eudr.notifications.risk.nonNegligible.body',
     icon: 'alert-triangle',
@@ -44,6 +48,7 @@ export const notificationTypes: NotificationTypeDefinition[] = [
   {
     type: 'eudr.mitigation.completed',
     module: 'eudr',
+    channels: ['in_app', 'email'],
     titleKey: 'eudr.notifications.mitigation.completed.title',
     bodyKey: 'eudr.notifications.mitigation.completed.body',
     icon: 'check-circle',

package/src/modules/query_index/lib/search-tokens.ts

@@ -162,6 +162,60 @@ function buildFieldPairs(recordId: string, doc?: Record<string, unknown> | null)
   return pairs
 }
 
+type TokenRowLike = { field?: unknown; token_hash?: unknown; token?: unknown }
+
+// NUL, not a printable separator: a field name may itself contain a space, so `a b` + hash `c`
+// would otherwise sign identically to field `a` + hash `b c`.
+const SIGNATURE_SEPARATOR = String.fromCharCode(0)
+
+// Identifies one token row for comparison. `token` is NULL unless `storeRawTokens` is on, and a
+// stored NULL has to sign the same as the `null` a freshly built row carries — otherwise every
+// record compares as changed and the skip never fires.
+function tokenSignature(row: TokenRowLike): string {
+  return [
+    String(row.field ?? ''),
+    String(row.token_hash ?? ''),
+    row.token == null ? '' : String(row.token),
+  ].join(SIGNATURE_SEPARATOR)
+}
+
+// Multiplicities, not sets: #4681 reports token rows duplicated by the concurrent-replacement
+// defect, and a set comparison reads such a record as already correct and preserves the duplicates
+// forever. Counting sends it through a full rewrite, which collapses them.
+function tallyOf(rows: Iterable<TokenRowLike>): Map<string, number> {
+  const tally = new Map<string, number>()
+  for (const row of rows) {
+    const signature = tokenSignature(row)
+    tally.set(signature, (tally.get(signature) ?? 0) + 1)
+  }
+  return tally
+}
+
+function tallyEquals(a: Map<string, number> | undefined, b: Map<string, number> | undefined): boolean {
+  const left = a ?? new Map<string, number>()
+  const right = b ?? new Map<string, number>()
+  if (left.size !== right.size) return false
+  for (const [key, count] of left.entries()) {
+    if (right.get(key) !== count) return false
+  }
+  return true
+}
+
+function tallyTokenRows<TRow extends TokenRowLike>(
+  rows: Iterable<TRow>,
+  keyOf: (row: TRow) => string
+): Map<string, Map<string, number>> {
+  const tallies = new Map<string, Map<string, number>>()
+  for (const row of rows) {
+    const key = keyOf(row)
+    const tally = tallies.get(key) ?? new Map<string, number>()
+    const signature = tokenSignature(row)
+    tally.set(signature, (tally.get(signature) ?? 0) + 1)
+    tallies.set(key, tally)
+  }
+  return tallies
+}
+
 export async function replaceSearchTokensForRecord(
   db: Kysely<any>,
   params: BuildTokenOptions,
@@ -174,6 +228,52 @@ export async function replaceSearchTokensForRecord(
   const tenantId = params.tenantId ?? null
   const fieldPairs = buildFieldPairs(String(params.recordId), params.doc)
 
+  // Same comparison #5402 gave the batch path, over the scope this path actually writes: the
+  // delete below is narrowed to the document's own `(entity_id, field)` pairs, so the comparison
+  // has to be narrowed the same way. Reading wider would let a token row under a field this
+  // document does not carry — the `cf_` twin the search module used to write, say — read as a
+  // difference forever and defeat the skip on every write.
+  const scopeTokenQuery = (query: any): any => {
+    let scoped = query
+      .where('entity_type' as any, '=', params.entityType)
+      .where(sql<boolean>`organization_id is not distinct from ${organizationId}`)
+      .where(sql<boolean>`tenant_id is not distinct from ${tenantId}`)
+      .where('entity_id' as any, '=', String(params.recordId))
+    if (fieldPairs.length) {
+      scoped = scoped.where('field' as any, 'in', fieldPairs.map(([, field]) => field))
+    }
+    return scoped
+  }
+
+  // Read through the caller's transaction when there is one. A separate connection cannot see that
+  // transaction's own uncommitted writes, so it could report rows a pending delete has already
+  // removed and talk this call out of re-inserting them.
+  const reader = options?.trx ?? db
+
+  // Count probe first, as in the batch path: it returns one row whatever the table holds, so a
+  // record whose stored rows have run away (#4681) is settled without materializing them.
+  const storedCountRows = await scopeTokenQuery(
+    reader.selectFrom('search_tokens' as any).select(sql<number>`count(*)`.as('token_count') as any),
+  ).execute()
+  const storedCount = Number((storedCountRows as any[])[0]?.token_count ?? 0)
+
+  let unchanged = storedCount === rows.length
+  if (unchanged && rows.length) {
+    const stored = await scopeTokenQuery(
+      reader.selectFrom('search_tokens' as any).select(['field' as any, 'token_hash' as any, 'token' as any]),
+    )
+      // Counts already match, so this cannot truncate. It bounds the read if a concurrent writer
+      // inserts between the probe and here; a truncated read compares as changed, which costs a
+      // rewrite rather than a wrong skip.
+      .limit(rows.length)
+      .execute()
+    unchanged = tallyEquals(tallyOf(rows), tallyOf(stored as any[]))
+  }
+  if (unchanged) {
+    debug('record.skip', { entityType: params.entityType, recordId: params.recordId, tokenCount: rows.length })
+    return
+  }
+
   const writeTokens = async (executor: SearchTokenExecutor): Promise<void> => {
     let deleteQuery = executor
       .deleteFrom('search_tokens' as any)
@@ -223,49 +323,6 @@ export async function deleteSearchTokensForRecord(
     .execute()
 }
 
-// NUL, not a printable separator: a field name may itself contain a space, so `a b` + hash `c`
-// would otherwise sign identically to field `a` + hash `b c`.
-const SIGNATURE_SEPARATOR = String.fromCharCode(0)
-
-// Identifies one token row for comparison. `token` is NULL unless `storeRawTokens` is on, and a
-// stored NULL has to sign the same as the `null` a freshly built row carries — otherwise every
-// record compares as changed and the skip never fires.
-function tokenSignature(row: { field?: unknown; token_hash?: unknown; token?: unknown }): string {
-  return [
-    String(row.field ?? ''),
-    String(row.token_hash ?? ''),
-    row.token == null ? '' : String(row.token),
-  ].join(SIGNATURE_SEPARATOR)
-}
-
-// Multiplicities, not sets: #4681 reports token rows duplicated by the concurrent-replacement
-// defect, and a set comparison reads such a record as already correct and preserves the duplicates
-// forever. Counting sends it through a full rewrite, which collapses them.
-function tallyEquals(a: Map<string, number> | undefined, b: Map<string, number> | undefined): boolean {
-  const left = a ?? new Map<string, number>()
-  const right = b ?? new Map<string, number>()
-  if (left.size !== right.size) return false
-  for (const [key, count] of left.entries()) {
-    if (right.get(key) !== count) return false
-  }
-  return true
-}
-
-function tallyTokenRows<TRow extends { field?: unknown; token_hash?: unknown; token?: unknown }>(
-  rows: Iterable<TRow>,
-  keyOf: (row: TRow) => string
-): Map<string, Map<string, number>> {
-  const tallies = new Map<string, Map<string, number>>()
-  for (const row of rows) {
-    const key = keyOf(row)
-    const tally = tallies.get(key) ?? new Map<string, number>()
-    const signature = tokenSignature(row)
-    tally.set(signature, (tally.get(signature) ?? 0) + 1)
-    tallies.set(key, tally)
-  }
-  return tallies
-}
-
 export async function replaceSearchTokensForBatch(
   db: Kysely<any>,
   payloads: Array<BuildTokenOptions & { doc: Record<string, unknown> }>

package/src/modules/sales/commands/documents.ts

@@ -1,6 +1,7 @@
 // @ts-nocheck
 
 import { randomUUID } from "crypto";
+import { isDeepStrictEqual } from "node:util";
 import { z } from "zod";
 import { registerCommand } from "@open-mercato/shared/lib/commands";
 import type { CommandHandler } from "@open-mercato/shared/lib/commands";
@@ -9197,6 +9198,88 @@ const createInvoiceCommand: CommandHandler<
   },
 };
 
+const invoiceUpdateChangeKeys = [
+  "invoiceNumber",
+  "statusEntryId",
+  "status",
+  "issueDate",
+  "dueDate",
+  "currencyCode",
+  "subtotalNetAmount",
+  "subtotalGrossAmount",
+  "discountTotalAmount",
+  "taxTotalAmount",
+  "grandTotalNetAmount",
+  "grandTotalGrossAmount",
+  "paidTotalAmount",
+  "outstandingAmount",
+  "metadata",
+] as const;
+
+function toAuditISOString(value: unknown): string | null {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value.toISOString();
+  }
+  if (typeof value === "string") {
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+  }
+  return null;
+}
+
+function auditValuesEqual(left: unknown, right: unknown): boolean {
+  if (Object.is(left, right)) return true;
+  if (left instanceof Date || right instanceof Date) {
+    const leftIso = toAuditISOString(left);
+    const rightIso = toAuditISOString(right);
+    return leftIso !== null && rightIso !== null && leftIso === rightIso;
+  }
+  return isDeepStrictEqual(left, right);
+}
+
+function buildAuditChanges(
+  before: Record<string, unknown>,
+  after: Record<string, unknown>,
+  keys: readonly string[],
+): Record<string, { from: unknown; to: unknown }> {
+  const changedKeys = keys.filter((key) => !auditValuesEqual(before[key], after[key]));
+  return buildChanges(before, after, changedKeys);
+}
+
+function selectInvoiceUpdateChangeKeys(
+  input: z.infer<typeof invoiceUpdateSchema>,
+): Array<(typeof invoiceUpdateChangeKeys)[number]> {
+  return invoiceUpdateChangeKeys.filter((key) =>
+    key === "status"
+      ? input.statusEntryId !== undefined
+      : input[key as keyof z.infer<typeof invoiceUpdateSchema>] !== undefined,
+  );
+}
+
+function applyInvoiceHeaderUpdate(
+  invoice: SalesInvoice,
+  input: z.infer<typeof invoiceUpdateSchema>,
+  resolvedStatus: string | null | undefined,
+): void {
+  if (input.invoiceNumber !== undefined) invoice.invoiceNumber = input.invoiceNumber;
+  if (input.statusEntryId !== undefined) {
+    invoice.statusEntryId = input.statusEntryId;
+    invoice.status = resolvedStatus ?? null;
+  }
+  if (input.issueDate !== undefined) invoice.issueDate = input.issueDate;
+  if (input.dueDate !== undefined) invoice.dueDate = input.dueDate;
+  if (input.currencyCode !== undefined) invoice.currencyCode = input.currencyCode;
+  if (input.subtotalNetAmount !== undefined) invoice.subtotalNetAmount = toNumericString(input.subtotalNetAmount);
+  if (input.subtotalGrossAmount !== undefined) invoice.subtotalGrossAmount = toNumericString(input.subtotalGrossAmount);
+  if (input.discountTotalAmount !== undefined) invoice.discountTotalAmount = toNumericString(input.discountTotalAmount);
+  if (input.taxTotalAmount !== undefined) invoice.taxTotalAmount = toNumericString(input.taxTotalAmount);
+  if (input.grandTotalNetAmount !== undefined) invoice.grandTotalNetAmount = toNumericString(input.grandTotalNetAmount);
+  if (input.grandTotalGrossAmount !== undefined) invoice.grandTotalGrossAmount = toNumericString(input.grandTotalGrossAmount);
+  if (input.paidTotalAmount !== undefined) invoice.paidTotalAmount = toNumericString(input.paidTotalAmount);
+  if (input.outstandingAmount !== undefined) invoice.outstandingAmount = toNumericString(input.outstandingAmount);
+  if (input.metadata !== undefined) invoice.metadata = input.metadata;
+}
+
 const updateInvoiceCommand: CommandHandler<
   z.infer<typeof invoiceUpdateSchema>,
   { invoiceId: string }
@@ -9225,29 +9308,12 @@ const updateInvoiceCommand: CommandHandler<
       deletedAt: null,
     });
 
-    const changes = buildChanges(invoice, parsed, [
-      "invoiceNumber",
-      "statusEntryId",
-      "status",
-      "issueDate",
-      "dueDate",
-      "currencyCode",
-      "subtotalNetAmount",
-      "subtotalGrossAmount",
-      "discountTotalAmount",
-      "taxTotalAmount",
-      "grandTotalNetAmount",
-      "grandTotalGrossAmount",
-      "paidTotalAmount",
-      "outstandingAmount",
-      "metadata",
-    ]);
-
+    let resolvedStatus: string | null | undefined;
     if (parsed.statusEntryId !== undefined) {
-      invoice.status = await resolveDictionaryEntryValue(em, parsed.statusEntryId ?? null, { tenantId: invoice.tenantId });
+      resolvedStatus = await resolveDictionaryEntryValue(em, parsed.statusEntryId ?? null, { tenantId: invoice.tenantId });
     }
 
-    Object.assign(invoice, changes);
+    applyInvoiceHeaderUpdate(invoice, parsed, resolvedStatus);
     invoice.updatedAt = new Date();
     await em.flush();
 
@@ -9283,11 +9349,18 @@ const updateInvoiceCommand: CommandHandler<
     const em = (ctx.container.resolve("em") as EntityManager).fork();
     return loadInvoiceSnapshot(em, result.invoiceId);
   },
-  buildLog: async ({ result, snapshots }) => {
+  buildLog: async ({ input, result, snapshots }) => {
     const before = snapshots.before as InvoiceGraphSnapshot | undefined;
     const after = snapshots.after as InvoiceGraphSnapshot | undefined;
     if (!after) return null;
     const { translate } = await resolveTranslations();
+    const changes = before
+      ? buildAuditChanges(
+          before.invoice as unknown as Record<string, unknown>,
+          after.invoice as unknown as Record<string, unknown>,
+          selectInvoiceUpdateChangeKeys(input),
+        )
+      : {};
     return {
       actionLabel: translate("sales.audit.invoices.update", "Update invoice"),
       resourceKind: "sales.invoice",
@@ -9296,6 +9369,7 @@ const updateInvoiceCommand: CommandHandler<
       organizationId: after.invoice.organizationId,
       snapshotBefore: before,
       snapshotAfter: after,
+      changes: Object.keys(changes).length ? changes : null,
       payload: {
         undo: { before, after } satisfies InvoiceUndoPayload,
       },
@@ -9704,6 +9778,52 @@ const createCreditMemoCommand: CommandHandler<
   },
 };
 
+const creditMemoUpdateChangeKeys = [
+  "creditMemoNumber",
+  "statusEntryId",
+  "status",
+  "reason",
+  "issueDate",
+  "currencyCode",
+  "subtotalNetAmount",
+  "subtotalGrossAmount",
+  "taxTotalAmount",
+  "grandTotalNetAmount",
+  "grandTotalGrossAmount",
+  "metadata",
+] as const;
+
+function selectCreditMemoUpdateChangeKeys(
+  input: z.infer<typeof creditMemoUpdateSchema>,
+): Array<(typeof creditMemoUpdateChangeKeys)[number]> {
+  return creditMemoUpdateChangeKeys.filter((key) =>
+    key === "status"
+      ? input.statusEntryId !== undefined
+      : input[key as keyof z.infer<typeof creditMemoUpdateSchema>] !== undefined,
+  );
+}
+
+function applyCreditMemoHeaderUpdate(
+  creditMemo: SalesCreditMemo,
+  input: z.infer<typeof creditMemoUpdateSchema>,
+  resolvedStatus: string | null | undefined,
+): void {
+  if (input.creditMemoNumber !== undefined) creditMemo.creditMemoNumber = input.creditMemoNumber;
+  if (input.statusEntryId !== undefined) {
+    creditMemo.statusEntryId = input.statusEntryId;
+    creditMemo.status = resolvedStatus ?? null;
+  }
+  if (input.reason !== undefined) creditMemo.reason = input.reason;
+  if (input.issueDate !== undefined) creditMemo.issueDate = input.issueDate;
+  if (input.currencyCode !== undefined) creditMemo.currencyCode = input.currencyCode;
+  if (input.subtotalNetAmount !== undefined) creditMemo.subtotalNetAmount = toNumericString(input.subtotalNetAmount);
+  if (input.subtotalGrossAmount !== undefined) creditMemo.subtotalGrossAmount = toNumericString(input.subtotalGrossAmount);
+  if (input.taxTotalAmount !== undefined) creditMemo.taxTotalAmount = toNumericString(input.taxTotalAmount);
+  if (input.grandTotalNetAmount !== undefined) creditMemo.grandTotalNetAmount = toNumericString(input.grandTotalNetAmount);
+  if (input.grandTotalGrossAmount !== undefined) creditMemo.grandTotalGrossAmount = toNumericString(input.grandTotalGrossAmount);
+  if (input.metadata !== undefined) creditMemo.metadata = input.metadata;
+}
+
 const updateCreditMemoCommand: CommandHandler<
   z.infer<typeof creditMemoUpdateSchema>,
   { creditMemoId: string }
@@ -9732,26 +9852,12 @@ const updateCreditMemoCommand: CommandHandler<
       deletedAt: null,
     });
 
-    const changes = buildChanges(creditMemo, parsed, [
-      "creditMemoNumber",
-      "statusEntryId",
-      "status",
-      "reason",
-      "issueDate",
-      "currencyCode",
-      "subtotalNetAmount",
-      "subtotalGrossAmount",
-      "taxTotalAmount",
-      "grandTotalNetAmount",
-      "grandTotalGrossAmount",
-      "metadata",
-    ]);
-
+    let resolvedStatus: string | null | undefined;
     if (parsed.statusEntryId !== undefined) {
-      creditMemo.status = await resolveDictionaryEntryValue(em, parsed.statusEntryId ?? null, { tenantId: creditMemo.tenantId });
+      resolvedStatus = await resolveDictionaryEntryValue(em, parsed.statusEntryId ?? null, { tenantId: creditMemo.tenantId });
     }
 
-    Object.assign(creditMemo, changes);
+    applyCreditMemoHeaderUpdate(creditMemo, parsed, resolvedStatus);
     creditMemo.updatedAt = new Date();
     await em.flush();
 
@@ -9787,11 +9893,18 @@ const updateCreditMemoCommand: CommandHandler<
     const em = (ctx.container.resolve("em") as EntityManager).fork();
     return loadCreditMemoSnapshot(em, result.creditMemoId);
   },
-  buildLog: async ({ result, snapshots }) => {
+  buildLog: async ({ input, result, snapshots }) => {
     const before = snapshots.before as CreditMemoGraphSnapshot | undefined;
     const after = snapshots.after as CreditMemoGraphSnapshot | undefined;
     if (!after) return null;
     const { translate } = await resolveTranslations();
+    const changes = before
+      ? buildAuditChanges(
+          before.creditMemo as unknown as Record<string, unknown>,
+          after.creditMemo as unknown as Record<string, unknown>,
+          selectCreditMemoUpdateChangeKeys(input),
+        )
+      : {};
     return {
       actionLabel: translate("sales.audit.credit_memos.update", "Update credit memo"),
       resourceKind: "sales.credit_memo",
@@ -9800,6 +9913,7 @@ const updateCreditMemoCommand: CommandHandler<
       organizationId: after.creditMemo.organizationId,
       snapshotBefore: before,
       snapshotAfter: after,
+      changes: Object.keys(changes).length ? changes : null,
       payload: {
         undo: { before, after } satisfies CreditMemoUndoPayload,
       },

package/src/modules/warranty_claims/notifications.ts

@@ -4,6 +4,7 @@ export const notificationTypes: NotificationTypeDefinition[] = [
   {
     type: 'warranty_claims.claim.submitted',
     module: 'warranty_claims',
+    channels: ['in_app', 'email'],
     titleKey: 'warranty_claims.notifications.submitted.title',
     bodyKey: 'warranty_claims.notifications.submitted.body',
     icon: 'clipboard-check',
@@ -23,6 +24,7 @@ export const notificationTypes: NotificationTypeDefinition[] = [
   {
     type: 'warranty_claims.claim.assigned',
     module: 'warranty_claims',
+    channels: ['in_app', 'email'],
     titleKey: 'warranty_claims.notifications.assigned.title',
     bodyKey: 'warranty_claims.notifications.assigned.body',
     icon: 'user-check',
@@ -42,6 +44,7 @@ export const notificationTypes: NotificationTypeDefinition[] = [
   {
     type: 'warranty_claims.claim.status_changed',
     module: 'warranty_claims',
+    channels: ['in_app', 'email'],
     titleKey: 'warranty_claims.notifications.statusChanged.title',
     bodyKey: 'warranty_claims.notifications.statusChanged.body',
     icon: 'refresh-cw',
@@ -61,6 +64,7 @@ export const notificationTypes: NotificationTypeDefinition[] = [
   {
     type: 'warranty_claims.claim.escalated',
     module: 'warranty_claims',
+    channels: ['in_app', 'email'],
     titleKey: 'warranty_claims.notifications.escalated.title',
     bodyKey: 'warranty_claims.notifications.escalated.body',
     icon: 'alarm-clock',
@@ -80,6 +84,7 @@ export const notificationTypes: NotificationTypeDefinition[] = [
   {
     type: 'warranty_claims.claim.customer_replied',
     module: 'warranty_claims',
+    channels: ['in_app', 'email'],
     titleKey: 'warranty_claims.notifications.customerReplied.title',
     bodyKey: 'warranty_claims.notifications.customerReplied.body',
     icon: 'message-square-reply',