@open-mercato/ui 0.4.2-canary-c02407ff85

package/src/backend/schedule/ScheduleView.tsx

@@ -0,0 +1,198 @@
+"use client"
+
+import * as React from 'react'
+import { Calendar, dateFnsLocalizer, type View, type SlotInfo } from 'react-big-calendar'
+import { addDays, differenceInCalendarDays, endOfDay, endOfMonth, endOfWeek, format, getDay, parse, startOfDay, startOfMonth, startOfWeek } from 'date-fns'
+import { enUS } from 'date-fns/locale/en-US'
+import type { ScheduleItem, ScheduleRange, ScheduleSlot, ScheduleViewMode } from './types'
+import { ScheduleToolbar } from './ScheduleToolbar'
+import { expandRecurringItems } from './recurrence'
+
+type CalendarEvent = {
+  id: string
+  title: string
+  start: Date
+  end: Date
+  resource: ScheduleItem
+}
+
+const localizer = dateFnsLocalizer({
+  format,
+  parse,
+  startOfWeek,
+  getDay,
+  locales: { 'en-US': enUS },
+})
+
+const VIEW_MAP: Record<ScheduleViewMode, View> = {
+  day: 'day',
+  week: 'week',
+  month: 'month',
+  agenda: 'agenda',
+}
+
+function deriveRange(date: Date, view: ScheduleViewMode, agendaLength: number): ScheduleRange {
+  if (view === 'day') {
+    return { start: startOfDay(date), end: endOfDay(date) }
+  }
+  if (view === 'week') {
+    return { start: startOfWeek(date, { locale: enUS }), end: endOfWeek(date, { locale: enUS }) }
+  }
+  if (view === 'month') {
+    return { start: startOfMonth(date), end: endOfMonth(date) }
+  }
+  const length = Math.max(1, agendaLength)
+  return { start: startOfDay(date), end: endOfDay(addDays(date, length - 1)) }
+}
+
+function normalizeRange(
+  nextRange: Date[] | { start: Date; end: Date } | null | undefined,
+  view: ScheduleViewMode,
+  agendaLength: number,
+): ScheduleRange | null {
+  if (!nextRange) return null
+  if (Array.isArray(nextRange)) {
+    if (nextRange.length === 0) return null
+    if (view === 'agenda') {
+      return { start: nextRange[0], end: nextRange[nextRange.length - 1] }
+    }
+    return deriveRange(nextRange[0], view, agendaLength)
+  }
+  if (nextRange.start && nextRange.end) return { start: nextRange.start, end: nextRange.end }
+  return deriveRange(new Date(), view, agendaLength)
+}
+
+function getEventStyles(item: ScheduleItem): React.CSSProperties {
+  if (item.kind === 'event') {
+    return { backgroundColor: 'rgba(59, 130, 246, 0.15)', border: '1px solid rgba(59, 130, 246, 0.5)', color: '#1e3a8a' }
+  }
+  if (item.kind === 'exception') {
+    return { backgroundColor: 'rgba(148, 163, 184, 0.2)', border: '1px solid rgba(100, 116, 139, 0.6)', color: '#334155' }
+  }
+  return { backgroundColor: 'rgba(16, 185, 129, 0.15)', border: '1px solid rgba(16, 185, 129, 0.5)', color: '#064e3b' }
+}
+
+export type ScheduleViewProps = {
+  items: ScheduleItem[]
+  view: ScheduleViewMode
+  range: ScheduleRange
+  timezone?: string
+  onRangeChange: (range: ScheduleRange) => void
+  onViewChange: (view: ScheduleViewMode) => void
+  onItemClick?: (item: ScheduleItem) => void
+  onSlotClick?: (slot: ScheduleSlot) => void
+  onTimezoneChange?: (timezone: string) => void
+  className?: string
+}
+
+export function ScheduleView({
+  items,
+  view,
+  range,
+  timezone,
+  onRangeChange,
+  onViewChange,
+  onItemClick,
+  onSlotClick,
+  onTimezoneChange,
+  className,
+}: ScheduleViewProps) {
+  const agendaLength = React.useMemo(
+    () => Math.max(1, differenceInCalendarDays(range.end, range.start) + 1),
+    [range.end, range.start],
+  )
+  const currentView = VIEW_MAP[view]
+  const expandedItems = React.useMemo(() => expandRecurringItems(items, range), [items, range])
+  const events = React.useMemo<CalendarEvent[]>(
+    () => expandedItems.map((item) => ({
+      id: item.id,
+      title: item.title,
+      start: item.startsAt,
+      end: item.endsAt,
+      resource: item,
+    })),
+    [expandedItems],
+  )
+
+  const handleNavigate = React.useCallback((date: Date, nextView?: View) => {
+    const resolvedView = (nextView ?? currentView) as ScheduleViewMode
+    onRangeChange(deriveRange(date, resolvedView, agendaLength))
+  }, [agendaLength, currentView, onRangeChange])
+
+  const handleRangeChange = React.useCallback((nextRange: Date[] | { start: Date; end: Date }, nextView?: View) => {
+    const resolvedView = (nextView ?? currentView) as ScheduleViewMode
+    const normalized = normalizeRange(nextRange, resolvedView, agendaLength)
+    if (normalized) onRangeChange(normalized)
+  }, [agendaLength, currentView, onRangeChange])
+
+  const handleViewChange = React.useCallback((nextView: View) => {
+    const resolved = nextView as ScheduleViewMode
+    if (resolved !== view) {
+      onViewChange(resolved)
+      onRangeChange(deriveRange(new Date(), resolved, agendaLength))
+    }
+  }, [agendaLength, onRangeChange, onViewChange, view])
+
+  const rootClassName = ['schedule-view', className].filter(Boolean).join(' ')
+
+  return (
+    <div className={rootClassName}>
+      <ScheduleToolbar
+        view={view}
+        range={range}
+        timezone={timezone}
+        onRangeChange={onRangeChange}
+        onViewChange={onViewChange}
+        onTimezoneChange={onTimezoneChange}
+      />
+      <div className="schedule-calendar mt-4 rounded-xl border bg-card p-3">
+        <Calendar
+          localizer={localizer}
+          culture="en-US"
+          events={events}
+          view={currentView}
+          date={range.start}
+          toolbar={false}
+          selectable={Boolean(onSlotClick)}
+          popup
+          length={agendaLength}
+          onView={handleViewChange}
+          onNavigate={handleNavigate}
+          onRangeChange={handleRangeChange}
+          onSelectEvent={(event: CalendarEvent) => onItemClick?.(event.resource)}
+          onSelectSlot={(slot: SlotInfo) => {
+            if (!onSlotClick) return
+            onSlotClick({ start: slot.start, end: slot.end })
+          }}
+          eventPropGetter={(event: CalendarEvent) => ({
+            style: getEventStyles(event.resource),
+          })}
+          components={{
+            event: ({ event }: { event: CalendarEvent }) => {
+              const resource = event.resource
+              const hasLink = Boolean(resource.linkLabel) && typeof onItemClick === 'function'
+              return (
+                <div className="flex items-center justify-between gap-2">
+                  <span className="truncate text-xs font-medium">{resource.title}</span>
+                  {hasLink ? (
+                    <button
+                      type="button"
+                      className="text-[11px] font-medium underline-offset-2 hover:underline"
+                      onClick={(clickEvent) => {
+                        clickEvent.stopPropagation()
+                        onItemClick?.(resource)
+                      }}
+                    >
+                      {resource.linkLabel}
+                    </button>
+                  ) : null}
+                </div>
+              )
+            },
+          }}
+          style={{ height: 640 }}
+        />
+      </div>
+    </div>
+  )
+}

package/src/backend/schedule/index.ts

@@ -0,0 +1,5 @@
+export * from './types'
+export * from './ScheduleToolbar'
+export * from './ScheduleGrid'
+export * from './ScheduleAgenda'
+export * from './ScheduleView'

package/src/backend/schedule/recurrence.ts

@@ -0,0 +1,99 @@
+import type { ScheduleItem, ScheduleRange } from './types'
+
+type RuleMetadata = {
+  rrule?: string
+  exdates?: unknown
+}
+
+const DAY_MS = 24 * 60 * 60 * 1000
+
+function startOfDay(value: Date): Date {
+  return new Date(value.getFullYear(), value.getMonth(), value.getDate())
+}
+
+function toDateKey(value: Date): string {
+  const year = value.getFullYear()
+  const month = String(value.getMonth() + 1).padStart(2, '0')
+  const day = String(value.getDate()).padStart(2, '0')
+  return `${year}-${month}-${day}`
+}
+
+function parseRepeat(rrule: string): 'once' | 'daily' | 'weekly' {
+  const freqMatch = rrule.match(/FREQ=([A-Z]+)/)
+  const countMatch = rrule.match(/COUNT=(\d+)/)
+  const freq = freqMatch?.[1]
+  const count = countMatch?.[1] ? Number(countMatch[1]) : null
+  if (freq === 'WEEKLY') return 'weekly'
+  if (freq === 'DAILY') {
+    if (count === 1) return 'once'
+    return 'daily'
+  }
+  return 'once'
+}
+
+function parseRuleMetadata(item: ScheduleItem): RuleMetadata | null {
+  if (!item.metadata || typeof item.metadata !== 'object') return null
+  const metadata = item.metadata as { rule?: unknown }
+  if (!metadata.rule || typeof metadata.rule !== 'object') return null
+  const rule = metadata.rule as RuleMetadata
+  if (typeof rule.rrule !== 'string') return null
+  return rule
+}
+
+function normalizeExdates(exdates: unknown): Set<string> {
+  if (!Array.isArray(exdates)) return new Set()
+  const keys = exdates
+    .map((value) => {
+      if (typeof value !== 'string') return null
+      const parsed = new Date(value)
+      if (Number.isNaN(parsed.getTime())) return null
+      return toDateKey(parsed)
+    })
+    .filter((value): value is string => value !== null)
+  return new Set(keys)
+}
+
+export function expandRecurringItems(items: ScheduleItem[], range: ScheduleRange): ScheduleItem[] {
+  const expanded: ScheduleItem[] = []
+  const rangeStart = startOfDay(range.start)
+  const rangeEnd = startOfDay(range.end)
+
+  items.forEach((item) => {
+    const rule = parseRuleMetadata(item)
+    if (!rule) {
+      expanded.push(item)
+      return
+    }
+
+    const repeat = parseRepeat(rule.rrule ?? '')
+    if (repeat === 'once') {
+      expanded.push(item)
+      return
+    }
+
+    const durationMs = Math.max(0, item.endsAt.getTime() - item.startsAt.getTime())
+    const startHours = item.startsAt.getHours()
+    const startMinutes = item.startsAt.getMinutes()
+    const startSeconds = item.startsAt.getSeconds()
+    const startMs = item.startsAt.getMilliseconds()
+    const itemStartDay = startOfDay(item.startsAt)
+    const exdates = normalizeExdates(rule.exdates)
+
+    for (let cursor = new Date(rangeStart); cursor <= rangeEnd; cursor = new Date(cursor.getTime() + DAY_MS)) {
+      if (cursor < itemStartDay) continue
+      if (repeat === 'weekly' && cursor.getDay() !== item.startsAt.getDay()) continue
+      const dateKey = toDateKey(cursor)
+      if (exdates.has(dateKey)) continue
+      const start = new Date(cursor.getFullYear(), cursor.getMonth(), cursor.getDate(), startHours, startMinutes, startSeconds, startMs)
+      const end = new Date(start.getTime() + durationMs)
+      expanded.push({
+        ...item,
+        id: `${item.id}:${dateKey}`,
+        startsAt: start,
+        endsAt: end,
+      })
+    }
+  })
+
+  return expanded
+}

package/src/backend/schedule/types.ts

@@ -0,0 +1,26 @@
+export type ScheduleViewMode = 'day' | 'week' | 'month' | 'agenda'
+
+export type ScheduleRange = {
+  start: Date
+  end: Date
+}
+
+export type ScheduleSlot = {
+  start: Date
+  end: Date
+}
+
+export type ScheduleItem = {
+  id: string
+  kind: 'availability' | 'event' | 'exception'
+  title: string
+  startsAt: Date
+  endsAt: Date
+  status?: 'draft' | 'negotiation' | 'confirmed' | 'cancelled'
+  subjectType?: 'member' | 'resource'
+  subjectId?: string
+  color?: string
+  linkLabel?: string
+  linkHref?: string
+  metadata?: Record<string, unknown>
+}

package/src/backend/upgrades/UpgradeActionBanner.tsx

@@ -0,0 +1,128 @@
+"use client"
+import * as React from 'react'
+import { Sparkles } from 'lucide-react'
+import { Button } from '../../primitives/button'
+import { apiCall } from '../utils/apiCall'
+import { flash } from '../FlashMessages'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+
+const upgradeActionsEnabled =
+  process.env.NEXT_PUBLIC_UPGRADE_ACTIONS_ENABLED === 'true' ||
+  process.env.UPGRADE_ACTIONS_ENABLED === 'true'
+
+type UpgradeActionPayload = {
+  id: string
+  version: string
+  message: string
+  ctaLabel: string
+  successMessage?: string
+  loadingLabel?: string
+}
+
+type UpgradeActionResponse = {
+  version: string
+  actions?: UpgradeActionPayload[]
+  error?: string
+}
+
+type RunActionResponse = {
+  status?: 'completed' | 'already_completed'
+  message?: string
+  error?: string
+}
+
+export function UpgradeActionBanner() {
+  const t = useT()
+  const [action, setAction] = React.useState<UpgradeActionPayload | null>(null)
+  const [loading, setLoading] = React.useState(false)
+  const cancelledRef = React.useRef(false)
+
+  const loadNextAction = React.useCallback(async () => {
+    if (!upgradeActionsEnabled) return
+    if (typeof window === 'undefined' || typeof fetch === 'undefined') return
+    const call = await apiCall<UpgradeActionResponse>('/api/configs/upgrade-actions')
+    if (cancelledRef.current) return
+    if (!call.ok || !call.result || !Array.isArray(call.result.actions) || !call.result.actions.length) {
+      setAction(null)
+      return
+    }
+    setAction(call.result.actions[0]!)
+  }, [])
+
+  React.useEffect(() => {
+    cancelledRef.current = false
+    void loadNextAction()
+    return () => {
+      cancelledRef.current = true
+    }
+  }, [loadNextAction])
+
+  if (!upgradeActionsEnabled || !action) return null
+
+  async function handleRun() {
+    if (!upgradeActionsEnabled || !action || loading) return
+    setLoading(true)
+    try {
+      const response = await apiCall<RunActionResponse>('/api/configs/upgrade-actions', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ actionId: action.id }),
+      })
+      if (!response.ok) {
+        const baseError =
+          (response.result && typeof response.result.error === 'string' && response.result.error) ||
+          t('upgrades.runFailed', 'We could not run this upgrade action.')
+        const detail = response.result && typeof (response.result as any).details === 'string' ? (response.result as any).details : null
+        const errorMessage = detail ? `${baseError} (${detail})` : baseError
+        flash(errorMessage, 'error')
+        return
+      }
+      const message =
+        response.result?.message ||
+        action.successMessage ||
+        t('upgrades.v034.success', 'Example catalog products and categories installed.')
+      flash(message, 'success')
+      setAction(null)
+      await loadNextAction()
+    } catch (error) {
+      const message = error instanceof Error ? error.message : t('upgrades.runFailed', 'We could not run this upgrade action.')
+      flash(message, 'error')
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const loadingLabel = action.loadingLabel || t('upgrades.v034.loading', 'Installing…')
+  const title = action.ctaLabel || action.message
+  const description = action.message && action.message !== title ? action.message : null
+
+  return (
+    <div className="mb-4 flex flex-col gap-3 rounded-md border border-amber-300 bg-amber-50 px-3 py-3 text-sm text-amber-900 md:flex-row md:items-center md:justify-between">
+      <div className="flex items-start gap-2 text-sm">
+        <Sparkles className="mt-0.5 size-4 text-amber-700" aria-hidden="true" />
+        <div className="flex flex-col gap-1">
+          <div className="font-medium text-amber-950">
+            {title}
+          </div>
+          {description ? (
+            <div className="text-xs text-amber-900/80">
+              {description}
+            </div>
+          ) : null}
+          <div className="text-xs text-amber-900/80">{t('upgrades.versionLabel', { version: action.version })}</div>
+        </div>
+      </div>
+      <div className="flex flex-wrap items-center gap-2">
+        <Button
+          variant="outline"
+          size="sm"
+          onClick={() => { void handleRun() }}
+          disabled={loading}
+          className="border-amber-300 text-amber-900 hover:bg-amber-100"
+        >
+          {loading ? loadingLabel : action.ctaLabel}
+        </Button>
+      </div>
+    </div>
+  )
+}

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

@@ -0,0 +1,109 @@
+jest.mock('../../utils/api', () => ({
+  apiFetch: jest.fn(),
+}))
+jest.mock('../../utils/serverErrors', () => {
+  const actual = jest.requireActual('../../utils/serverErrors')
+  return {
+    ...actual,
+    raiseCrudError: jest.fn(),
+  }
+})
+
+import { apiFetch } from '../../utils/api'
+import { raiseCrudError } from '../../utils/serverErrors'
+import { apiCall, apiCallOrThrow, readApiResultOrThrow } from '../../utils/apiCall'
+
+function createMockResponse(body: string, init?: { status?: number }): Response {
+  const status = init?.status ?? 200
+  const ok = status >= 200 && status < 300
+  const responseBody = body
+  return {
+    ok,
+    status,
+    headers: new Map<string, string>(),
+    text: jest.fn(async () => responseBody),
+    clone: () => createMockResponse(responseBody, { status }),
+  } as unknown as Response
+}
+
+describe('apiCall', () => {
+  beforeEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('returns parsed JSON result by default', async () => {
+    const payload = { ok: true }
+    const response = createMockResponse(JSON.stringify(payload), { status: 200 })
+    ;(apiFetch as jest.Mock).mockResolvedValue(response)
+    const result = await apiCall<{ ok: boolean }>('/api/test')
+    expect(result.ok).toBe(true)
+    expect(result.status).toBe(200)
+    expect(result.result).toEqual(payload)
+    expect(result.response).toBe(response)
+  })
+
+  it('uses fallback when parsing fails', async () => {
+    ;(apiFetch as jest.Mock).mockResolvedValue(new Response('not json', { status: 200 }))
+    const result = await apiCall<{ ok: boolean }>('/api/test', undefined, { fallback: { ok: false } })
+    expect(result.result).toEqual({ ok: false })
+  })
+
+  it('supports custom parser', async () => {
+    const response = new Response('data', { status: 202 })
+    ;(apiFetch as jest.Mock).mockResolvedValue(response)
+    const parser = jest.fn(async () => ({ parsed: true }))
+    const result = await apiCall<{ parsed: boolean }>('/api/custom', undefined, { parse: parser })
+    expect(parser).toHaveBeenCalled()
+    expect(result.result).toEqual({ parsed: true })
+  })
+})
+
+describe('apiCallOrThrow', () => {
+  beforeEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('returns call result when successful', async () => {
+    const payload = { ok: true }
+    const response = createMockResponse(JSON.stringify(payload), { status: 200 })
+    ;(apiFetch as jest.Mock).mockResolvedValue(response)
+    const call = await apiCallOrThrow<{ ok: boolean }>('/api/success', undefined, { errorMessage: 'failed' })
+    expect(call.ok).toBe(true)
+    expect(call.result).toEqual(payload)
+    expect(raiseCrudError).not.toHaveBeenCalled()
+  })
+
+  it('delegates to raiseCrudError when response is not ok', async () => {
+    const response = createMockResponse(JSON.stringify({ error: 'nope' }), { status: 500 })
+    ;(apiFetch as jest.Mock).mockResolvedValue(response)
+    ;(raiseCrudError as jest.Mock).mockRejectedValue(new Error('nope'))
+    await expect(apiCallOrThrow('/api/fail', undefined, { errorMessage: 'failed' })).rejects.toThrow('nope')
+    expect(raiseCrudError).toHaveBeenCalledWith(response, 'failed')
+  })
+})
+
+describe('readApiResultOrThrow', () => {
+  beforeEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('returns parsed result when present', async () => {
+    const payload = { ok: true }
+    ;(apiFetch as jest.Mock).mockResolvedValue(createMockResponse(JSON.stringify(payload), { status: 200 }))
+    const result = await readApiResultOrThrow<{ ok: boolean }>('/api/result')
+    expect(result).toEqual(payload)
+  })
+
+  it('throws when result is null and not allowed', async () => {
+    ;(apiFetch as jest.Mock).mockResolvedValue(createMockResponse('', { status: 200 }))
+    await expect(
+      readApiResultOrThrow('/api/empty', undefined, { errorMessage: 'failed', emptyResultMessage: 'missing' }),
+    ).rejects.toThrow('missing')
+  })
+
+  it('allows null result when configured', async () => {
+    ;(apiFetch as jest.Mock).mockResolvedValue(createMockResponse('', { status: 200 }))
+    const result = await readApiResultOrThrow('/api/empty-ok', undefined, { allowNullResult: true })
+    expect(result).toBeNull()
+  })
+})

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

@@ -0,0 +1,87 @@
+jest.mock('../../utils/apiCall', () => ({
+  apiCall: jest.fn(),
+}))
+jest.mock('../../utils/serverErrors', () => ({
+  raiseCrudError: jest.fn().mockResolvedValue(undefined),
+}))
+
+import { apiCall } from '../../utils/apiCall'
+import { raiseCrudError } from '../../utils/serverErrors'
+import { createCrud, deleteCrud, updateCrud } from '../crud'
+
+const response = new Response('ok', { status: 200 })
+
+describe('crud helpers', () => {
+  beforeEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('createCrud resolves with parsed result', async () => {
+    const payload = { id: '123' }
+    ;(apiCall as jest.Mock).mockResolvedValue({
+      ok: true,
+      status: 201,
+      result: payload,
+      response,
+    })
+
+    const result = await createCrud<{ id: string }>('example/todos', { title: 'Test' })
+    expect(result.result).toEqual(payload)
+    expect(apiCall).toHaveBeenCalledWith(
+      '/api/example/todos',
+      expect.objectContaining({ method: 'POST' }),
+      expect.any(Object),
+    )
+  })
+
+  it('createCrud delegates error handling when request fails', async () => {
+    ;(apiCall as jest.Mock).mockResolvedValue({
+      ok: false,
+      status: 400,
+      result: null,
+      response,
+    })
+    const rejection = new Error('fail')
+    ;(raiseCrudError as jest.Mock).mockRejectedValue(rejection)
+    await expect(createCrud('example/todos', { title: 'Test' })).rejects.toThrow('fail')
+    expect(raiseCrudError).toHaveBeenCalledWith(response, 'Failed to create')
+  })
+
+  it('updateCrud uses PUT and returns ApiCallResult', async () => {
+    const callResult = { ok: true, status: 200, result: { updated: true }, response }
+    ;(apiCall as jest.Mock).mockResolvedValue(callResult)
+    const result = await updateCrud<{ updated: boolean }>('example/todos', { id: '1' })
+    expect(result).toBe(callResult)
+    expect(apiCall).toHaveBeenLastCalledWith(
+      '/api/example/todos',
+      expect.objectContaining({ method: 'PUT' }),
+      expect.any(Object),
+    )
+  })
+
+  it('deleteCrud supports id parameter', async () => {
+    const callResult = { ok: true, status: 200, result: null, response }
+    ;(apiCall as jest.Mock).mockResolvedValue(callResult)
+    const result = await deleteCrud('example/todos', '123')
+    expect(result).toBe(callResult)
+    expect(apiCall).toHaveBeenCalledWith(
+      '/api/example/todos?id=123',
+      expect.objectContaining({ method: 'DELETE' }),
+      expect.any(Object),
+    )
+  })
+
+  it('deleteCrud supports JSON body payload', async () => {
+    const callResult = { ok: true, status: 200, result: null, response }
+    ;(apiCall as jest.Mock).mockResolvedValue(callResult)
+    await deleteCrud('example/todos', { body: { id: 'abc' } })
+    expect(apiCall).toHaveBeenCalledWith(
+      '/api/example/todos',
+      expect.objectContaining({
+        method: 'DELETE',
+        body: JSON.stringify({ id: 'abc' }),
+      }),
+      expect.any(Object),
+    )
+  })
+})

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

@@ -0,0 +1,25 @@
+import { fetchCustomFieldDefs, normalizeEntityIds } from '../customFieldDefs'
+
+const createFetchStub = (payload: unknown) => {
+  const json = jest.fn().mockResolvedValue(payload)
+  return Object.assign(jest.fn().mockResolvedValue({ json }), { json })
+}
+
+describe('customFieldDefs utilities', () => {
+  it('normalizes entity ids and removes duplicates', () => {
+    expect(normalizeEntityIds([' alpha ', 'ALPHA', 'beta', null as any])).toEqual(['alpha', 'ALPHA', 'beta'])
+  })
+
+  it('fetches definitions via provided fetch implementation and sorts by priority', async () => {
+    const stub = createFetchStub({
+      items: [
+        { key: 'b', priority: 5 },
+        { key: 'a', priority: 1 },
+        { key: 'c' },
+      ],
+    })
+    const defs = await fetchCustomFieldDefs(['entity.one'], stub as unknown as typeof fetch)
+    expect(stub).toHaveBeenCalledWith('/api/entities/definitions?entityId=entity.one', expect.any(Object))
+    expect(defs.map((d) => d.key)).toEqual(['c', 'a', 'b'])
+  })
+})