@freighttech/ui 0.13.18

package/src/backend/settings/index.ts

@@ -0,0 +1,3 @@
+export * from './SettingsNavigation'
+export { SettingsPageWrapper } from './SettingsPageWrapper'
+export type { SettingsPageWrapperProps } from './SettingsPageWrapper'

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__/api.scoped-headers.test.ts

@@ -0,0 +1,58 @@
+import { apiFetch, withScopedApiHeaders } from '../api'
+
+describe('withScopedApiHeaders', () => {
+  const originalFetch = (globalThis as { fetch?: typeof fetch }).fetch
+
+  beforeEach(() => {
+    jest.restoreAllMocks()
+    ;(globalThis as { fetch?: jest.Mock }).fetch = jest.fn(async () => new Response('{}', { status: 200 }))
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+    ;(globalThis as { fetch?: typeof fetch }).fetch = originalFetch
+  })
+
+  test('removes the correct scoped header when overlapping scopes finish out of order', async () => {
+    let releaseFirst: (() => void) | null = null
+    let releaseSecond: (() => void) | null = null
+
+    const firstPending = new Promise<void>((resolve) => {
+      releaseFirst = resolve
+    })
+    const secondPending = new Promise<void>((resolve) => {
+      releaseSecond = resolve
+    })
+
+    const firstScope = withScopedApiHeaders(
+      { 'x-first-scope': 'first' },
+      async () => {
+        await firstPending
+      },
+    )
+
+    const secondScope = withScopedApiHeaders(
+      { 'x-second-scope': 'second' },
+      async () => {
+        await secondPending
+      },
+    )
+
+    if (!releaseFirst || !releaseSecond) throw new Error('Test setup failed')
+
+    releaseFirst()
+    await firstScope
+
+    await apiFetch('/api/test')
+
+    releaseSecond()
+    await secondScope
+
+    const call = ((globalThis as { fetch?: jest.Mock }).fetch as jest.Mock).mock.calls[0]
+    expect(call).toBeDefined()
+
+    const headers = new Headers((call?.[1] as RequestInit | undefined)?.headers)
+    expect(headers.get('x-first-scope')).toBeNull()
+    expect(headers.get('x-second-scope')).toBe('second')
+  })
+})

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

@@ -0,0 +1,148 @@
+/**
+ * @jest-environment jsdom
+ */
+jest.mock('../../FlashMessages', () => ({
+  flash: jest.fn(),
+}))
+
+import { flash } from '../../FlashMessages'
+import {
+  ForbiddenError,
+  UnauthorizedError,
+  apiFetch,
+} from '../../utils/api'
+
+function createMockResponse(
+  status: number,
+  body: unknown,
+  headers?: Record<string, string>,
+): Response {
+  const serializedBody =
+    typeof body === 'string' ? body : JSON.stringify(body ?? {})
+  const headerMap = new Map<string, string>(
+    Object.entries(headers ?? {}).map(([key, value]) => [
+      key.toLowerCase(),
+      value,
+    ]),
+  )
+  const build = () =>
+    ({
+      ok: status >= 200 && status < 300,
+      status,
+      headers: {
+        get: (key: string) => headerMap.get(key.toLowerCase()) ?? null,
+      },
+      json: async () => JSON.parse(serializedBody),
+      text: async () => serializedBody,
+      clone: () => build(),
+    }) as Response
+  return build()
+}
+
+describe('apiFetch', () => {
+  beforeEach(() => {
+    jest.resetAllMocks()
+    jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+    jest.useFakeTimers()
+    window.history.pushState({}, '', '/backend/sales/documents')
+    ;(window as unknown as Record<string, unknown>).__omOriginalFetch = undefined
+  })
+
+  afterEach(() => {
+    ;(window as unknown as Record<string, unknown>).__omOriginalFetch = undefined
+    jest.clearAllTimers()
+    jest.useRealTimers()
+    jest.restoreAllMocks()
+  })
+
+  it('throws ForbiddenError when backend returns ACL hints', async () => {
+    ;(window as unknown as Record<string, unknown>).__omOriginalFetch = jest.fn(async () =>
+      createMockResponse(403, {
+        error: 'Forbidden',
+        requiredRoles: ['Admin'],
+      }),
+    )
+
+    await expect(apiFetch('/api/private')).rejects.toBeInstanceOf(ForbiddenError)
+    expect(flash).toHaveBeenCalledWith(
+      'Insufficient permissions. Redirecting to login…',
+      'warning',
+    )
+  })
+
+  it('throws ForbiddenError when ACL hints are missing', async () => {
+    const response = createMockResponse(403, {
+      error: 'Forbidden',
+      message: 'Access denied without ACL hints',
+    })
+    ;(window as unknown as Record<string, unknown>).__omOriginalFetch = jest.fn(async () => response)
+
+    await expect(apiFetch('/api/private')).rejects.toBeInstanceOf(ForbiddenError)
+    expect(flash).not.toHaveBeenCalled()
+  })
+
+  it('does not redirect on login page and returns 403 payload', async () => {
+    window.history.pushState({}, '', '/login')
+    const response = createMockResponse(403, {
+      error: 'Forbidden',
+      requiredRoles: ['Admin'],
+    })
+    ;(window as unknown as Record<string, unknown>).__omOriginalFetch = jest.fn(async () => response)
+
+    const result = await apiFetch('/api/private')
+    expect(result).toBe(response)
+    expect(flash).not.toHaveBeenCalled()
+  })
+
+  it('returns the 403 payload — and schedules no navigation — when the forbidden redirect is disabled', async () => {
+    // The counterpart of the first case above, and the half HEDGE-180 leaned
+    // on: with ACL hints present, the default is to navigate the document to
+    // /login. Callers that only want the picker to fail (not the page) opt out
+    // with this header, so the 403 has to come back as a plain Response and
+    // leave no pending `setTimeout` carrying `location.href = '/login…'`.
+    const response = createMockResponse(403, {
+      error: 'Forbidden',
+      requiredFeatures: ['auth.users.list'],
+    })
+    ;(window as unknown as Record<string, unknown>).__omOriginalFetch = jest.fn(async () => response)
+
+    const result = await apiFetch('/api/auth/users?pageSize=50', {
+      headers: {
+        'x-om-forbidden-redirect': '0',
+      },
+    })
+
+    expect(result).toBe(response)
+    expect(flash).not.toHaveBeenCalled()
+    expect(jest.getTimerCount()).toBe(0)
+    expect(window.location.pathname).toBe('/backend/sales/documents')
+  })
+
+  it('returns 401 payload when unauthorized redirect is disabled', async () => {
+    const response = createMockResponse(401, {
+      error: 'checkout.payPage.errors.password',
+    })
+    ;(window as unknown as Record<string, unknown>).__omOriginalFetch = jest.fn(async () => response)
+
+    const result = await apiFetch('/api/private', {
+      headers: {
+        'x-om-unauthorized-redirect': '0',
+      },
+    })
+
+    expect(result).toBe(response)
+    expect(flash).not.toHaveBeenCalled()
+  })
+
+  it('throws UnauthorizedError for 401 responses by default', async () => {
+    ;(window as unknown as Record<string, unknown>).__omOriginalFetch = jest.fn(async () =>
+      createMockResponse(401, { error: 'Unauthorized' }),
+    )
+
+    await expect(apiFetch('/api/private')).rejects.toBeInstanceOf(UnauthorizedError)
+    expect(flash).toHaveBeenCalledWith(
+      'Session expired. Redirecting to sign in…',
+      'warning',
+    )
+  })
+})

package/src/backend/utils/__tests__/apiCall.scoped-request-headers.test.ts

@@ -0,0 +1,58 @@
+import { apiCall, withScopedApiRequestHeaders } from '../apiCall'
+
+describe('withScopedApiRequestHeaders', () => {
+  const originalFetch = (globalThis as { fetch?: typeof fetch }).fetch
+
+  beforeEach(() => {
+    jest.restoreAllMocks()
+    ;(globalThis as { fetch?: jest.Mock }).fetch = jest.fn(async () => new Response('{}', { status: 200 }))
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+    ;(globalThis as { fetch?: typeof fetch }).fetch = originalFetch
+  })
+
+  test('removes only completed request scope when scopes finish out of order', async () => {
+    let releaseFirst: (() => void) | null = null
+    let releaseSecond: (() => void) | null = null
+
+    const firstPending = new Promise<void>((resolve) => {
+      releaseFirst = resolve
+    })
+    const secondPending = new Promise<void>((resolve) => {
+      releaseSecond = resolve
+    })
+
+    const firstScope = withScopedApiRequestHeaders(
+      { 'x-first-scope': 'first' },
+      async () => {
+        await firstPending
+      },
+    )
+
+    const secondScope = withScopedApiRequestHeaders(
+      { 'x-second-scope': 'second' },
+      async () => {
+        await secondPending
+      },
+    )
+
+    if (!releaseFirst || !releaseSecond) throw new Error('Test setup failed')
+
+    releaseFirst()
+    await firstScope
+
+    await apiCall('/api/test')
+
+    releaseSecond()
+    await secondScope
+
+    const call = ((globalThis as { fetch?: jest.Mock }).fetch as jest.Mock).mock.calls[0]
+    expect(call).toBeDefined()
+
+    const headers = new Headers((call?.[1] as RequestInit | undefined)?.headers)
+    expect(headers.get('x-first-scope')).toBeNull()
+    expect(headers.get('x-second-scope')).toBe('second')
+  })
+})

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'])
+  })
+})

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

@@ -0,0 +1,35 @@
+import { collectCustomFieldValues } from '../customFieldValues'
+
+describe('collectCustomFieldValues', () => {
+  it('strips cf_ prefix by default', () => {
+    const input = { cf_name: 'Alice', cf_age: 30, email: 'alice@example.com' }
+    expect(collectCustomFieldValues(input)).toEqual({ name: 'Alice', age: 30 })
+  })
+
+  it('handles cf: prefix and keeps both by default', () => {
+    const input = { 'cf:city': 'Berlin', cf_country: 'DE' }
+    expect(collectCustomFieldValues(input)).toEqual({ city: 'Berlin', country: 'DE' })
+  })
+
+  it('applies transform and accept hooks', () => {
+    const input = { cf_name: 'Alice', cf_notes: '', cf_skip: 'value' }
+    const result = collectCustomFieldValues(input, {
+      transform: (value) => (typeof value === 'string' ? value.trim() : value),
+      accept: (fieldId) => fieldId !== 'skip',
+    })
+    expect(result).toEqual({ name: 'Alice', notes: '' })
+  })
+
+  it('retains prefix when stripPrefix is false', () => {
+    const input = { cf_name: 'Alice' }
+    expect(collectCustomFieldValues(input, { stripPrefix: false })).toEqual({ cf_name: 'Alice' })
+  })
+
+  it('omits undefined results when requested', () => {
+    const input = { cf_name: 'Alice', cf_age: 30, cf_extra: null }
+    const result = collectCustomFieldValues(input, {
+      transform: (value, key) => (key === 'extra' ? undefined : value),
+    })
+    expect(result).toEqual({ name: 'Alice', age: 30 })
+  })
+})