@open-mercato/core 0.7.1-develop.7106.1.53fe9dd1b1 → 0.7.1-develop.7112.1.d486e6f1b2

package/src/modules/customers/components/detail/authorUserLookup.ts

@@ -0,0 +1,85 @@
+"use client"
+
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { MAX_USER_LOOKUP_IDS } from '@open-mercato/core/modules/auth/lib/userIdFilter'
+
+type AuthUserItem = {
+  id?: unknown
+  name?: unknown
+  display_name?: unknown
+  email?: unknown
+}
+
+// Imported rather than restated: `parseIdsParam` slices past the route's cap without complaining,
+// so a client batch larger than the server accepts loses the overflow ids silently.
+const MAX_IDS_PER_LOOKUP = MAX_USER_LOOKUP_IDS
+
+/**
+ * The outcome of a batch lookup. `resolvedIds` lists the ids the server actually answered for —
+ * an id that came back without a row (deleted user) still counts as resolved, an id whose request
+ * failed does not. Callers cache on `resolvedIds`, so a transient failure is retried rather than
+ * remembered as a permanent blank.
+ */
+export type AuthorUserLookup = {
+  names: Map<string, string>
+  resolvedIds: string[]
+}
+
+function toName(item: AuthUserItem | null | undefined): [string, string] | null {
+  if (!item || typeof item.id !== 'string' || !item.id.trim()) return null
+  const name = typeof item.name === 'string' && item.name.trim() ? item.name.trim() : null
+  const displayName = typeof item.display_name === 'string' && item.display_name.trim()
+    ? item.display_name.trim()
+    : null
+  const email = typeof item.email === 'string' && item.email.trim() ? item.email.trim() : null
+  const label = name ?? displayName ?? email
+  return label ? [item.id.trim(), label] : null
+}
+
+// A viewer of a customer record does not necessarily hold `auth.users.list`, so this lookup must be
+// allowed to fail: `x-om-forbidden-redirect: 0` keeps a 403 from bouncing the whole detail page to
+// /login, and `null` signals that the call itself failed. Callers must not confuse that with a
+// successful call that matched nobody — caching the former would remember a transient error forever.
+async function fetchBatch(ids: string[], signal?: AbortSignal): Promise<AuthUserItem[] | null> {
+  const params = new URLSearchParams()
+  params.set('page', '1')
+  // The route's pageSize defaults to 50, so a batch larger than that would be truncated by
+  // pagination even after it survived the `?ids=` cap.
+  params.set('pageSize', String(ids.length))
+  // URLSearchParams encodes on toString(); pre-encoding here would double-escape the commas.
+  params.set('ids', ids.join(','))
+  const call = await apiCall<{ items?: AuthUserItem[] }>(
+    `/api/auth/users?${params.toString()}`,
+    { headers: { 'x-om-forbidden-redirect': '0' }, signal },
+    { fallback: null },
+  ).catch(() => null)
+  if (!call || !call.ok) return null
+  return call.result?.items ?? []
+}
+
+/**
+ * Batch id → display-name resolution for activity authors already on screen, so an author whose
+ * name was not denormalized onto the activity still renders a name instead of a bare UUID.
+ */
+export async function resolveAuthorUserNames(
+  ids: readonly string[],
+  signal?: AbortSignal,
+): Promise<AuthorUserLookup> {
+  const unique = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)))
+  const names = new Map<string, string>()
+  const resolvedIds: string[] = []
+  for (let offset = 0; offset < unique.length; offset += MAX_IDS_PER_LOOKUP) {
+    if (signal?.aborted) break
+    const batch = unique.slice(offset, offset + MAX_IDS_PER_LOOKUP)
+    const items = await fetchBatch(batch, signal)
+    // One failed batch must not cost the batches that did answer, and its ids stay unresolved so
+    // the next render retries them.
+    if (items === null) continue
+    for (const item of items) {
+      const entry = toName(item)
+      if (entry) names.set(entry[0], entry[1])
+    }
+    resolvedIds.push(...batch)
+  }
+  return { names, resolvedIds }
+}

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

@@ -352,10 +352,19 @@ export class HybridQueryEngine implements QueryEngine {
 
       const normalizedFilters = normalizeFilters(opts.filters)
       const cfFilters = normalizedFilters.filter((filter) => filter.field.startsWith('cf:') || filter.field.startsWith('l10n:'))
+      // `applySort` orders `cf:` sorts off the left-joined index doc, so a
+      // sort-only custom-field query depends on the index just as much as a cf
+      // filter does — without this disjunct it would skip the coverage guards
+      // below and silently order by a NULL expression on an empty index (#5521).
+      // Only `cf:` qualifies: neither engine ever applies an `l10n:` ordering —
+      // both drop it while resolving sorts — so counting it here would pay the
+      // coverage probes and the ORM diversion for an ordering that is discarded.
+      const hasCfSort = (opts.sort || []).some((sort) => String(sort.field).startsWith('cf:'))
       const coverageScope = this.resolveCoverageSnapshotScope(opts)
       const wantsCf = (
         (opts.fields || []).some((field) => typeof field === 'string' && (field.startsWith('cf:') || field.startsWith('l10n:'))) ||
         cfFilters.length > 0 ||
+        hasCfSort ||
         (Array.isArray(opts.includeCustomFields) && opts.includeCustomFields.length > 0)
       )
 

package/src/modules/workflows/backend/definitions/[id]/page.tsx

@@ -1,7 +1,7 @@
 "use client"
 
 import * as React from 'react'
-import { useRouter, useParams, usePathname } from 'next/navigation'
+import { useRouter, usePathname } from 'next/navigation'
 import { useQuery } from '@tanstack/react-query'
 import { Page, PageBody } from '@open-mercato/ui/backend/Page'
 import { CrudForm } from '@open-mercato/ui/backend/CrudForm'
@@ -33,20 +33,12 @@ import { MobileDefinitionDetail } from '../../../components/mobile/MobileDefinit
 import { useIsMobile } from '@open-mercato/ui/hooks/useIsMobile'
 import type { WorkflowDefinitionTrigger } from '../../../data/entities'
 
-export default function EditWorkflowDefinitionPage() {
+export default function EditWorkflowDefinitionPage({ params }: { params?: { id?: string } }) {
   const router = useRouter()
-  const params = useParams()
   const pathname = usePathname()
   const t = useT()
   const isMobile = useIsMobile()
-
-  // Handle catch-all route: params.slug = ['definitions', 'uuid']
-  let definitionId: string | undefined
-  if (params?.slug && Array.isArray(params.slug)) {
-    definitionId = params.slug[1] // Second element is the ID
-  } else if (params?.id) {
-    definitionId = Array.isArray(params.id) ? params.id[0] : params.id
-  }
+  const definitionId = params?.id
 
   const { data: definition, isLoading, error } = useQuery({
     queryKey: ['workflow-definition', definitionId],

package/src/modules/workflows/backend/events/[id]/page.tsx

@@ -2,7 +2,7 @@
 
 import * as React from 'react'
 import Link from 'next/link'
-import { useParams, useRouter } from 'next/navigation'
+import { useRouter } from 'next/navigation'
 import { useQuery } from '@tanstack/react-query'
 import { apiFetch } from '@open-mercato/ui/backend/utils/api'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
@@ -36,19 +36,10 @@ type WorkflowEvent = {
   } | null
 }
 
-export default function WorkflowEventDetailPage() {
+export default function WorkflowEventDetailPage({ params }: { params?: { id?: string } }) {
   const router = useRouter()
-  const params = useParams()
   const t = useT()
-
-  // Handle both {id: '17'} and {slug: ['events', '17']} formats
-  let eventId: string | undefined
-  if (params?.id) {
-    eventId = Array.isArray(params.id) ? params.id[0] : params.id
-  } else if (params?.slug && Array.isArray(params.slug)) {
-    // If slug is ['events', '17'], extract '17'
-    eventId = params.slug[params.slug.length - 1]
-  }
+  const eventId = params?.id
 
   const { data: event, isLoading, error } = useQuery({
     queryKey: ['workflows', 'events', eventId],