@open-mercato/core 0.7.1-develop.7113.1.9d83dca10c → 0.7.1-develop.7121.1.734c263bda

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> }>