@open-mercato/core 0.6.6-develop.6401.1.8c07df34a7 → 0.6.6-develop.6403.1.b57089b6fe

package/src/modules/planner/commands/availability-weekly.ts

@@ -8,14 +8,24 @@ import {
   type PlannerAvailabilityWeeklyReplaceInput,
 } from '../data/validators'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
-import type { PlannerAvailabilityKind, PlannerAvailabilitySubjectType } from '../data/entities'
+import { emitCrudSideEffects } from '@open-mercato/shared/lib/commands/helpers'
 import {
   enforceCommandOptimisticLock,
   enforceRecordGoneIsConflict,
 } from '@open-mercato/shared/lib/crud/optimistic-lock-command'
+import type { DataEngine } from '@open-mercato/shared/lib/data/engine'
+import type { CrudIndexerConfig } from '@open-mercato/shared/lib/crud/types'
+import type { PlannerAvailabilityKind, PlannerAvailabilitySubjectType } from '../data/entities'
 import { ensureOrganizationScope, ensureTenantScope, extractUndoPayload } from './shared'
+import { plannerAvailabilityRuleSetCrudEvents } from '../lib/crud'
+import { E } from '#generated/entities.ids.generated'
 
 const AVAILABILITY_RULE_RESOURCE_KIND = 'planner.availability.rule'
+const AVAILABILITY_RULE_SET_CACHE_RESOURCE_KIND = 'planner.availability-rule-set'
+
+const availabilityRuleSetCrudIndexer: CrudIndexerConfig<PlannerAvailabilityRuleSet> = {
+  entityType: E.planner.planner_availability_rule_set,
+}
 
 // Canonical resource kind for the parent rule set, matching the tag the CRUD
 // factory derives for `planner.availability-rule-sets.*` commands. Weekly
@@ -95,6 +105,14 @@ function toAvailabilityRuleSnapshot(record: PlannerAvailabilityRule): Availabili
   }
 }
 
+function nextRuleSetUpdatedAt(current: Date | null | undefined, fallback: Date): Date {
+  const currentMs = current instanceof Date ? current.getTime() : Number.NaN
+  if (Number.isFinite(currentMs) && fallback.getTime() <= currentMs) {
+    return new Date(currentMs + 1)
+  }
+  return fallback
+}
+
 async function loadWeeklySnapshots(
   em: EntityManager,
   params: {
@@ -173,12 +191,12 @@ const replaceWeeklyAvailabilityCommand: CommandHandler<PlannerAvailabilityWeekly
     const em = (ctx.container.resolve('em') as EntityManager).fork()
     const now = new Date()
 
-    await em.transactional(async (trx) => {
-      // The weekly rules of a rule set are a sub-resource of that rule set: the
-      // parent is the optimistic-lock consistency boundary. Guard the parent's
-      // version (so a stale weekly save loses to a concurrent rule-set
-      // change/delete) and bump its `updated_at` after the replace (so a
-      // concurrent rule-set delete/update with a stale token conflicts). See #2927.
+    // The weekly rules of a rule set are a sub-resource of that rule set: the
+    // parent is the optimistic-lock consistency boundary. Guard the parent's
+    // version (so a stale weekly save loses to a concurrent rule-set
+    // change/delete) and bump its `updated_at` after the replace (so a
+    // concurrent rule-set delete/update with a stale token conflicts). See #2927.
+    const touchedRuleSet = await em.transactional(async (trx): Promise<PlannerAvailabilityRuleSet | null> => {
       let ruleSet: PlannerAvailabilityRuleSet | null = null
       if (parsed.subjectType === 'ruleset') {
         ruleSet = await trx.findOne(PlannerAvailabilityRuleSet, {
@@ -250,13 +268,30 @@ const replaceWeeklyAvailabilityCommand: CommandHandler<PlannerAvailabilityWeekly
       })
 
       if (ruleSet) {
-        ruleSet.updatedAt = now
+        ruleSet.updatedAt = nextRuleSetUpdatedAt(ruleSet.updatedAt, now)
         trx.persist(ruleSet)
       }
 
       await trx.flush()
+      return ruleSet
     })
 
+    if (touchedRuleSet) {
+      const dataEngine = ctx.container.resolve('dataEngine') as DataEngine
+      await emitCrudSideEffects({
+        dataEngine,
+        action: 'updated',
+        entity: touchedRuleSet,
+        identifiers: {
+          id: touchedRuleSet.id,
+          organizationId: touchedRuleSet.organizationId,
+          tenantId: touchedRuleSet.tenantId,
+        },
+        events: plannerAvailabilityRuleSetCrudEvents,
+        indexer: availabilityRuleSetCrudIndexer,
+      })
+    }
+
     return { ok: true }
   },
   buildLog: async ({ input, snapshots, ctx }) => {
@@ -284,6 +319,9 @@ const replaceWeeklyAvailabilityCommand: CommandHandler<PlannerAvailabilityWeekly
           after,
         } satisfies WeeklyUndoPayload,
       },
+      context: parsed.subjectType === 'ruleset'
+        ? { cacheAliases: [AVAILABILITY_RULE_SET_CACHE_RESOURCE_KIND] }
+        : null,
     }
   },
   undo: async ({ logEntry, ctx }) => {

package/src/modules/planner/components/AvailabilityRulesEditor.tsx

@@ -19,6 +19,7 @@ import { createCrud, deleteCrud, updateCrud } from '@open-mercato/ui/backend/uti
 import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
 import { buildOptimisticLockHeader } from '@open-mercato/ui/backend/utils/optimisticLock'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { surfaceRecordConflict } from '@open-mercato/ui/backend/conflicts'
 import { Spinner } from '@open-mercato/ui/primitives/spinner'
 import { ComboboxInput, TimePicker } from '@open-mercato/ui/backend/inputs'
 import { DictionaryEntrySelect, type DictionarySelectLabels } from '@open-mercato/core/modules/dictionaries/components/DictionaryEntrySelect'
@@ -30,7 +31,6 @@ import {
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
 import { normalizeCrudServerError } from '@open-mercato/ui/backend/utils/serverErrors'
-import { surfaceRecordConflict } from '@open-mercato/ui/backend/conflicts'
 import { parseAvailabilityRuleWindow } from '@open-mercato/core/modules/planner/lib/availabilitySchedule'
 import { deleteAvailabilityRuleSet } from '@open-mercato/core/modules/planner/lib/deleteAvailabilityRuleSet'
 import { CrudForm, type CrudField } from '@open-mercato/ui/backend/CrudForm'
@@ -778,6 +778,12 @@ export function AvailabilityRulesEditor({
     void refreshBookedEvents()
   }, [refreshBookedEvents])
 
+  const refreshAfterRuleSetConflict = React.useCallback(() => {
+    void refreshRuleSets()
+    void refreshRuleSetRules()
+    void refreshAvailability()
+  }, [refreshAvailability, refreshRuleSetRules, refreshRuleSets])
+
   const weeklyDraft = React.useMemo(() => buildWeeklyDraft(activeRules), [activeRules])
   const [weeklyWindows, setWeeklyWindows] = React.useState<WeeklyWindows>(() => cloneWeeklyWindows(weeklyDraft))
   const weeklyWindowsRef = React.useRef<WeeklyWindows>(cloneWeeklyWindows(weeklyDraft))
@@ -893,14 +899,15 @@ export function AvailabilityRulesEditor({
       if (!shouldSkipRefresh) {
         await refreshAvailability()
         await refreshRuleSetRules()
+        if (usingRuleSet) {
+          await refreshRuleSets()
+        }
       }
       if (parentRuleSet) {
         await refreshRuleSets()
       }
     } catch (error) {
-      if (surfaceRecordConflict(error, t)) {
-        return
-      }
+      if (surfaceRecordConflict(error, t, { onRefresh: refreshAfterRuleSetConflict })) return
       const message = error instanceof Error ? error.message : listLabels.saveWeeklyError
       flash(message, 'error')
     } finally {
@@ -912,8 +919,9 @@ export function AvailabilityRulesEditor({
     refreshAvailability,
     refreshRuleSetRules,
     refreshRuleSets,
-    ruleSets,
+    refreshAfterRuleSetConflict,
     effectiveRulesetId,
+    ruleSets,
     subjectId,
     subjectType,
     t,
@@ -1180,7 +1188,7 @@ export function AvailabilityRulesEditor({
       refreshRuleSets,
       onSuccess: () => flash(listLabels.ruleSetDeleteSuccess, 'success'),
       onError: (error) => {
-        if (surfaceRecordConflict(error, t)) return
+        if (surfaceRecordConflict(error, t, { onRefresh: refreshAfterRuleSetConflict })) return
         console.error('planner.availability-rule-sets.delete', error)
         const normalized = normalizeCrudServerError(error)
         flash(normalized.message ?? listLabels.ruleSetDeleteError, 'error')
@@ -1195,6 +1203,7 @@ export function AvailabilityRulesEditor({
     listLabels.ruleSetDeleteSuccess,
     onRulesetChange,
     refreshAvailability,
+    refreshAfterRuleSetConflict,
     refreshRuleSets,
     ruleSets,
     rulesetId,

package/src/modules/sales/cli.ts

@@ -1,7 +1,7 @@
 import type { ModuleCli } from '@open-mercato/shared/modules/registry'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import type { EntityManager } from '@mikro-orm/postgresql'
-import { seedSalesAdjustmentKinds, seedSalesStatusDictionaries } from './lib/dictionaries'
+import { backfillDealLossReasonDictionary, seedSalesAdjustmentKinds, seedSalesStatusDictionaries } from './lib/dictionaries'
 import { seedSalesTaxRates } from './lib/seeds'
 import { ensureExamplePaymentMethods, ensureExampleShippingMethods } from './seed/examples-data'
 import { seedSalesExamples } from './seed/examples'
@@ -103,6 +103,43 @@ const seedAdjustmentKindsCommand: ModuleCli = {
   },
 }
 
+const backfillDealLossReasonsCommand: ModuleCli = {
+  command: 'backfill-deal-loss-reasons',
+  async run(rest) {
+    const args = parseArgs(rest)
+    const tenantId = String(args.tenantId ?? args.tenant ?? '')
+    const organizationId = String(args.organizationId ?? args.org ?? args.orgId ?? '')
+    if (!tenantId || !organizationId) {
+      console.error('Usage: mercato sales backfill-deal-loss-reasons --tenant <tenantId> --org <organizationId>')
+      return
+    }
+    const container = await createRequestContainer()
+    try {
+      const em = container.resolve<EntityManager>('em')
+      const result = await em.transactional(async (tem) => {
+        const backfillResult = await backfillDealLossReasonDictionary(tem, { tenantId, organizationId })
+        await tem.flush()
+        return backfillResult
+      })
+      console.log(
+        [
+          `Deal loss reasons dictionary ready for organization ${organizationId}.`,
+          `dictionaryId=${result.dictionaryId}`,
+          `createdDictionary=${String(result.createdDictionary)}`,
+          `copiedLegacyEntries=${String(result.copiedLegacyEntries)}`,
+          `seededDefaultEntries=${String(result.seededDefaultEntries)}`,
+          `existingEntries=${String(result.existingEntries)}`,
+        ].join(' '),
+      )
+    } finally {
+      const disposable = container as unknown as { dispose?: () => Promise<void> }
+      if (typeof disposable.dispose === 'function') {
+        await disposable.dispose()
+      }
+    }
+  },
+}
+
 const seedShippingMethodsCommand: ModuleCli = {
   command: 'seed-shipping-methods',
   async run(rest) {
@@ -189,6 +226,7 @@ export default [
   seedTaxRatesCommand,
   seedStatusesCommand,
   seedAdjustmentKindsCommand,
+  backfillDealLossReasonsCommand,
   seedShippingMethodsCommand,
   seedPaymentMethodsCommand,
   seedExamplesCommand,

package/src/modules/sales/lib/dictionaries.ts

@@ -133,6 +133,14 @@ type SalesDictionarySeed = {
 
 type SeedScope = { tenantId: string; organizationId: string }
 
+export type BackfillDealLossReasonDictionaryResult = {
+  dictionaryId: string
+  createdDictionary: boolean
+  copiedLegacyEntries: number
+  seededDefaultEntries: number
+  existingEntries: number
+}
+
 const ORDER_STATUS_DEFAULTS: SalesDictionarySeed[] = [
   { value: 'draft', label: 'Draft', color: '#94a3b8', icon: 'lucide:file-pen-line' },
   { value: 'pending_approval', label: 'Pending Approval', color: '#f59e0b', icon: 'lucide:hourglass' },
@@ -262,6 +270,88 @@ const DEAL_LOSS_REASON_DEFAULTS: SalesDictionarySeed[] = [
   { value: 'other', label: 'Other', color: '#71717a', icon: 'lucide:minus-circle' },
 ]
 
+export async function backfillDealLossReasonDictionary(
+  em: EntityManager,
+  scope: SeedScope
+): Promise<BackfillDealLossReasonDictionaryResult> {
+  const definition = getSalesDictionaryDefinition('deal-loss-reasons')
+  const existingDictionary = await em.findOne(Dictionary, {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    key: definition.key,
+    deletedAt: null,
+  })
+  const dictionary = existingDictionary ?? await ensureSalesDictionary({
+    em,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    kind: 'deal-loss-reasons',
+  })
+  const targetEntries = await em.find(DictionaryEntry, {
+    dictionary,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+  })
+
+  if (targetEntries.length > 0) {
+    return {
+      dictionaryId: dictionary.id,
+      createdDictionary: !existingDictionary,
+      copiedLegacyEntries: 0,
+      seededDefaultEntries: 0,
+      existingEntries: targetEntries.length,
+    }
+  }
+
+  const legacyDictionary = await em.findOne(Dictionary, {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    key: 'customer_lost_reason',
+    deletedAt: null,
+  })
+  const legacyEntries = legacyDictionary
+    ? await em.find(
+      DictionaryEntry,
+      {
+        dictionary: legacyDictionary,
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId,
+      },
+      { orderBy: { position: 'asc', label: 'asc' } },
+    )
+    : []
+
+  let copiedLegacyEntries = 0
+  let seededDefaultEntries = 0
+  const processedValues = new Set<string>()
+  const seeds = legacyEntries.length
+    ? legacyEntries.map((entry) => ({
+      value: entry.value,
+      label: entry.label,
+      color: entry.color,
+      icon: entry.icon,
+    }))
+    : DEAL_LOSS_REASON_DEFAULTS
+
+  for (const seed of seeds) {
+    const normalizedValue = normalizeDictionaryValue(seed.value ?? '')
+    if (!normalizedValue || processedValues.has(normalizedValue)) continue
+    const entry = await ensureSalesDictionaryEntry(em, scope, 'deal-loss-reasons', seed)
+    if (!entry) continue
+    processedValues.add(normalizedValue)
+    if (legacyEntries.length) copiedLegacyEntries += 1
+    else seededDefaultEntries += 1
+  }
+
+  return {
+    dictionaryId: dictionary.id,
+    createdDictionary: !existingDictionary,
+    copiedLegacyEntries,
+    seededDefaultEntries,
+    existingEntries: 0,
+  }
+}
+
 export async function seedSalesStatusDictionaries(
   em: EntityManager,
   scope: SeedScope