@open-mercato/ui 0.6.7-develop.6726.1.983ae8a07e → 0.6.7-develop.6749.1.6b54c56dfe

package/src/backend/sidebar/__tests__/group-visibility.test.ts

@@ -0,0 +1,131 @@
+import {
+  applyGroupHidden,
+  collectGroupItemKeys,
+  resolveGroupVisibility,
+  resolveItemKey,
+  type SidebarGroup,
+} from '../customization-helpers'
+
+// Hiding a whole group used to require toggling every item in it individually — `AppShell` drops a
+// group only once *all* of its items are hidden. These cases cover the bulk toggle that does it in one
+// action, and pin the invariant that matters for compatibility: it writes the same `hiddenItemIds`
+// keys the per-item switches write, and nothing else.
+
+const group: SidebarGroup = {
+  id: 'catalog.nav.group',
+  name: 'Catalog',
+  items: [
+    { href: '/backend/catalog/products', title: 'Products' },
+    {
+      href: '/backend/catalog/categories',
+      title: 'Categories',
+      children: [
+        { href: '/backend/catalog/categories/tree', title: 'Tree' },
+        { href: '/backend/catalog/categories/import', title: 'Import' },
+      ],
+    },
+  ],
+}
+
+const ALL_KEYS = [
+  '/backend/catalog/products',
+  '/backend/catalog/categories',
+  '/backend/catalog/categories/tree',
+  '/backend/catalog/categories/import',
+]
+
+describe('collectGroupItemKeys', () => {
+  it('includes top-level items and every nested descendant', () => {
+    expect(collectGroupItemKeys(group).sort()).toEqual([...ALL_KEYS].sort())
+  })
+
+  it('returns nothing for an empty group', () => {
+    expect(collectGroupItemKeys({ id: 'empty', name: 'Empty', items: [] })).toEqual([])
+  })
+
+  it('prefers an explicit item id over the href, matching resolveItemKey', () => {
+    const withIds: SidebarGroup = {
+      id: 'g',
+      name: 'G',
+      items: [{ id: 'custom-id', href: '/backend/thing', title: 'Thing' }],
+    }
+
+    expect(collectGroupItemKeys(withIds)).toEqual([resolveItemKey(withIds.items[0])])
+  })
+})
+
+describe('resolveGroupVisibility', () => {
+  it('is visible when nothing is hidden', () => {
+    expect(resolveGroupVisibility(group, {})).toBe('visible')
+  })
+
+  it('is hidden only when every item including descendants is hidden', () => {
+    const allHidden = Object.fromEntries(ALL_KEYS.map((key) => [key, true]))
+
+    expect(resolveGroupVisibility(group, allHidden)).toBe('hidden')
+  })
+
+  it('is partial when some but not all items are hidden', () => {
+    expect(resolveGroupVisibility(group, { '/backend/catalog/products': true })).toBe('partial')
+  })
+
+  it('is partial when only a nested descendant is left visible', () => {
+    const allButOne = Object.fromEntries(
+      ALL_KEYS.filter((key) => key !== '/backend/catalog/categories/import').map((key) => [key, true]),
+    )
+
+    expect(resolveGroupVisibility(group, allButOne)).toBe('partial')
+  })
+
+  it('treats an empty group as visible rather than hidden', () => {
+    expect(resolveGroupVisibility({ id: 'empty', name: 'Empty', items: [] }, {})).toBe('visible')
+  })
+})
+
+describe('applyGroupHidden', () => {
+  it('hides every item in the group, descendants included', () => {
+    const next = applyGroupHidden({}, group, true)
+
+    expect(Object.keys(next).sort()).toEqual([...ALL_KEYS].sort())
+    expect(resolveGroupVisibility(group, next)).toBe('hidden')
+  })
+
+  it('clears every item in the group when shown', () => {
+    const hidden = applyGroupHidden({}, group, true)
+    const next = applyGroupHidden(hidden, group, false)
+
+    expect(next).toEqual({})
+    expect(resolveGroupVisibility(group, next)).toBe('visible')
+  })
+
+  it('leaves keys belonging to other groups untouched', () => {
+    const other = { '/backend/sales/orders': true }
+
+    expect(applyGroupHidden(other, group, true)['/backend/sales/orders']).toBe(true)
+    expect(applyGroupHidden(other, group, false)).toEqual(other)
+  })
+
+  it('does not mutate the input map', () => {
+    const input = { '/backend/sales/orders': true }
+    const snapshot = { ...input }
+
+    applyGroupHidden(input, group, true)
+
+    expect(input).toEqual(snapshot)
+  })
+
+  it('reaches the same state as toggling each item by hand', () => {
+    const byHand = ALL_KEYS.reduce<Record<string, boolean>>((acc, key) => {
+      acc[key] = true
+      return acc
+    }, {})
+
+    expect(applyGroupHidden({}, group, true)).toEqual(byHand)
+  })
+
+  it('is idempotent', () => {
+    const once = applyGroupHidden({}, group, true)
+
+    expect(applyGroupHidden(once, group, true)).toEqual(once)
+  })
+})

package/src/backend/sidebar/customization-helpers.ts

@@ -156,6 +156,53 @@ export function applyCustomizationDraft(
   return result
 }
 
+/** Every item key a group owns, including nested children. */
+export function collectGroupItemKeys(group: SidebarGroup): string[] {
+  const keys: string[] = []
+  const walk = (items: SidebarItem[]) => {
+    for (const item of items) {
+      keys.push(resolveItemKey(item))
+      if (item.children?.length) walk(item.children)
+    }
+  }
+  walk(group.items)
+  return keys
+}
+
+/**
+ * Whether a group is fully visible, fully hidden, or in between. `AppShell` drops a group once every
+ * one of its items is hidden, so `'hidden'` is the state that removes the group from the sidebar.
+ */
+export function resolveGroupVisibility(
+  group: SidebarGroup,
+  hiddenItemIds: Record<string, boolean>,
+): 'visible' | 'hidden' | 'partial' {
+  const keys = collectGroupItemKeys(group)
+  if (keys.length === 0) return 'visible'
+  const hiddenCount = keys.filter((key) => hiddenItemIds[key]).length
+  if (hiddenCount === 0) return 'visible'
+  if (hiddenCount === keys.length) return 'hidden'
+  return 'partial'
+}
+
+/**
+ * Hides or shows every item in a group at once. Writes the same `hiddenItemIds` keys the per-item
+ * switches use, so the resulting settings are indistinguishable from reaching this state by toggling
+ * each item by hand — no new persisted shape, no migration.
+ */
+export function applyGroupHidden(
+  hiddenItemIds: Record<string, boolean>,
+  group: SidebarGroup,
+  hidden: boolean,
+): Record<string, boolean> {
+  const next = { ...hiddenItemIds }
+  for (const key of collectGroupItemKeys(group)) {
+    if (hidden) next[key] = true
+    else delete next[key]
+  }
+  return next
+}
+
 /**
  * Filters groups to include only main sidebar items.
  * Excludes items with pageContext 'settings' or 'profile' from customization.

package/src/backend/utils/__tests__/customFieldForms.optionsPaging.test.ts

@@ -0,0 +1,95 @@
+/** @jest-environment node */
+
+const apiCall = jest.fn()
+
+jest.mock('../apiCall', () => ({
+  apiCall: (...args: unknown[]) => apiCall(...args),
+}))
+
+jest.mock('../../fields/registry', () => ({
+  FieldRegistry: { getInput: () => null },
+  loadGeneratedFieldRegistrations: async () => {},
+}))
+
+import { buildFormFieldFromCustomFieldDef } from '../customFieldForms'
+
+const okPage = (payload: Record<string, unknown>) => ({ ok: true, result: payload })
+
+const requestedUrls = () => apiCall.mock.calls.map(([url]) => url as string)
+
+const loadOptionsFor = (def: Parameters<typeof buildFormFieldFromCustomFieldDef>[0]) => {
+  const field = buildFormFieldFromCustomFieldDef(def)
+  const loadOptions = (field as { loadOptions?: (query?: string) => Promise<Array<{ value: string; label: string }>> })
+    .loadOptions
+  if (!loadOptions) throw new Error('[internal] expected the field to expose loadOptions')
+  return loadOptions
+}
+
+/**
+ * Guards the review finding on #4175: the entries route caps rows per response,
+ * so the generic `optionsUrl` loader behind every select/currency/relation and
+ * multi-dictionary custom field must page instead of dropping everything past
+ * the first page.
+ */
+describe('custom field remote options paging', () => {
+  beforeEach(() => {
+    apiCall.mockReset()
+  })
+
+  it('walks every page of a dictionary-backed multi-select', async () => {
+    apiCall
+      .mockResolvedValueOnce(
+        okPage({ items: [{ value: 'a', label: 'Alpha' }], total: 2, hasMore: true }),
+      )
+      .mockResolvedValueOnce(
+        okPage({ items: [{ value: 'b', label: 'Beta' }], total: 2, hasMore: false }),
+      )
+
+    const options = await loadOptionsFor({
+      key: 'tags',
+      kind: 'dictionary',
+      multi: true,
+      dictionaryId: 'dict-1',
+    })()
+
+    expect(requestedUrls()).toEqual([
+      '/api/dictionaries/dict-1/entries',
+      '/api/dictionaries/dict-1/entries?offset=1',
+    ])
+    expect(options).toEqual([
+      { value: 'a', label: 'Alpha' },
+      { value: 'b', label: 'Beta' },
+    ])
+  })
+
+  it('keeps the typeahead query on every page it requests', async () => {
+    apiCall
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'a', label: 'Alpha' }], hasMore: true }))
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'ab', label: 'Able' }], hasMore: false }))
+
+    await loadOptionsFor({ key: 'ref', kind: 'select', optionsUrl: '/api/refs' })('al')
+
+    expect(requestedUrls()[0]).toContain('query=al')
+    expect(requestedUrls()[1]).toContain('query=al')
+    expect(requestedUrls()[1]).toContain('offset=1')
+  })
+
+  it('issues one request for a route that does not report hasMore', async () => {
+    apiCall.mockResolvedValueOnce(okPage({ items: [{ value: 'usd', label: 'USD' }] }))
+
+    const options = await loadOptionsFor({ key: 'ref', kind: 'select', optionsUrl: '/api/refs' })()
+
+    expect(apiCall).toHaveBeenCalledTimes(1)
+    expect(options).toEqual([{ value: 'usd', label: 'USD' }])
+  })
+
+  it('returns no options when a page fails rather than a partial list', async () => {
+    apiCall
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'a', label: 'Alpha' }], hasMore: true }))
+      .mockResolvedValueOnce({ ok: false, result: { error: 'Forbidden' } })
+
+    const options = await loadOptionsFor({ key: 'ref', kind: 'select', optionsUrl: '/api/refs' })()
+
+    expect(options).toEqual([])
+  })
+})

package/src/backend/utils/__tests__/fetchAllPages.test.ts

@@ -0,0 +1,103 @@
+/** @jest-environment node */
+
+const apiCall = jest.fn()
+
+jest.mock('../apiCall', () => ({
+  apiCall: (...args: unknown[]) => apiCall(...args),
+}))
+
+import { fetchAllOffsetPages, MAX_OFFSET_PAGES } from '../fetchAllPages'
+
+const okPage = (payload: Record<string, unknown>) => ({ ok: true, result: payload })
+
+const requestedUrls = () => apiCall.mock.calls.map(([url]) => url as string)
+
+describe('fetchAllOffsetPages', () => {
+  beforeEach(() => {
+    apiCall.mockReset()
+  })
+
+  it('issues a single untouched request when the route does not report hasMore', async () => {
+    apiCall.mockResolvedValueOnce(okPage({ items: [{ value: 'a' }, { value: 'b' }] }))
+
+    const result = await fetchAllOffsetPages('/api/options')
+
+    expect(requestedUrls()).toEqual(['/api/options'])
+    expect(result.ok).toBe(true)
+    expect(result.pageCount).toBe(1)
+    expect(result.items).toEqual([{ value: 'a' }, { value: 'b' }])
+  })
+
+  it('walks hasMore, advancing the offset by the rows already collected', async () => {
+    apiCall
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }, { value: 'b' }], hasMore: true }))
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'c' }], hasMore: false }))
+
+    const result = await fetchAllOffsetPages('/api/options')
+
+    expect(requestedUrls()).toEqual(['/api/options', '/api/options?offset=2'])
+    expect(result.items).toHaveLength(3)
+    expect(result.pageCount).toBe(2)
+  })
+
+  it('preserves the caller query string when it appends the offset', async () => {
+    apiCall
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }], hasMore: true }))
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'b' }], hasMore: false }))
+
+    await fetchAllOffsetPages('/api/options?query=ab&q=ab')
+
+    expect(requestedUrls()[1]).toBe('/api/options?query=ab&q=ab&offset=1')
+  })
+
+  it('continues from an offset the caller already put on the url', async () => {
+    apiCall
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }], hasMore: true }))
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'b' }], hasMore: false }))
+
+    await fetchAllOffsetPages('/api/options?offset=10')
+
+    expect(requestedUrls()).toEqual(['/api/options?offset=10', '/api/options?offset=11'])
+  })
+
+  it('exposes the first payload so callers can read page-invariant metadata', async () => {
+    apiCall
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }], hasMore: true, sortMode: 'value_desc' }))
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'b' }], hasMore: false, sortMode: 'value_desc' }))
+
+    const result = await fetchAllOffsetPages('/api/options')
+
+    expect(result.firstPayload.sortMode).toBe('value_desc')
+  })
+
+  it('stops on an empty page so a route reporting hasMore forever cannot spin', async () => {
+    apiCall
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }], hasMore: true }))
+      .mockResolvedValueOnce(okPage({ items: [], hasMore: true }))
+
+    const result = await fetchAllOffsetPages('/api/options')
+
+    expect(apiCall).toHaveBeenCalledTimes(2)
+    expect(result.items).toHaveLength(1)
+  })
+
+  it('caps the walk at the page ceiling', async () => {
+    apiCall.mockResolvedValue(okPage({ items: [{ value: 'a' }], hasMore: true }))
+
+    const result = await fetchAllOffsetPages('/api/options')
+
+    expect(apiCall).toHaveBeenCalledTimes(MAX_OFFSET_PAGES)
+    expect(result.pageCount).toBe(MAX_OFFSET_PAGES)
+  })
+
+  it('reports a failed page instead of returning a silently truncated list', async () => {
+    apiCall
+      .mockResolvedValueOnce(okPage({ items: [{ value: 'a' }], hasMore: true }))
+      .mockResolvedValueOnce({ ok: false, result: { error: 'Forbidden' } })
+
+    const result = await fetchAllOffsetPages('/api/options')
+
+    expect(result.ok).toBe(false)
+    expect(result.errorPayload).toEqual({ error: 'Forbidden' })
+  })
+})

package/src/backend/utils/customFieldForms.ts

@@ -9,7 +9,7 @@ import {
   fetchCustomFieldDefinitionsPayload,
 } from './customFieldDefs'
 import { FieldRegistry, loadGeneratedFieldRegistrations } from '../fields/registry'
-import { apiCall } from './apiCall'
+import { fetchAllOffsetPages } from './fetchAllPages'
 import { normalizeCustomFieldOptions } from '@open-mercato/shared/modules/entities/options'
 import { CURRENCY_OPTIONS_URL } from '@open-mercato/shared/modules/entities/kinds'
 
@@ -42,18 +42,22 @@ function buildOptionsUrl(base: string, query?: string): string {
   }
 }
 
-type OptionsResponse = { items?: unknown[] }
-
 async function loadRemoteOptions(url: string): Promise<Array<{ value: string; label: string }>> {
   try {
-    const call = await apiCall<OptionsResponse>(url, undefined, { fallback: { items: [] } })
-    if (!call.ok) return []
-    const payload = call.result ?? { items: [] }
-    const items = Array.isArray(payload?.items) ? payload.items : []
-    return items.map((it: any) => ({
-      value: String(it?.value ?? it),
-      label: String(it?.label ?? it?.value ?? it),
-    }))
+    // Options routes bound how many rows one response carries (dictionary
+    // entries at 500), so walk every page instead of reading a single
+    // response — a stored value past the first page must stay selectable and
+    // resolvable to its label. Routes without `hasMore` still resolve in one
+    // request.
+    const pages = await fetchAllOffsetPages(url)
+    if (!pages.ok) return []
+    return pages.items.map((item) => {
+      const record = item && typeof item === 'object' ? (item as Record<string, unknown>) : null
+      return {
+        value: String(record?.value ?? item),
+        label: String(record?.label ?? record?.value ?? item),
+      }
+    })
   } catch {
     return []
   }

package/src/backend/utils/fetchAllPages.ts

@@ -0,0 +1,93 @@
+"use client"
+
+import { apiCall } from './apiCall'
+
+// Offset-paged list routes cap how many rows one response may carry, so a
+// caller that needs the whole collection has to walk the pages. Bound the walk
+// so a route reporting hasMore forever cannot hang the caller; at the 500-row
+// dictionary ceiling this still covers 25k rows.
+export const MAX_OFFSET_PAGES = 50
+
+export type OffsetPagedPayload = Record<string, unknown>
+
+export type OffsetPagedResult = {
+  ok: boolean
+  items: unknown[]
+  pageCount: number
+  firstPayload: OffsetPagedPayload
+  errorPayload: OffsetPagedPayload | null
+}
+
+const ABSOLUTE_URL_PATTERN = /^([a-z][a-z\d+\-.]*:)?\/\//i
+
+type ParsedUrl = { url: URL; absolute: boolean }
+
+function parseUrl(value: string): ParsedUrl | null {
+  try {
+    const absolute = ABSOLUTE_URL_PATTERN.test(value)
+    const origin = typeof window !== 'undefined' ? window.location.origin : 'http://localhost'
+    return { url: absolute ? new URL(value) : new URL(value, origin), absolute }
+  } catch {
+    return null
+  }
+}
+
+function formatUrl(parsed: ParsedUrl): string {
+  return parsed.absolute ? parsed.url.toString() : `${parsed.url.pathname}${parsed.url.search}`
+}
+
+function readOffset(value: string): number {
+  const parsed = parseUrl(value)
+  if (!parsed) return 0
+  const offset = Number.parseInt(parsed.url.searchParams.get('offset') ?? '', 10)
+  return Number.isFinite(offset) && offset > 0 ? offset : 0
+}
+
+function withOffset(value: string, offset: number): string {
+  const parsed = parseUrl(value)
+  if (!parsed) {
+    const separator = value.includes('?') ? '&' : '?'
+    return `${value}${separator}offset=${offset}`
+  }
+  parsed.url.searchParams.set('offset', String(offset))
+  return formatUrl(parsed)
+}
+
+/**
+ * Walk every page of an offset-paged list route and return the assembled items.
+ *
+ * A route that does not report `hasMore` resolves after a single request, so
+ * this is a drop-in replacement for a one-shot `apiCall` against any list
+ * endpoint. Ordering is preserved as the route returned it, page after page —
+ * callers that need a global order across page boundaries must re-sort.
+ */
+export async function fetchAllOffsetPages(
+  url: string,
+  options: { maxPages?: number } = {},
+): Promise<OffsetPagedResult> {
+  const maxPages = options.maxPages ?? MAX_OFFSET_PAGES
+  const baseOffset = readOffset(url)
+  const items: unknown[] = []
+  let firstPayload: OffsetPagedPayload = {}
+  let pageCount = 0
+
+  while (pageCount < maxPages) {
+    // The first request goes out untouched so a route that caches only its
+    // default page still serves that page from cache.
+    const pageUrl = pageCount === 0 ? url : withOffset(url, baseOffset + items.length)
+    const call = await apiCall<OffsetPagedPayload>(pageUrl, undefined, { fallback: {} })
+    const payload = call.result ?? {}
+    if (!call.ok) {
+      return { ok: false, items, pageCount, firstPayload, errorPayload: payload }
+    }
+    pageCount += 1
+    if (pageCount === 1) firstPayload = payload
+    const pageItems = Array.isArray(payload.items) ? payload.items : []
+    items.push(...pageItems)
+    // An empty page also stops the walk: without it a route that keeps
+    // reporting hasMore while returning nothing would spin to the page cap.
+    if (payload.hasMore !== true || pageItems.length === 0) break
+  }
+
+  return { ok: true, items, pageCount, firstPayload, errorPayload: null }
+}