@open-mercato/core 0.8.1-develop.7207.1.901ef7e47a → 0.8.1-develop.7218.1.9f22882799

package/src/modules/customers/components/calendar/CalendarToolbar.tsx

@@ -17,6 +17,7 @@ import {
   SelectTrigger,
   SelectValue,
 } from '@open-mercato/ui/primitives/select'
+import { resolveDateFnsLocale } from '@open-mercato/ui/primitives/date-locale'
 import { useLocale, useT } from '@open-mercato/shared/lib/i18n/context'
 import { formatDateRangeLabel } from '../../lib/calendar/format'
 import type {
@@ -51,6 +52,7 @@ export function CalendarToolbar(props: CalendarToolbarProps) {
   } = props
   const t = useT()
   const locale = useLocale()
+  const dateFnsLocale = resolveDateFnsLocale(locale)
   const [rangeOpen, setRangeOpen] = React.useState(false)
   const [filtersOpen, setFiltersOpen] = React.useState(false)
   const [pendingFilters, setPendingFilters] = React.useState<CalendarFiltersValue>(filters)
@@ -133,6 +135,7 @@ export function CalendarToolbar(props: CalendarToolbarProps) {
                 mode="single"
                 selected={anchor}
                 defaultMonth={anchor}
+                locale={dateFnsLocale}
                 onSelect={(date) => {
                   if (!date) return
                   onAnchorChange(date)

package/src/modules/customers/components/calendar/editor/RepeatField.tsx

@@ -26,7 +26,6 @@ export function RepeatField({
   endType,
   count,
   untilDate,
-  locale,
   onFreqChange,
   onToggleDay,
   onEndTypeChange,
@@ -38,7 +37,6 @@ export function RepeatField({
   endType: EditorRepeatEndType
   count: number
   untilDate: string
-  locale: string
   onFreqChange(next: EditorRepeatFreq): void
   onToggleDay(index: number): void
   onEndTypeChange(next: EditorRepeatEndType): void
@@ -105,7 +103,6 @@ export function RepeatField({
               value={untilDate || ''}
               onChange={onUntilDateChange}
               ariaLabel={t('customers.calendar.editor.repeat.onDate', 'On date')}
-              locale={locale}
             />
           ) : null}
           {endType === 'count' ? (

package/src/modules/customers/components/calendar/editor/ScheduleSection.tsx

@@ -19,7 +19,6 @@ function DateTimeRow({
   date,
   time,
   showTime,
-  locale,
   onDateChange,
   onTimeChange,
 }: {
@@ -27,7 +26,6 @@ function DateTimeRow({
   date: string
   time: string
   showTime: boolean
-  locale: string
   onDateChange(next: string): void
   onTimeChange(next: string): void
 }) {
@@ -35,7 +33,7 @@ function DateTimeRow({
     <div className="flex w-full items-end gap-2.5">
       <div className="flex min-w-0 flex-1 flex-col gap-1.5">
         <span className={LABEL_CLASS}>{label}</span>
-        <DateControl value={date} onChange={onDateChange} ariaLabel={label} locale={locale} />
+        <DateControl value={date} onChange={onDateChange} ariaLabel={label} />
       </div>
       {showTime ? <TimeControl value={time} onChange={onTimeChange} ariaLabel={label} /> : null}
     </div>
@@ -51,7 +49,6 @@ export function ScheduleSection({
   startTime,
   endDate,
   endTime,
-  locale,
   endsError,
   onAllDayChange,
   onDateChange,
@@ -67,7 +64,6 @@ export function ScheduleSection({
   startTime: string
   endDate: string
   endTime: string
-  locale: string
   endsError?: string | null
   onAllDayChange(next: boolean): void
   onDateChange(next: string): void
@@ -91,7 +87,6 @@ export function ScheduleSection({
         date={date}
         time={startTime}
         showTime={showTime}
-        locale={locale}
         onDateChange={onDateChange}
         onTimeChange={onStartTimeChange}
       />
@@ -101,7 +96,6 @@ export function ScheduleSection({
           date={endDate}
           time={endTime}
           showTime={showTime}
-          locale={locale}
           onDateChange={onEndDateChange}
           onTimeChange={onEndTimeChange}
         />

package/src/modules/customers/components/calendar/editor/inputs.tsx

@@ -116,7 +116,6 @@ export function DateControl({
   value: string
   onChange(next: string): void
   ariaLabel: string
-  locale: string
   className?: string
 }) {
   const [open, setOpen] = React.useState(false)

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
@@ -164,7 +135,7 @@ export async function setRecordCustomFields(
         const cf = em.create(CustomFieldValue, { entityId, recordId, organizationId, tenantId, fieldKey, createdAt: new Date() })
         clearValueColumns(cf)
         const stored = encrypted
-          ? await encryptCustomFieldValue(val, tenantId, getEncryptionService(), encryptionCache)
+          ? await encryptCustomFieldValue(val, tenantId, getEncryptionService(), encryptionCache, { entityId, fieldKey })
           : val
         switch (col) {
           case 'valueText': cf.valueText = stored == null ? null : String(stored); break
@@ -181,7 +152,7 @@ export async function setRecordCustomFields(
 
     const column: keyof CustomFieldValue = encrypted ? 'valueText' : def ? columnFromKind(def.kind) : columnFromJsValue(raw as Primitive)
     const storedValue = encrypted
-      ? await encryptCustomFieldValue(raw as Primitive, tenantId, getEncryptionService(), encryptionCache)
+      ? await encryptCustomFieldValue(raw as Primitive, tenantId, getEncryptionService(), encryptionCache, { entityId, fieldKey })
       : raw
 
     let cf = await em.findOne(CustomFieldValue, { entityId, recordId, organizationId, tenantId, fieldKey })

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/batch.ts

@@ -1,7 +1,7 @@
 import { type Kysely, sql } from 'kysely'
 import { recordIndexerError } from '@open-mercato/shared/lib/indexers/error-log'
 import { isUniqueViolation } from '@open-mercato/shared/lib/db/pg-errors'
-import { buildIndexDocument, type IndexCustomFieldValue } from './document'
+import { buildIndexDocument, rebuildAggregateSearchField, type IndexCustomFieldValue } from './document'
 import { replaceSearchTokensForBatch, isSearchDebugEnabled } from './search-tokens'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 import { resolveSearchConfig } from '@open-mercato/shared/lib/search/config'
@@ -304,7 +304,13 @@ export async function upsertIndexBatch(
           tenantId: scopeTenant ?? null,
         })
         if (decrypted && typeof decrypted === 'object') {
-          tokenDoc = decrypted
+          // Rebuilt on the decrypted copy: `search_text` is on no encryption map, so the
+          // aggregate composed at document-build time still concatenates the ciphertext
+          // values the row carries at rest and tokenizes into rows nothing matches (#5625).
+          // The copy keeps `doc` — the encrypted row written to `entity_indexes` — untouched.
+          // A caller that passes no `decryptDoc` keeps the build-time aggregate by design:
+          // without a decryption step there is no plaintext to recompose it from.
+          tokenDoc = rebuildAggregateSearchField(decrypted, { entityType, config: searchConfig })
         }
       } catch (decryptError) {
         // Only affects the search tokens built below; the indexed document itself is

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

@@ -109,6 +109,34 @@ export function attachAggregateSearchField(
   return doc
 }
 
+/**
+ * Recomputes the aggregate on a shallow copy of `doc`.
+ *
+ * Search tokens are built from the *decrypted* index document, while the document
+ * persisted in `entity_indexes` stays encrypted at rest. The aggregate composed during
+ * document build therefore concatenates ciphertext for every field an encryption map
+ * covers, and `decryptIndexDocForSearch` cannot repair it because `search_text` is on no
+ * map (#5625). Token writers call this on the decrypted document so the aggregate is
+ * tokenized from the same plaintext a user actually searches for; the copy keeps the
+ * caller's stored document untouched.
+ *
+ * A pre-existing aggregate is blanked before recomposition rather than deleted: an empty
+ * string yields no tokens, but it keeps the key on the document, and
+ * `replaceSearchTokensForRecord` scopes its DELETE to the document's own field names. A
+ * deleted key would drop `search_text` out of that scope and strand the ciphertext-derived
+ * rows with no writer left to remove them.
+ */
+export function rebuildAggregateSearchField(
+  doc: Record<string, unknown>,
+  options: AggregateSearchOptions = {},
+): Record<string, unknown> {
+  const copy = { ...doc }
+  // `collectAggregateSearchValues` skips the aggregate's own key, so this blank is
+  // overwritten whenever anything survives the blocklist and stays blank otherwise.
+  if (AGGREGATE_SEARCH_FIELD in copy) copy[AGGREGATE_SEARCH_FIELD] = ''
+  return attachAggregateSearchField(copy, options)
+}
+
 export function buildIndexDocument(
   baseRow: Record<string, unknown>,
   customFieldValues: Iterable<IndexCustomFieldValue> = [],

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/indexer.ts

@@ -10,8 +10,9 @@ import {
 } from '@open-mercato/shared/lib/crud/custom-field-definition-index'
 import { type Kysely, type Transaction, sql } from 'kysely'
 import { createLogger } from '@open-mercato/shared/lib/logger'
+import { resolveSearchConfig } from '@open-mercato/shared/lib/search/config'
 import { replaceSearchTokensForRecord, deleteSearchTokensForRecord } from './search-tokens'
-import { attachAggregateSearchField } from './document'
+import { attachAggregateSearchField, rebuildAggregateSearchField } from './document'
 
 const logger = createLogger('query_index').child({ component: 'indexer' })
 
@@ -400,12 +401,24 @@ export async function reindexSearchTokensForRecord(
       dekKeyCache,
     )
   })()
+  // Rebuilt on the decrypted document: the aggregate stored in `entity_indexes` was
+  // composed from the row as it sits at rest, so for every encryption-mapped field it
+  // holds ciphertext no user query can ever match (#5625). `resolveSearchConfig` re-parses
+  // the environment on every call, so it is resolved once and threaded into both the
+  // rebuild and the token writer — that also makes the aggregate's blocklist filter and
+  // the per-field one provably read the same snapshot, as the batch path already does.
+  const searchConfig = resolveSearchConfig()
+  const searchDoc = rebuildAggregateSearchField(await tokenDoc, {
+    entityType: args.entityType,
+    config: searchConfig,
+  })
   await replaceSearchTokensForRecord(db, {
     entityType: args.entityType,
     recordId: args.recordId,
     organizationId: args.organizationId ?? null,
     tenantId: args.tenantId ?? null,
-    doc: await tokenDoc,
+    doc: searchDoc,
+    config: searchConfig,
   }, { trx: args.trx })
 }
 

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}