@open-mercato/core 0.8.1-develop.7207.1.901ef7e47a → 0.8.1-develop.7215.1.60786cf836

package/src/modules/catalog/components/products/ProductUomSection.tsx

@@ -57,15 +57,6 @@ const REFERENCE_UNIT_OPTIONS = REFERENCE_UNIT_CODES.map((code) => ({
   fallback: REFERENCE_UNIT_DISPLAY[code] ?? code,
 }));
 
-// Keeps the field submit-ready (dot-decimal, no grouping characters) while the user is
-// still typing. Falls back to the raw value when it isn't parseable yet (empty, a lone
-// sign) so the field stays editable. Delegates to `parseLocaleNumber` instead of a
-// hard-coded `,` -> `.` swap, which broke on grouped input such as `1 234,56` (#5828).
-export function normalizeDecimalInput(value: string, locale?: string): string {
-  const parsed = parseLocaleNumber(value, locale);
-  return parsed === null ? value : String(parsed);
-}
-
 export function toPositiveNumber(value: unknown, locale?: string): number | null {
   if (typeof value === "number") {
     return Number.isFinite(value) && value > 0 ? value : null;
@@ -88,10 +79,7 @@ function formatPreviewNumber(value: number): string {
   return Number.isInteger(rounded) ? String(rounded) : rounded.toString();
 }
 
-function normalizeConversions(
-  value: unknown,
-  locale?: string,
-): ProductUnitConversionDraft[] {
+function normalizeConversions(value: unknown): ProductUnitConversionDraft[] {
   if (!Array.isArray(value)) return [];
   const normalized = value
     .map((entry) => {
@@ -100,9 +88,9 @@ function normalizeConversions(
       return {
         id: toTrimmedOrNull(row.id) ?? null,
         unitCode: toTrimmedOrNull(row.unitCode) ?? "",
-        toBaseFactor: toTrimmedOrNull(row.toBaseFactor)
-          ? normalizeDecimalInput(toTrimmedOrNull(row.toBaseFactor) as string, locale)
-          : "",
+        // Stays raw while editing (issue #5828) — re-serializing on every render would drop
+        // an in-progress decimal separator the instant it's typed.
+        toBaseFactor: toTrimmedOrNull(row.toBaseFactor) ?? "",
         sortOrder: toTrimmedOrNull(row.sortOrder) ?? "",
         isActive: row.isActive !== false,
       } satisfies ProductUnitConversionDraft;
@@ -150,8 +138,8 @@ export function ProductUomSection({
   const [loadingUnits, setLoadingUnits] = React.useState(false);
   const [errorLoadingUnits, setErrorLoadingUnits] = React.useState(false);
   const conversions = React.useMemo(
-    () => normalizeConversions(values.unitConversions, locale),
-    [values.unitConversions, locale],
+    () => normalizeConversions(values.unitConversions),
+    [values.unitConversions],
   );
 
   React.useEffect(() => {
@@ -246,15 +234,13 @@ export function ProductUomSection({
 
   const defaultUnit = toTrimmedOrNull(values.defaultUnit) ?? "";
   const defaultSalesUnit = toTrimmedOrNull(values.defaultSalesUnit) ?? "";
-  const defaultSalesQuantityRaw =
+  const defaultSalesQuantity =
     toTrimmedOrNull(values.defaultSalesUnitQuantity) ?? "1";
-  const defaultSalesQuantity = normalizeDecimalInput(defaultSalesQuantityRaw, locale);
   const unitPriceEnabled = Boolean(values.unitPriceEnabled);
   const unitPriceReferenceUnit =
     toTrimmedOrNull(values.unitPriceReferenceUnit) ?? "";
-  const unitPriceBaseQuantityRaw =
+  const unitPriceBaseQuantity =
     toTrimmedOrNull(values.unitPriceBaseQuantity) ?? "";
-  const unitPriceBaseQuantity = normalizeDecimalInput(unitPriceBaseQuantityRaw, locale);
 
   const baseUnitLabel = findUnitLabel(defaultUnit) ?? defaultUnit;
   const salesUnitLabel =
@@ -396,10 +382,7 @@ export function ProductUomSection({
             inputMode="decimal"
             value={defaultSalesQuantity}
             onChange={(event) =>
-              setValue(
-                "defaultSalesUnitQuantity",
-                normalizeDecimalInput(event.target.value, locale),
-              )
+              setValue("defaultSalesUnitQuantity", event.target.value)
             }
             placeholder="1"
           />
@@ -549,10 +532,7 @@ export function ProductUomSection({
                 inputMode="decimal"
                 value={unitPriceBaseQuantity}
                 onChange={(event) =>
-                  setValue(
-                    "unitPriceBaseQuantity",
-                    normalizeDecimalInput(event.target.value, locale),
-                  )
+                  setValue("unitPriceBaseQuantity", event.target.value)
                 }
                 placeholder="1"
               />
@@ -663,7 +643,7 @@ export function ProductUomSection({
                     value={entry.toBaseFactor}
                     onChange={(event) =>
                       updateConversion(index, {
-                        toBaseFactor: normalizeDecimalInput(event.target.value, locale),
+                        toBaseFactor: event.target.value,
                       })
                     }
                     placeholder="1"

package/src/modules/catalog/components/products/productForm.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { slugify } from "@open-mercato/shared/lib/slugify";
 import { parseObjectLike } from "@open-mercato/shared/lib/json/parseObjectLike";
+import { parseLocaleNumber } from "@open-mercato/shared/lib/number";
 import type { ReferenceUnitCode } from "@open-mercato/shared/lib/units/unitCodes";
 import {
   CATALOG_CONFIGURABLE_PRODUCT_TYPES,
@@ -348,6 +349,58 @@ export const productFormSchema = z
     { message: 'catalog.products.validation.availabilityDateRange', path: ['availableUntil'] }
   );
 
+// The UoM fields below stay raw locale-typed text while the user is editing them
+// (`ProductUomSection`, issue #5828), so `z.coerce.number()` — which only accepts a dot
+// decimal separator — cannot parse them directly. Convert to a canonical dot-decimal string
+// right before validation; an unparseable value is left as-is so the schema's own "expected
+// number" error still fires.
+function toCanonicalDecimalString(raw: string, locale?: string): string {
+  if (!raw.trim()) return raw;
+  const parsed = parseLocaleNumber(raw, locale);
+  return parsed === null ? raw : String(parsed);
+}
+
+export function withCanonicalUomFields(
+  values: ProductFormValues,
+  locale?: string,
+): ProductFormValues {
+  return {
+    ...values,
+    defaultSalesUnitQuantity:
+      typeof values.defaultSalesUnitQuantity === "string"
+        ? toCanonicalDecimalString(values.defaultSalesUnitQuantity, locale)
+        : values.defaultSalesUnitQuantity,
+    unitPriceBaseQuantity:
+      typeof values.unitPriceBaseQuantity === "string"
+        ? toCanonicalDecimalString(values.unitPriceBaseQuantity, locale)
+        : values.unitPriceBaseQuantity,
+    unitConversions: Array.isArray(values.unitConversions)
+      ? values.unitConversions.map((conversion) => ({
+          ...conversion,
+          toBaseFactor:
+            typeof conversion?.toBaseFactor === "string"
+              ? toCanonicalDecimalString(conversion.toBaseFactor, locale)
+              : conversion?.toBaseFactor,
+        }))
+      : values.unitConversions,
+  };
+}
+
+// `CrudForm`'s `schema` prop runs validation internally, before `onSubmit` — so a page that
+// passes `productFormSchema` there directly (rather than calling `.safeParse` by hand inside
+// `onSubmit`, as the edit page does) needs the UoM canonicalization baked into the schema
+// itself. `locale` is only known at render time, so this builds the wrapped schema per-locale
+// rather than exporting a single module-level constant.
+export function buildLocaleAwareProductFormSchema(locale?: string): z.ZodType<ProductFormValues> {
+  return z.preprocess(
+    (raw) =>
+      raw && typeof raw === "object"
+        ? withCanonicalUomFields(raw as ProductFormValues, locale)
+        : raw,
+    productFormSchema,
+  ) as unknown as z.ZodType<ProductFormValues>;
+}
+
 export const PRODUCT_FORM_STEPS = [
   "general",
   "organize",

package/src/modules/configs/lib/upgrade-actions.ts

@@ -21,6 +21,12 @@ export type UpgradeActionDefinition = {
   ctaKey: string
   successKey: string
   loadingKey?: string
+  /**
+   * Modules that must be enabled for this action to be offered/executed.
+   * Mirrors `InjectionWidgetMetadata.requiredModules` — omit for actions
+   * owned by `configs` itself.
+   */
+  requiredModules?: string[]
   run: (ctx: UpgradeActionContext) => Promise<void>
 }
 
@@ -119,6 +125,7 @@ export const upgradeActions: UpgradeActionDefinition[] = [
     ctaKey: 'payment_gateways.upgradeActions.sessionInitializationPrune.cta',
     successKey: 'payment_gateways.upgradeActions.sessionInitializationPrune.success',
     loadingKey: 'payment_gateways.upgradeActions.sessionInitializationPrune.loading',
+    requiredModules: ['payment_gateways'],
     run: async ({ container, tenantId, organizationId }) => {
       const { registerSessionInitializationPruneSchedule } = await import(
         '@open-mercato/core/modules/payment_gateways/setup'

package/src/modules/configs/services/upgradeActionsService.ts

@@ -3,6 +3,7 @@ import type { EntityManager } from '@mikro-orm/postgresql'
 import type { AwilixContainer } from 'awilix'
 import { appVersion } from '@open-mercato/shared/lib/version'
 import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
+import { getEnabledModuleIds } from '@open-mercato/shared/security/enabledModulesRegistry'
 import { UpgradeActionRun } from '../data/entities'
 import { actionsUpToVersion, findUpgradeAction, type UpgradeActionDefinition } from '../lib/upgrade-actions'
 import { createLogger } from '@open-mercato/shared/lib/logger'
@@ -19,6 +20,18 @@ export function getCurrentVersion(): string {
   return appVersion
 }
 
+/**
+ * An action with no `requiredModules` is owned by `configs` itself and is
+ * always available. Fails closed when the module registry is empty/unavailable,
+ * mirroring `isDocumentEntityRegistryModuleEnabled`.
+ */
+function isActionModuleEnabled(definition: UpgradeActionDefinition): boolean {
+  const required = definition.requiredModules
+  if (!Array.isArray(required) || required.length === 0) return true
+  const enabledModuleIds = new Set(getEnabledModuleIds())
+  return required.every((moduleId) => enabledModuleIds.has(moduleId))
+}
+
 export async function listPendingUpgradeActions(
   em: EntityManager,
   {
@@ -37,7 +50,9 @@ export async function listPendingUpgradeActions(
     version: { $in: versions },
   })
   const completed = new Set(runs.map((run) => `${run.version}::${run.actionId}`))
-  return definitions.filter((definition) => !completed.has(`${definition.version}::${definition.id}`))
+  return definitions
+    .filter((definition) => !completed.has(`${definition.version}::${definition.id}`))
+    .filter(isActionModuleEnabled)
 }
 
 export async function executeUpgradeAction(
@@ -53,7 +68,7 @@ export async function executeUpgradeAction(
     throw new Error('UPGRADE_ACTIONS_DISABLED')
   }
   const definition = findUpgradeAction(actionId, version)
-  if (!definition) {
+  if (!definition || !isActionModuleEnabled(definition)) {
     throw new Error('UPGRADE_ACTION_NOT_AVAILABLE')
   }
   const em = container.resolve<EntityManager>('em')

package/src/modules/entities/lib/definition-scope-where.ts

@@ -0,0 +1,27 @@
+export type DefinitionScopeClauseInput = {
+  organizationId?: string | null
+  tenantId?: string | null
+}
+
+// SQL `IN (?, NULL)` never matches rows where the column IS NULL, so a scope
+// filter that mixes a concrete id with a literal null has to be expressed as an
+// `$or` of equality and IS NULL. Every query that resolves the definitions
+// visible to a scope — the write path, the validation path, the single-key
+// lookups — routes through this builder so they cannot drift apart again (#5919).
+export function createVisibleDefinitionScopeClause(scope: DefinitionScopeClauseInput) {
+  const organizationId = scope.organizationId ?? null
+  const tenantId = scope.tenantId ?? null
+
+  const organizationCandidates = [{ organizationId: null as string | null }]
+  if (organizationId !== null) organizationCandidates.unshift({ organizationId })
+
+  const tenantCandidates = [{ tenantId: null as string | null }]
+  if (tenantId !== null) tenantCandidates.unshift({ tenantId })
+
+  return {
+    $and: [
+      { $or: organizationCandidates },
+      { $or: tenantCandidates },
+    ],
+  }
+}

package/src/modules/entities/lib/definition-scope.ts

@@ -1,6 +1,7 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
 import { CustomFieldDef } from '@open-mercato/core/modules/entities/data/entities'
+import { createVisibleDefinitionScopeClause } from './definition-scope-where'
 
 type AuthScope = {
   tenantId?: string | null
@@ -84,20 +85,11 @@ export function createVisibleDefinitionWhere(
   scope: DefinitionMutationScope,
   options: DefinitionVisibilityOptions = {},
 ) {
-  const organizationCandidates = [{ organizationId: null as string | null }]
-  if (scope.organizationId) organizationCandidates.unshift({ organizationId: scope.organizationId })
-
-  const tenantCandidates = [{ tenantId: null as string | null }]
-  if (scope.tenantId) tenantCandidates.unshift({ tenantId: scope.tenantId })
-
   return {
     entityId,
     key,
     ...options,
-    $and: [
-      { $or: organizationCandidates },
-      { $or: tenantCandidates },
-    ],
+    ...createVisibleDefinitionScopeClause(scope),
   }
 }
 

package/src/modules/entities/lib/helpers.ts

@@ -6,6 +6,7 @@ import {
   TOO_MANY_CUSTOM_FIELDS_ERROR,
 } from '@open-mercato/shared/modules/entities/validation'
 import { CustomFieldDef, CustomFieldValue } from '../data/entities'
+import { loadScopedCustomFieldDefs } from './scoped-field-defs'
 
 type Primitive = string | number | boolean | null | undefined
 type PrimitiveOrArray = Primitive | Primitive[]
@@ -70,39 +71,9 @@ export async function setRecordCustomFields(
   const tenantId = opts.tenantId ?? null
   const preferDefs = opts.preferDefs !== false
 
-  let defsByKey: Record<string, CustomFieldDef> | undefined
+  let defsByKey: Map<string, CustomFieldDef> | undefined
   if (preferDefs) {
-    const defs = await em.find(CustomFieldDef, {
-      entityId,
-      isActive: true,
-      deletedAt: null,
-      organizationId: { $in: [organizationId, null] as any },
-      tenantId: { $in: [tenantId, null] as any },
-    })
-    const scopeScore = (def: CustomFieldDef) => (def.tenantId ? 2 : 0) + (def.organizationId ? 1 : 0)
-    defsByKey = {}
-    for (const d of defs) {
-      const existing = defsByKey[d.key]
-      if (!existing) {
-        defsByKey[d.key] = d
-        continue
-      }
-      const nextScore = scopeScore(d)
-      const existingScore = scopeScore(existing)
-      if (nextScore > existingScore) {
-        defsByKey[d.key] = d
-        continue
-      }
-      if (nextScore < existingScore) continue
-
-      const nextUpdatedAt = d.updatedAt instanceof Date ? d.updatedAt.getTime() : new Date(d.updatedAt).getTime()
-      const existingUpdatedAt = existing.updatedAt instanceof Date
-        ? existing.updatedAt.getTime()
-        : new Date(existing.updatedAt).getTime()
-      if (nextUpdatedAt >= existingUpdatedAt) {
-        defsByKey[d.key] = d
-      }
-    }
+    defsByKey = await loadScopedCustomFieldDefs(em, { entityId, organizationId, tenantId })
   }
 
   const toPersist: CustomFieldValue[] = []
@@ -147,7 +118,7 @@ export async function setRecordCustomFields(
     const raw = values[fieldKey]
     if (raw === undefined) continue
 
-    const def = defsByKey?.[fieldKey]
+    const def = defsByKey?.get(fieldKey)
     const encrypted = Boolean(def?.configJson && (def as any).configJson?.encrypted)
     const isArray = Array.isArray(raw)
     // When array (multi-value): replace all existing rows for the key. Delete

package/src/modules/entities/lib/scoped-field-defs.ts

@@ -1,5 +1,6 @@
 import type { EntityManager } from '@mikro-orm/core'
 import { CustomFieldDef } from '../data/entities'
+import { createVisibleDefinitionScopeClause } from './definition-scope-where'
 
 export type ScopedCustomFieldDefsOptions = {
   entityId: string
@@ -19,25 +20,15 @@ export async function loadScopedCustomFieldDefs(
   em: EntityManager,
   opts: ScopedCustomFieldDefsOptions,
 ): Promise<Map<string, CustomFieldDef>> {
-  const organizationId = opts.organizationId ?? null
-  const tenantId = opts.tenantId ?? null
   const defs = await em.find(CustomFieldDef, {
     entityId: opts.entityId,
     isActive: true,
     deletedAt: null,
-    $and: [
-      {
-        $or: organizationId === null
-          ? [{ organizationId: null }]
-          : [{ organizationId }, { organizationId: null }],
-      },
-      {
-        $or: tenantId === null
-          ? [{ tenantId: null }]
-          : [{ tenantId }, { tenantId: null }],
-      },
-    ],
-  } as any)
+    ...createVisibleDefinitionScopeClause({
+      organizationId: opts.organizationId,
+      tenantId: opts.tenantId,
+    }),
+  })
 
   const byKey = new Map<string, CustomFieldDef>()
   for (const def of defs) {

package/src/modules/query_index/lib/engine.ts

@@ -528,10 +528,10 @@ export class HybridQueryEngine implements QueryEngine {
         // `ignoreRuntimeHealth` asks the on-disk question -- a column holds ciphertext even while
         // the KMS is down -- so an outage keeps encrypted columns on the token path (#4622).
         // `organizationId: null` is deliberate, not an omission: the service then unions in every
-        // organization's map (`fetchAllOrganizationFieldNames`), so a field any org encrypts stays
-        // on the token path -- a wider set fails safe. Passing the request's org instead would
-        // silently break encrypted-column search for orgs without their own map. That union is an
-        // UNCACHED `encryption_maps` read, one extra round-trip per searched list request.
+        // organization's map, so a field any org encrypts stays on the token path -- a wider set
+        // fails safe. Passing the request's org instead would silently break encrypted-column
+        // search for orgs without their own map. The service caches that union (#5949), and the
+        // TTL cache in `resolveEncryptedLikeFieldSet` keeps even the lookup off the request path.
         try {
           const encryptionService = this.getEncryptionService()
           const readEncryptedFieldNames = encryptionService?.getEncryptedFieldNames?.bind(encryptionService)

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

@@ -168,6 +168,37 @@ function shouldIndexField(
   return collectTextValues(value).some((text) => text.length > 0)
 }
 
+/**
+ * Builds the `search_tokens` rows for one document.
+ *
+ * `maxTokensPerRecord` is spent in the iteration order of `params.doc`'s own keys: fields are
+ * tokenized one after another and the loop stops at the first field that exhausts the budget, so
+ * on an over-budget record the surviving fields are whichever ones come first. That order is a
+ * property of the object handed in, not of the entity, and the two write-path builders order it
+ * differently: `buildIndexDocument` (`lib/document.ts`, the batch reindex path) appends `cf:*` keys
+ * after the base columns and the aggregate `search_text` field last. `buildIndexDoc` (`lib/indexer.ts`,
+ * the incremental single-record write path — `upsertIndexRow` → `reindexSearchTokensForRecord`) adds
+ * `l10n:{locale}:{field}` translation keys between the `cf:*` keys and `search_text`. The budget is
+ * spent front-to-back, so the fields nearest the end of that order are starved first: `search_text`
+ * is last on both paths and starves first either way, but starves sooner on the incremental path,
+ * because the `l10n:*` keys ahead of it there consume budget the batch path would have spent on it.
+ * Those translation fields starve next, before any `cf:*` key or base column. The two paths can
+ * therefore keep different fields searchable for an otherwise equivalent record.
+ *
+ * Every write path tokenizes an in-memory document it is about to write — `TokenSearchStrategy.index`
+ * writes only `search_tokens` rows and never touches `entity_indexes.doc` — which keeps each path
+ * self-consistent on its own. A document read back out of the `entity_indexes.doc` `jsonb` column is
+ * not the same object: Postgres stores `jsonb` keys in a canonical order (by key length, then byte
+ * order), not in insertion order. Re-tokenizing such a document can therefore truncate at a different
+ * field than the write did, so code that verifies or recomputes a record's expected tokens must
+ * rebuild the document through the builder that matches the write path being checked — `buildIndexDoc`
+ * for incrementally-written records, `buildIndexDocument` for batch-reindexed ones — rather than
+ * reading it back from the database.
+ *
+ * Making truncation reproducible from a `jsonb` read — by sorting fields before tokenization —
+ * would change which terms stay searchable on over-budget records, so it is a behavior decision
+ * rather than a clarification (#5971).
+ */
 export function buildSearchTokenRows(params: BuildTokenOptions): SearchTokenRow[] {
   const config = params.config ?? resolveSearchConfig()
   if (!config.enabled) return []

package/src/modules/wms/components/backend/AdjustInventoryDialog.tsx

@@ -141,6 +141,13 @@ export function AdjustInventoryDialog({
   )
   const [submitting, setSubmitting] = React.useState(false)
   const [form, setForm] = React.useState<AdjustFormValues>(EMPTY_FORM)
+  // Raw text the user is typing into the delta field, decoupled from `form.delta` (issue
+  // #5828): re-deriving the input's display from the committed number on every keystroke
+  // drops an in-progress decimal separator the instant it's typed (`2,5` collapses to `2`
+  // then the next digit appends, producing `25`). Synced from `form.delta` only while the
+  // field is not focused, mirroring `CrudForm.NumberInput`'s buffer.
+  const [deltaInputText, setDeltaInputText] = React.useState<string>(String(EMPTY_FORM.delta))
+  const deltaInputFocusedRef = React.useRef(false)
   const [fieldErrors, setFieldErrors] = React.useState<Record<string, string>>({})
   const [onHand, setOnHand] = React.useState<number | null>(null)
   const [previewError, setPreviewError] = React.useState<string | null>(null)
@@ -189,6 +196,7 @@ export function AdjustInventoryDialog({
 
   const resetDialog = React.useCallback(() => {
     setForm(EMPTY_FORM)
+    setDeltaInputText(String(EMPTY_FORM.delta))
     setFieldErrors({})
     setOnHand(null)
     setPreviewError(null)
@@ -208,6 +216,10 @@ export function AdjustInventoryDialog({
     setFieldErrors({})
   }, [])
 
+  React.useEffect(() => {
+    if (!deltaInputFocusedRef.current) setDeltaInputText(String(form.delta))
+  }, [form.delta])
+
   React.useEffect(() => {
     if (!open) return
     const catalogVariantId = initialCatalogVariantId?.trim()
@@ -689,12 +701,20 @@ export function AdjustInventoryDialog({
                 <Input
                   type="text"
                   inputMode="decimal"
-                  value={String(form.delta)}
+                  value={deltaInputText}
                   onChange={(event) => {
+                    setDeltaInputText(event.target.value)
                     const parsed = parseDeltaInput(event.target.value, locale)
                     if (parsed == null) return
                     patchForm({ delta: parsed })
                   }}
+                  onFocus={() => {
+                    deltaInputFocusedRef.current = true
+                  }}
+                  onBlur={() => {
+                    deltaInputFocusedRef.current = false
+                    setDeltaInputText(String(form.delta))
+                  }}
                   className="h-8 w-auto min-w-0 flex-1 border-0 bg-transparent p-0 shadow-none focus-visible:ring-0"
                   inputClassName="text-center [appearance:textfield] [&::-webkit-inner-spin-button]:appearance-none [&::-webkit-outer-spin-button]:appearance-none"
                   disabled={submitting}