@open-mercato/core 0.8.1-develop.7296.1.2111d779db → 0.9.0

package/src/modules/catalog/lib/bulkCreateProducts.ts

@@ -0,0 +1,340 @@
+import type { AwilixContainer } from 'awilix'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { CommandBus, CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
+import { CatalogProduct } from '../data/entities'
+import type { ProductBulkCreateRow } from '../data/validators'
+import type { ProgressService, ProgressServiceContext } from '../../progress/lib/progressService'
+import {
+  MAX_CHECKPOINTED_FAILURES,
+  buildFirstRowIndexByKey,
+  encodePriorKeyRows,
+  findRecordCreatedByPreviousAttempt,
+  readCheckpoint,
+  readCheckpointInterval,
+} from './bulkCreateCheckpoint'
+
+export const CATALOG_PRODUCT_BULK_CREATE_QUEUE = 'catalog-product-bulk-create'
+
+export { getCatalogQueue } from './catalogQueue'
+
+export type CatalogProductBulkCreateFailureCode = 'sku_taken' | 'handle_taken' | 'command_failed'
+
+export type CatalogProductBulkCreateScope = {
+  organizationId: string
+  tenantId: string
+  userId?: string | null
+}
+
+export type CatalogProductBulkCreateJobPayload = {
+  progressJobId: string
+  items: ProductBulkCreateRow[]
+  scope: CatalogProductBulkCreateScope
+}
+
+export type CatalogProductBulkCreateFailure = {
+  index: number
+  title?: string
+  code: CatalogProductBulkCreateFailureCode
+  message: string
+}
+
+export type CatalogProductBulkCreateSummary = {
+  createdCount: number
+  failedCount: number
+  /**
+   * Not a complete list on a resumed run: it covers the rows the final attempt handled, while
+   * `createdCount` covers the whole batch. Iterate it for the ids it does carry, never as a
+   * substitute for `createdCount`.
+   */
+  createdIds: string[]
+  failedItems: CatalogProductBulkCreateFailure[]
+}
+
+function buildCommandContext(
+  scope: CatalogProductBulkCreateScope,
+  container: AwilixContainer,
+): CommandRuntimeContext {
+  return {
+    container,
+    auth: null,
+    organizationScope: {
+      selectedId: scope.organizationId,
+      filterIds: [scope.organizationId],
+      allowedIds: [scope.organizationId],
+      tenantId: scope.tenantId,
+    },
+    selectedOrganizationId: scope.organizationId,
+    organizationIds: [scope.organizationId],
+  }
+}
+
+function normalizeForLookup(value?: string | null): string | null {
+  if (typeof value !== 'string') return null
+  const trimmed = value.trim()
+  return trimmed.length ? trimmed : null
+}
+
+// Namespaced so a sku can never be confused with a handle that happens to spell the same string.
+function skuKey(sku: string): string {
+  return `sku:${sku}`
+}
+
+function handleKey(handle: string): string {
+  return `handle:${handle}`
+}
+
+/**
+ * Every key the row's product could be found under. `title` is deliberately absent: it carries no
+ * uniqueness constraint, so matching on it would let one row claim an unrelated product and
+ * silently drop itself from the batch.
+ */
+function naturalKeysOfRow(row: ProductBulkCreateRow): string[] {
+  const keys: string[] = []
+  const sku = normalizeForLookup(row.sku ?? null)
+  if (sku) keys.push(skuKey(sku))
+  const handle = normalizeForLookup(row.handle ?? null)
+  if (handle) keys.push(handleKey(handle))
+  return keys
+}
+
+/** The one key a row's record is reclaimed under on a resumed attempt; SKU wins when both exist. */
+function naturalKeyOfRow(row: ProductBulkCreateRow): string | null {
+  return naturalKeysOfRow(row)[0] ?? null
+}
+
+export async function createCatalogProductsWithProgress(params: {
+  container: AwilixContainer
+  progressJobId: string
+  items: ProductBulkCreateRow[]
+  scope: CatalogProductBulkCreateScope
+}): Promise<CatalogProductBulkCreateSummary> {
+  const { container, progressJobId, items, scope } = params
+  const commandBus = container.resolve('commandBus') as CommandBus
+  const progressService = container.resolve('progressService') as ProgressService
+  const em = container.resolve('em') as EntityManager
+  const progressContext: ProgressServiceContext = {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    userId: scope.userId,
+  }
+
+  const existingJob = await progressService.getJob(progressJobId, progressContext)
+  const priorCheckpoint = readCheckpoint<CatalogProductBulkCreateFailure>(existingJob?.meta)
+  const checkpointInterval = readCheckpointInterval(existingJob?.meta)
+  const startIndex = priorCheckpoint.lastCompletedRowIndex + 1
+
+  await progressService.startJob(progressJobId, progressContext)
+
+  // Batch pre-validation: fail rows referencing an already-taken sku or handle before ever
+  // calling the command, saving a DB round-trip for rows that are provably invalid up front.
+  // The same two queries also produce the key -> id map a resumed attempt uses to reclaim the
+  // records an interrupted attempt already created, so resume costs no extra query.
+  const distinctSkus = Array.from(new Set(
+    items
+      .map((item) => normalizeForLookup(item.sku ?? null))
+      .filter((value): value is string => value !== null),
+  ))
+  const distinctHandles = Array.from(new Set(
+    items
+      .map((item) => normalizeForLookup(item.handle ?? null))
+      .filter((value): value is string => value !== null),
+  ))
+  const existingKeyIds = new Map<string, string>()
+  const existingSkus = new Set<string>()
+  const existingHandles = new Set<string>()
+  if (distinctSkus.length) {
+    const rows = await em.find(CatalogProduct, {
+      sku: { $in: distinctSkus },
+      organizationId: scope.organizationId,
+      tenantId: scope.tenantId,
+      deletedAt: null,
+    })
+    for (const product of rows) {
+      const sku = product.sku as string
+      existingSkus.add(sku)
+      existingKeyIds.set(skuKey(sku), product.id)
+    }
+  }
+  if (distinctHandles.length) {
+    const rows = await em.find(CatalogProduct, {
+      handle: { $in: distinctHandles },
+      organizationId: scope.organizationId,
+      tenantId: scope.tenantId,
+      deletedAt: null,
+    })
+    for (const product of rows) {
+      const handle = product.handle as string
+      existingHandles.add(handle)
+      existingKeyIds.set(handleKey(handle), product.id)
+    }
+  }
+
+  // Recorded once, on the attempt that starts from row 0, and read back verbatim by every later
+  // attempt: after rows have been created the database can no longer tell which keys predate the
+  // job. This write rides the attempt's first `updateProgress`, which always persists (a fresh
+  // throttle entry has no last-persisted timestamp to throttle against), so it is durable before
+  // any row is created. A row counts as pre-existing when *any* of its keys is already taken, so a
+  // row whose handle is spoken for is never reclaimed on the strength of its free SKU.
+  const isFirstAttempt = priorCheckpoint.priorKeyRows === null
+  const priorKeyRowIndices: number[] = []
+  if (isFirstAttempt) {
+    items.forEach((item, index) => {
+      if (naturalKeysOfRow(item).some((key) => existingKeyIds.has(key))) priorKeyRowIndices.push(index)
+    })
+  }
+  await progressService.updateProgress(
+    progressJobId,
+    {
+      totalCount: items.length,
+      processedCount: startIndex,
+      ...(isFirstAttempt ? { meta: { priorKeyRows: encodePriorKeyRows(priorKeyRowIndices, items.length) } } : {}),
+    },
+    progressContext,
+  )
+
+  const resumeIndex = {
+    priorKeyRows: priorCheckpoint.priorKeyRows,
+    existingKeyIds,
+    firstRowIndexByKey: buildFirstRowIndexByKey(items, naturalKeysOfRow),
+  }
+  const reclaimedIds = new Set<string>()
+
+  const commandContext = buildCommandContext(scope, container)
+  // Seeded from the previous attempt's checkpoint so a resumed run's summary covers the whole
+  // batch rather than only the rows after the last durable checkpoint (see
+  // lib/bulkCreateCategories.ts for the failure this prevents).
+  const createdIds: string[] = [...priorCheckpoint.createdIds]
+  const failedItems: CatalogProductBulkCreateFailure[] = [...priorCheckpoint.failedItems]
+  let createdCount = priorCheckpoint.createdCount
+  let failedCount = priorCheckpoint.failedCount
+
+  const recordFailure = (failure: CatalogProductBulkCreateFailure) => {
+    failedItems.push(failure)
+    failedCount += 1
+  }
+
+  const buildSummary = (): CatalogProductBulkCreateSummary => ({
+    createdCount,
+    failedCount,
+    createdIds,
+    failedItems,
+  })
+
+  const checkpoint = async (index: number) => {
+    const processedCount = index + 1
+    if (processedCount % checkpointInterval === 0 || processedCount === items.length) {
+      await progressService.updateProgress(
+        progressJobId,
+        {
+          processedCount,
+          meta: {
+            lastCompletedRowIndex: index,
+            checkpointSummary: {
+              createdCount,
+              failedCount,
+              failedItems: failedItems.slice(0, MAX_CHECKPOINTED_FAILURES),
+            },
+          },
+        },
+        progressContext,
+      )
+    }
+  }
+
+  for (let index = startIndex; index < items.length; index += 1) {
+    // Polled at the head of the iteration and only on the checkpoint boundary — see
+    // lib/bulkCreateCategories.ts for the reasoning.
+    if ((index - startIndex) % checkpointInterval === 0) {
+      const cancelled = await progressService.isCancellationRequested(
+        progressJobId,
+        scope.tenantId,
+        scope.organizationId,
+      )
+      if (cancelled) {
+        const partialSummary = buildSummary()
+        await progressService.updateProgress(
+          progressJobId,
+          { meta: { resultSummary: partialSummary } },
+          progressContext,
+        )
+        await progressService.markCancelled(progressJobId, progressContext)
+        return partialSummary
+      }
+    }
+
+    const row = items[index]
+    const sku = normalizeForLookup(row.sku ?? null)
+    const handle = normalizeForLookup(row.handle ?? null)
+
+    // Reclaims a record an interrupted attempt of this job already created for this exact row,
+    // so it is neither duplicated nor reported as a conflict against itself. Every other row
+    // falls through to the normal path, including rows the classifier cannot speak for.
+    const reclaimedId = findRecordCreatedByPreviousAttempt(resumeIndex, index, naturalKeyOfRow(row), reclaimedIds)
+    if (reclaimedId) {
+      reclaimedIds.add(reclaimedId)
+      createdIds.push(reclaimedId)
+      createdCount += 1
+      await checkpoint(index)
+      continue
+    }
+
+    if (sku && existingSkus.has(sku)) {
+      recordFailure({
+        index,
+        title: row.title,
+        code: 'sku_taken',
+        message: 'Product SKU already exists for this organization.',
+      })
+      await checkpoint(index)
+      continue
+    }
+    if (handle && existingHandles.has(handle)) {
+      recordFailure({
+        index,
+        title: row.title,
+        code: 'handle_taken',
+        message: 'Product handle already exists for this organization.',
+      })
+      await checkpoint(index)
+      continue
+    }
+
+    try {
+      const { result } = await commandBus.execute<
+        ProductBulkCreateRow & { organizationId: string; tenantId: string },
+        { productId: string }
+      >('catalog.products.create', {
+        input: { ...row, organizationId: scope.organizationId, tenantId: scope.tenantId },
+        ctx: commandContext,
+      })
+      if (result?.productId) {
+        createdIds.push(result.productId)
+        createdCount += 1
+        if (sku) existingSkus.add(sku)
+        if (handle) existingHandles.add(handle)
+      } else {
+        // Recorded rather than dropped so `createdCount + failedCount` always accounts for
+        // every row in the batch.
+        recordFailure({
+          index,
+          title: row.title,
+          code: 'command_failed',
+          message: 'Product creation returned no product id.',
+        })
+      }
+    } catch (error) {
+      recordFailure({
+        index,
+        title: row.title,
+        code: 'command_failed',
+        message: error instanceof Error ? error.message : 'Product creation failed',
+      })
+    }
+
+    await checkpoint(index)
+  }
+
+  const summary = buildSummary()
+  await progressService.completeJob(progressJobId, { resultSummary: summary }, progressContext)
+  return summary
+}

package/src/modules/catalog/lib/bulkDelete.ts

@@ -2,12 +2,11 @@ import type { AwilixContainer } from 'awilix'
 import type { CommandBus, CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
 import { invalidateCrudCache } from '@open-mercato/shared/lib/crud/cache'
 import { runWithCacheTenant } from '@open-mercato/cache'
-import { createModuleQueue, type Queue } from '@open-mercato/queue'
 import type { ProgressService, ProgressServiceContext } from '../../progress/lib/progressService'
 
 export const CATALOG_PRODUCT_BULK_DELETE_QUEUE = 'catalog-product-bulk-delete'
 
-const queues = new Map<string, Queue<Record<string, unknown>>>()
+export { getCatalogQueue } from './catalogQueue'
 
 export type CatalogProductBulkDeleteScope = {
   organizationId: string
@@ -27,24 +26,21 @@ export type CatalogProductBulkDeleteSummary = {
 
 const BULK_DELETE_CACHE_ALIASES = ['catalog.products']
 
-export function getCatalogQueue(queueName: string): Queue<Record<string, unknown>> {
-  const existing = queues.get(queueName)
-  if (existing) return existing
-
-  const concurrency = Math.max(1, Number.parseInt(process.env.CATALOG_QUEUE_CONCURRENCY ?? '3', 10) || 3)
-  const created = createModuleQueue<Record<string, unknown>>(queueName, { concurrency })
-
-  queues.set(queueName, created)
-  return created
-}
-
 function buildCommandContext(
   scope: CatalogProductBulkDeleteScope,
   container: AwilixContainer,
 ): CommandRuntimeContext {
+  if (!scope.tenantId || !scope.organizationId || !scope.userId) {
+    throw new Error('[internal] Catalog bulk delete requires tenant, organization and user scope')
+  }
   return {
     container,
-    auth: null,
+    auth: {
+      sub: scope.userId,
+      tenantId: scope.tenantId,
+      orgId: scope.organizationId,
+      isSuperAdmin: false,
+    },
     organizationScope: {
       selectedId: scope.organizationId,
       filterIds: [scope.organizationId],

package/src/modules/catalog/lib/catalogQueue.ts

@@ -0,0 +1,14 @@
+import { createModuleQueue, type Queue } from '@open-mercato/queue'
+
+const queues = new Map<string, Queue<Record<string, unknown>>>()
+
+export function getCatalogQueue(queueName: string): Queue<Record<string, unknown>> {
+  const existing = queues.get(queueName)
+  if (existing) return existing
+
+  const concurrency = Math.max(1, Number.parseInt(process.env.CATALOG_QUEUE_CONCURRENCY ?? '3', 10) || 3)
+  const created = createModuleQueue<Record<string, unknown>>(queueName, { concurrency })
+
+  queues.set(queueName, created)
+  return created
+}

package/src/modules/catalog/lib/currencyOptions.ts

@@ -0,0 +1,28 @@
+import { readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+import { CURRENCY_OPTIONS_URL } from '@open-mercato/shared/modules/entities/kinds'
+import type { DictionaryOption } from '@open-mercato/core/modules/dictionaries/components/DictionaryEntrySelect'
+
+const CURRENCY_OPTIONS_LIMIT = 100
+
+type CurrencyOptionsPayload = {
+  items?: unknown
+}
+
+export async function loadCurrencyOptions(errorMessage: string): Promise<DictionaryOption[]> {
+  const payload = await readApiResultOrThrow<CurrencyOptionsPayload>(
+    `${CURRENCY_OPTIONS_URL}?limit=${CURRENCY_OPTIONS_LIMIT}`,
+    undefined,
+    { errorMessage },
+  )
+  const items = Array.isArray(payload?.items) ? payload.items : []
+  const options: DictionaryOption[] = []
+  for (const item of items) {
+    if (!item || typeof item !== 'object') continue
+    const record = item as Record<string, unknown>
+    const value = typeof record.value === 'string' ? record.value.trim().toUpperCase() : ''
+    if (!value) continue
+    const label = typeof record.label === 'string' && record.label.trim().length ? record.label.trim() : value
+    options.push({ value, label, color: null, icon: null })
+  }
+  return options
+}

package/src/modules/catalog/lib/productSearch.ts

@@ -0,0 +1,16 @@
+import { buildAccentInsensitiveSearchExpression } from '@open-mercato/shared/lib/db/accentInsensitiveSearch'
+
+/**
+ * Columns `GET /api/catalog/products?search=` matches against, in the order the
+ * GIN trigram index concatenates them. The list is shared with
+ * `migrations/Migration20260914120100` so the query predicate and the index
+ * expression cannot drift apart — when they do, PostgreSQL stops using the index
+ * without any error, it just gets slower.
+ *
+ * Property names and column names are identical for all five (single words, no
+ * camelCase), so this list doubles as the field list the encrypted-`ILIKE`
+ * diagnostic needs.
+ */
+export const PRODUCT_SEARCH_COLUMNS = ['title', 'subtitle', 'description', 'sku', 'handle'] as const
+
+export const PRODUCT_SEARCH_EXPRESSION_SQL = buildAccentInsensitiveSearchExpression(PRODUCT_SEARCH_COLUMNS)

package/src/modules/catalog/lib/seeds.ts

@@ -3,51 +3,10 @@ import type { AwilixContainer } from 'awilix'
 import { Dictionary, DictionaryEntry, type DictionaryManagerVisibility } from '@open-mercato/core/modules/dictionaries/data/entities'
 import { CatalogPriceKind } from '../data/entities'
 import { seedCatalogExamples } from '../seed/examples'
+import { CATALOG_UNIT_DEFAULTS } from './unitLabels'
 
 export type CatalogSeedScope = { tenantId: string; organizationId: string }
 
-const UNIT_DEFAULTS: Array<{ value: string; label: string; description?: string }> = [
-  { value: 'pc', label: 'Piece (piece)' },
-  { value: 'set', label: 'Set (piece)' },
-  { value: 'pkg', label: 'Package (piece)' },
-  { value: 'box', label: 'Box (piece)' },
-  { value: 'roll', label: 'Roll (piece)' },
-  { value: 'pair', label: 'Pair (piece)' },
-  { value: 'dozen', label: 'Dozen (piece)' },
-  { value: 'unit', label: 'Unit (piece)' },
-  { value: 'g', label: 'Gram (weight)' },
-  { value: 'kg', label: 'Kilogram (weight)' },
-  { value: 'mg', label: 'Milligram (weight)' },
-  { value: 'lb', label: 'Pound (weight)' },
-  { value: 'oz', label: 'Ounce (weight)' },
-  { value: 'ml', label: 'Milliliter (volume)' },
-  { value: 'l', label: 'Liter (volume)' },
-  { value: 'cl', label: 'Centiliter (volume)' },
-  { value: 'm3', label: 'Cubic Meter (volume)' },
-  { value: 'mm', label: 'Millimeter (length)' },
-  { value: 'cm', label: 'Centimeter (length)' },
-  { value: 'm', label: 'Meter (length)' },
-  { value: 'km', label: 'Kilometer (length)' },
-  { value: 'in', label: 'Inch (length)' },
-  { value: 'ft', label: 'Foot (length)' },
-  { value: 'm2', label: 'Square Meter (area)' },
-  { value: 'cm2', label: 'Square Centimeter (area)' },
-  { value: 'ft2', label: 'Square Foot (area)' },
-  { value: 'gb', label: 'Gigabyte (digital)' },
-  { value: 'mb', label: 'Megabyte (digital)' },
-  { value: 'tb', label: 'Terabyte (digital)' },
-  { value: 'license', label: 'License (digital)' },
-  { value: 'seat', label: 'Seat (digital)' },
-  { value: 'sec', label: 'Second (time)' },
-  { value: 'min', label: 'Minute (time)' },
-  { value: 'hour', label: 'Hour (time)' },
-  { value: 'day', label: 'Day (time)' },
-  { value: 'week', label: 'Week (time)' },
-  { value: 'month', label: 'Month (time)' },
-  { value: 'year', label: 'Year (time)' },
-  { value: 'kwh', label: 'Kilowatt Hour (energy)' },
-]
-
 const PRICE_KIND_DEFAULTS = [
   { code: 'regular', title: 'Regular', isPromotion: false, displayMode: 'including-tax' as const, currencyCode: 'USD' as const },
   { code: 'sale', title: 'Sale', isPromotion: true, displayMode: 'including-tax' as const, currencyCode: 'USD' as const },
@@ -85,7 +44,7 @@ export async function seedCatalogUnits(
     organizationId: scope.organizationId,
   })
   const existingMap = new Map(existingEntries.map((entry) => [entry.value.toLowerCase(), entry]))
-  for (const unit of UNIT_DEFAULTS) {
+  for (const unit of CATALOG_UNIT_DEFAULTS) {
     const key = unit.value.toLowerCase()
     if (existingMap.has(key)) continue
     const entry = em.create(DictionaryEntry, {

package/src/modules/catalog/lib/unitLabels.ts

@@ -0,0 +1,52 @@
+import type { TranslateFn } from '@open-mercato/shared/lib/i18n/context'
+
+export const CATALOG_UNIT_DEFAULTS = [
+  { value: 'pc', label: 'Piece (piece)', labelKey: 'catalog.units.pc' },
+  { value: 'set', label: 'Set (piece)', labelKey: 'catalog.units.set' },
+  { value: 'pkg', label: 'Package (piece)', labelKey: 'catalog.units.pkg' },
+  { value: 'box', label: 'Box (piece)', labelKey: 'catalog.units.box' },
+  { value: 'roll', label: 'Roll (piece)', labelKey: 'catalog.units.roll' },
+  { value: 'pair', label: 'Pair (piece)', labelKey: 'catalog.units.pair' },
+  { value: 'dozen', label: 'Dozen (piece)', labelKey: 'catalog.units.dozen' },
+  { value: 'unit', label: 'Unit (piece)', labelKey: 'catalog.units.unit' },
+  { value: 'g', label: 'Gram (weight)', labelKey: 'catalog.units.g' },
+  { value: 'kg', label: 'Kilogram (weight)', labelKey: 'catalog.units.kg' },
+  { value: 'mg', label: 'Milligram (weight)', labelKey: 'catalog.units.mg' },
+  { value: 'lb', label: 'Pound (weight)', labelKey: 'catalog.units.lb' },
+  { value: 'oz', label: 'Ounce (weight)', labelKey: 'catalog.units.oz' },
+  { value: 'ml', label: 'Milliliter (volume)', labelKey: 'catalog.units.ml' },
+  { value: 'l', label: 'Liter (volume)', labelKey: 'catalog.units.l' },
+  { value: 'cl', label: 'Centiliter (volume)', labelKey: 'catalog.units.cl' },
+  { value: 'm3', label: 'Cubic Meter (volume)', labelKey: 'catalog.units.m3' },
+  { value: 'mm', label: 'Millimeter (length)', labelKey: 'catalog.units.mm' },
+  { value: 'cm', label: 'Centimeter (length)', labelKey: 'catalog.units.cm' },
+  { value: 'm', label: 'Meter (length)', labelKey: 'catalog.units.m' },
+  { value: 'km', label: 'Kilometer (length)', labelKey: 'catalog.units.km' },
+  { value: 'in', label: 'Inch (length)', labelKey: 'catalog.units.in' },
+  { value: 'ft', label: 'Foot (length)', labelKey: 'catalog.units.ft' },
+  { value: 'm2', label: 'Square Meter (area)', labelKey: 'catalog.units.m2' },
+  { value: 'cm2', label: 'Square Centimeter (area)', labelKey: 'catalog.units.cm2' },
+  { value: 'ft2', label: 'Square Foot (area)', labelKey: 'catalog.units.ft2' },
+  { value: 'gb', label: 'Gigabyte (digital)', labelKey: 'catalog.units.gb' },
+  { value: 'mb', label: 'Megabyte (digital)', labelKey: 'catalog.units.mb' },
+  { value: 'tb', label: 'Terabyte (digital)', labelKey: 'catalog.units.tb' },
+  { value: 'license', label: 'License (digital)', labelKey: 'catalog.units.license' },
+  { value: 'seat', label: 'Seat (digital)', labelKey: 'catalog.units.seat' },
+  { value: 'sec', label: 'Second (time)', labelKey: 'catalog.units.sec' },
+  { value: 'min', label: 'Minute (time)', labelKey: 'catalog.units.min' },
+  { value: 'hour', label: 'Hour (time)', labelKey: 'catalog.units.hour' },
+  { value: 'day', label: 'Day (time)', labelKey: 'catalog.units.day' },
+  { value: 'week', label: 'Week (time)', labelKey: 'catalog.units.week' },
+  { value: 'month', label: 'Month (time)', labelKey: 'catalog.units.month' },
+  { value: 'year', label: 'Year (time)', labelKey: 'catalog.units.year' },
+  { value: 'kwh', label: 'Kilowatt Hour (energy)', labelKey: 'catalog.units.kwh' },
+] as const
+
+const defaultsByCode = new Map<string, (typeof CATALOG_UNIT_DEFAULTS)[number]>(
+  CATALOG_UNIT_DEFAULTS.map((unit) => [unit.value, unit]),
+)
+
+export function translateCatalogUnitLabel(value: string, label: string, t: TranslateFn): string {
+  const unit = defaultsByCode.get(value.toLowerCase())
+  return unit && label === unit.label ? t(unit.labelKey, label) : label
+}

package/src/modules/catalog/migrations/Migration20260914120000.ts

@@ -0,0 +1,51 @@
+import { Migration } from '@mikro-orm/migrations';
+
+// Installs the two PostgreSQL extensions accent-insensitive product search needs
+// (see Migration20260914120100, which creates the wrapper function and the index
+// on top of them). They are separate migrations on purpose: `unaccent` must be a
+// committed extension before a function body can pin its dictionary with
+// `'public.unaccent'::regdictionary`, and the index is built CONCURRENTLY, which
+// cannot run inside a transaction.
+//
+// `create extension` needs CREATE on the database, which the application role
+// does not always hold on managed PostgreSQL. Failing here aborts the whole
+// `yarn db:migrate` run — every later module's migrations included — so the bare
+// permission error is turned into a message that names what to grant. The check
+// runs only when the extension is actually missing, so an instance where an
+// operator pre-created them needs no extra privilege.
+//
+// Two distinct SQLSTATEs cover the ways this can fail: `insufficient_privilege`
+// (42501) when the role itself lacks CREATE, and `feature_not_supported`
+// (0A000) on managed providers (e.g. RDS) that reject an extension outright for
+// not being on their allowlist, independent of the role's own privileges.
+const ensureExtensionSql = (extension: string): string => `
+  do $$
+  begin
+    if not exists (select 1 from pg_extension where extname = '${extension}') then
+      begin
+        execute 'create extension if not exists "${extension}" schema public';
+      exception when insufficient_privilege or feature_not_supported then
+        raise exception using
+          errcode = 'insufficient_privilege',
+          message = 'Open Mercato requires the PostgreSQL "${extension}" extension for accent-insensitive catalog search, and this role may not create it.',
+          hint = 'Connect as a superuser (or allowlist the extension on managed PostgreSQL) and run: CREATE EXTENSION IF NOT EXISTS "${extension}" SCHEMA public; then re-run yarn db:migrate.';
+      end;
+    end if;
+  end
+  $$;
+`;
+
+export class Migration20260914120000 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(ensureExtensionSql('unaccent'));
+    this.addSql(ensureExtensionSql('pg_trgm'));
+  }
+
+  override async down(): Promise<void> {
+    // The extensions are deliberately left in place: other schemas may have come
+    // to depend on them, and dropping an extension cascades to everything built
+    // on it. Migration20260914120100 removes what this module actually owns.
+  }
+
+}

package/src/modules/catalog/migrations/Migration20260914120100.ts

@@ -0,0 +1,50 @@
+import { Migration } from '@mikro-orm/migrations';
+import {
+  IMMUTABLE_UNACCENT_FUNCTION,
+  buildImmutableUnaccentFunctionSql,
+} from '@open-mercato/shared/lib/db/accentInsensitiveSearch';
+import { PRODUCT_SEARCH_EXPRESSION_SQL } from '../lib/productSearch';
+
+export const CATALOG_PRODUCT_SEARCH_INDEX = 'catalog_products_search_trgm_idx';
+
+// Accent-insensitive product search (#6074). The wrapper function and the GIN
+// trigram index are built from the same expression builder the query uses
+// (lib/productSearch.ts), because PostgreSQL only uses an expression index when
+// the predicate is spelled identically — a drift here degrades silently to a
+// sequential scan rather than failing.
+//
+// The extensions come from Migration20260914120000, already committed by the
+// time this runs, so the function body can pin the dictionary with
+// `'public.unaccent'::regdictionary` instead of resolving it through search_path.
+//
+// catalog_products is high-churn and this index covers the concatenation of five
+// text columns including the full description, so the build is slow enough that
+// a plain CREATE INDEX would hold its SHARE lock — blocking every product write
+// — for the length of a deploy. It is therefore built CONCURRENTLY, which cannot
+// run inside a transaction, hence isTransactional() => false; the migration
+// runner applies migrations one-by-one, so this opt-out is safe. Drop first so
+// retrying an interrupted concurrent build removes PostgreSQL's INVALID index
+// stub instead of letting IF NOT EXISTS report success over an unusable index.
+// Same shape as sales/Migration20260821120000 and
+// query_index/Migration20260731105052.
+export class Migration20260914120100 extends Migration {
+
+  override isTransactional(): boolean {
+    return false;
+  }
+
+  override async up(): Promise<void> {
+    this.addSql(buildImmutableUnaccentFunctionSql());
+    this.addSql(`drop index concurrently if exists "${CATALOG_PRODUCT_SEARCH_INDEX}";`);
+    this.addSql(
+      `create index concurrently "${CATALOG_PRODUCT_SEARCH_INDEX}" on "catalog_products" using gin (${PRODUCT_SEARCH_EXPRESSION_SQL} gin_trgm_ops);`,
+    );
+  }
+
+  override async down(): Promise<void> {
+    // The index depends on the function, so it must go first.
+    this.addSql(`drop index concurrently if exists "${CATALOG_PRODUCT_SEARCH_INDEX}";`);
+    this.addSql(`drop function if exists ${IMMUTABLE_UNACCENT_FUNCTION}(text);`);
+  }
+
+}