@open-mercato/core 0.6.7-develop.6834.1.e76f4b8cbc → 0.6.7-develop.6851.1.c1680b00d8

package/src/modules/directory/i18n/ko.json

@@ -0,0 +1,105 @@
+{
+  "directory.audit.organizations.create": "조직 생성",
+  "directory.audit.organizations.delete": "조직 삭제",
+  "directory.audit.organizations.update": "조직 수정",
+  "directory.audit.tenants.create": "테넌트 생성",
+  "directory.audit.tenants.delete": "테넌트 삭제",
+  "directory.audit.tenants.update": "테넌트 수정",
+  "directory.branding.actions.reset": "기본 로고 사용",
+  "directory.branding.actions.save": "브랜딩 저장",
+  "directory.branding.aspectRatio.description": "비활성화되면 사이드바에서 로고가 표준 아이콘 모양으로 잘립니다.",
+  "directory.branding.aspectRatio.label": "가로 세로 비율 유지",
+  "directory.branding.currentScope": "현재 조직",
+  "directory.branding.description": "현재 선택된 조직에 대해 백엔드 사이드바에 사용되는 로고를 설정하세요.",
+  "directory.branding.errors.blocked": "브랜딩 저장이 차단되었습니다.",
+  "directory.branding.errors.invalidLogoUrl": "유효한 이미지 URL을 입력하세요.",
+  "directory.branding.errors.load": "조직 브랜딩을 불러오지 못했습니다",
+  "directory.branding.errors.notFound": "조직을 찾을 수 없습니다",
+  "directory.branding.errors.organizationRequired": "사이드바 브랜딩을 변경하기 전에 단일 조직을 선택하세요.",
+  "directory.branding.errors.save": "조직 브랜딩 업데이트에 실패했습니다",
+  "directory.branding.errors.upload": "로고 업로드에 실패했습니다",
+  "directory.branding.file.hint": "PNG, JPG, WebP 또는 SVG가 가장 적합합니다. 업로드된 파일은 조직 첨부 파일로 저장됩니다.",
+  "directory.branding.file.label": "로고 업로드",
+  "directory.branding.flash.saved": "조직 브랜딩이 업데이트되었습니다",
+  "directory.branding.loading": "조직 브랜딩을 불러오는 중...",
+  "directory.branding.nav": "조직 브랜딩",
+  "directory.branding.previewAlt": "{{name}} 로고 미리보기",
+  "directory.branding.title": "조직 브랜딩",
+  "directory.branding.url.hint": "외부 이미지 URL을 사용하거나 비워 두면 기본 Open Mercato 로고로 대체됩니다.",
+  "directory.branding.url.label": "로고 URL",
+  "directory.branding.url.placeholder": "https://example.com/logo.svg",
+  "directory.nav.group": "디렉터리",
+  "directory.nav.organizations": "조직",
+  "directory.nav.organizations.create": "조직 생성",
+  "directory.nav.tenants": "테넌트",
+  "directory.nav.tenants.create": "테넌트 생성",
+  "directory.organizations.common.none": "—",
+  "directory.organizations.errors.deleteFailed": "조직 삭제에 실패했습니다",
+  "directory.organizations.errors.orgIdRequired": "조직 식별자는 필수입니다",
+  "directory.organizations.errors.tenantRequired": "슈퍼 관리자는 테넌트 선택이 필요합니다",
+  "directory.organizations.flash.created": "조직이 생성되었습니다",
+  "directory.organizations.flash.deleted": "조직이 삭제되었습니다",
+  "directory.organizations.flash.updated": "조직이 수정되었습니다",
+  "directory.organizations.form.action.create": "생성",
+  "directory.organizations.form.action.save": "저장",
+  "directory.organizations.form.actions.backToList": "조직 목록으로 돌아가기",
+  "directory.organizations.form.children.empty": "직접 할당된 하위 조직이 없습니다.",
+  "directory.organizations.form.errors.load": "조직을 불러오지 못했습니다",
+  "directory.organizations.form.errors.missingId": "조직 식별자가 누락되었습니다.",
+  "directory.organizations.form.errors.notFound": "조직을 찾을 수 없습니다",
+  "directory.organizations.form.field.children": "하위 조직",
+  "directory.organizations.form.field.isActive": "활성",
+  "directory.organizations.form.field.name": "이름",
+  "directory.organizations.form.field.parent": "상위 조직",
+  "directory.organizations.form.field.slug": "슬러그",
+  "directory.organizations.form.field.slug.description": "고객 포털에 사용되는 URL 안전 식별자입니다 (소문자, 숫자, 하이픈, 밑줄).",
+  "directory.organizations.form.field.tenant": "테넌트",
+  "directory.organizations.form.field.tenantReadonlyDescription": "기존 조직의 테넌트를 변경할 수 없습니다.",
+  "directory.organizations.form.group.customFields": "커스텀 데이터",
+  "directory.organizations.form.group.details": "상세 정보",
+  "directory.organizations.form.loading": "조직을 불러오는 중...",
+  "directory.organizations.form.pathLabel": "경로: {path}",
+  "directory.organizations.form.rootOption": "— 최상위 레벨 —",
+  "directory.organizations.form.tenant.select": "테넌트 선택",
+  "directory.organizations.form.title.edit": "조직 편집",
+  "directory.organizations.list.actions.create": "생성",
+  "directory.organizations.list.actions.delete": "삭제",
+  "directory.organizations.list.actions.edit": "편집",
+  "directory.organizations.list.columns.active": "활성",
+  "directory.organizations.list.columns.children": "하위 조직",
+  "directory.organizations.list.columns.organization": "조직",
+  "directory.organizations.list.columns.parent": "상위 조직",
+  "directory.organizations.list.columns.path": "경로",
+  "directory.organizations.list.columns.tenant": "테넌트",
+  "directory.organizations.list.confirmDelete": "조직 \"{{name}}\"을(를) 보관하시겠습니까?",
+  "directory.organizations.list.error.delete": "조직 삭제에 실패했습니다",
+  "directory.organizations.list.error.load": "조직을 불러오지 못했습니다",
+  "directory.organizations.list.filters.active": "활성",
+  "directory.organizations.list.filters.all": "전체",
+  "directory.organizations.list.filters.inactive": "비활성",
+  "directory.organizations.list.filters.status": "상태",
+  "directory.organizations.list.searchPlaceholder": "조직 검색",
+  "directory.organizations.list.title": "조직",
+  "directory.tenants.form.actions.backToList": "테넌트 목록으로 돌아가기",
+  "directory.tenants.form.errors.delete": "테넌트 삭제에 실패했습니다",
+  "directory.tenants.form.errors.load": "테넌트를 불러오지 못했습니다",
+  "directory.tenants.form.errors.notFound": "테넌트를 찾을 수 없습니다",
+  "directory.tenants.form.fields.active": "활성",
+  "directory.tenants.form.fields.name": "이름",
+  "directory.tenants.form.groups.custom": "커스텀 데이터",
+  "directory.tenants.form.groups.details": "상세 정보",
+  "directory.tenants.form.loading": "테넌트를 불러오는 중…",
+  "directory.tenants.form.title.edit": "테넌트 편집",
+  "directory.tenants.list.actions.create": "생성",
+  "directory.tenants.list.columns.active": "활성",
+  "directory.tenants.list.columns.created": "생성일",
+  "directory.tenants.list.columns.tenant": "테넌트",
+  "directory.tenants.list.confirmDelete": "테넌트 \"{{name}}\"을(를) 삭제하시겠습니까? 보관 처리됩니다.",
+  "directory.tenants.list.error.delete": "테넌트 삭제에 실패했습니다",
+  "directory.tenants.list.error.load": "테넌트를 불러오지 못했습니다",
+  "directory.tenants.list.filters.active": "활성",
+  "directory.tenants.list.filters.inactive": "비활성",
+  "directory.tenants.list.filters.status": "상태",
+  "directory.tenants.list.success.delete": "테넌트가 삭제되었습니다",
+  "directory.tenants.list.title": "테넌트"
+}

package/src/modules/entities/api/definitions.ts

@@ -441,6 +441,9 @@ export async function GET(req: Request) {
         label: d.configJson?.label || d.key,
         description: d.configJson?.description || undefined,
         multi: Boolean(d.configJson?.multi),
+        relatedEntityId: d.kind === 'relation' && typeof d.configJson?.relatedEntityId === 'string'
+          ? d.configJson.relatedEntityId.trim() || undefined
+          : undefined,
         options: (() => {
           if (d.kind === 'currency') return undefined
           const normalizedOptions = normalizeCustomFieldOptions(d.configJson?.options)
@@ -707,6 +710,7 @@ const customFieldDefinitionSchema = z.object({
   label: z.string(),
   description: z.string().optional(),
   multi: z.boolean().optional(),
+  relatedEntityId: z.string().optional(),
   options: z.array(customFieldOptionValueSchema).optional(),
   optionsUrl: z.string().optional(),
   filterable: z.boolean().optional(),

package/src/modules/entities/backend/entities/user/[entityId]/records/page.tsx

@@ -4,7 +4,7 @@ import { resolveExtensionPointPattern } from '@open-mercato/shared/modules/widge
 import { extensionPoints } from '@open-mercato/core/modules/entities/extension-points'
 import { useSearchParams } from 'next/navigation'
 import type { ColumnDef, SortingState } from '@tanstack/react-table'
-import { filterCustomFieldDefs, useCustomFieldDefs } from '@open-mercato/ui/backend/utils/customFieldDefs'
+import { filterCustomFieldDefs, useCustomFieldDefs, type CustomFieldDefDto } from '@open-mercato/ui/backend/utils/customFieldDefs'
 import { Page, PageBody } from '@open-mercato/ui/backend/Page'
 import { DataTable, type DataTableExportFormat } from '@open-mercato/ui/backend/DataTable'
 import type { PreparedExport } from '@open-mercato/shared/lib/crud/exporters'
@@ -23,6 +23,11 @@ import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuarde
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { ErrorMessage, LoadingMessage } from '@open-mercato/ui/backend/detail'
 import { useRecordsEntityGuard } from '@open-mercato/core/modules/entities/components/useRecordsEntityGuard'
+import {
+  RelationCell,
+  RelationDisplaysProvider,
+  useRecordListRelationDisplays,
+} from '@open-mercato/core/modules/entities/components/RecordListRelationCell'
 
 type RecordsResponse = {
   items: any[]
@@ -98,6 +103,13 @@ function RecordsPageInner({ params }: { params: { entityId?: string } }) {
     enabled: Boolean(entityId),
     keyExtras: [scopeVersion],
   })
+  const relationDefinitions = React.useMemo(
+    () => filterCustomFieldDefs(cfDefs, 'list').filter(
+      (definition): definition is CustomFieldDefDto => definition.kind === 'relation',
+    ),
+    [cfDefs],
+  )
+  const relationDisplaysByField = useRecordListRelationDisplays(relationDefinitions, rawData)
 
   // Fields searched server-side: every visible column plus the base `id`.
   const searchableFields = React.useMemo(() => {
@@ -182,7 +194,10 @@ function RecordsPageInner({ params }: { params: { entityId?: string } }) {
       meta: { priority: idx < 4 ? 1 : idx < 6 ? 2 : idx < 8 ? 3 : idx < maxVisible ? 4 : 5 },
       cell: ({ getValue }: { getValue: () => unknown }) => {
         const v = getValue() as any
-        return <span className="truncate max-w-[24ch] inline-block align-top" title={normalizeCell(v)}>{normalizeCell(v)}</span>
+        if (d.kind === 'relation') {
+          return <RelationCell fieldKey={d.key} value={v} fallbackText={normalizeCell(v)} />
+        }
+        return <span className="inline-block max-w-60 truncate align-top" title={normalizeCell(v)}>{normalizeCell(v)}</span>
       },
     }))
     // Ensure hidden 'id' column exists for sorting/state
@@ -378,81 +393,83 @@ export RECORD_ID="<record uuid>"`}</code></pre>
             </div>
           </div>
         </ContextHelp>
-        <DataTable
-          stickyActionsColumn
-          title={`Records: ${entityId}`}
-          entityId={entityId}
-          actions={actions}
-          columns={columns}
-          data={data}
-          perspective={{
-            tableId: resolveExtensionPointPattern(extensionPoints.hosts.userRecordsTable.pattern, { entityId }),
-          }}
-          exporter={exportConfig}
-          filters={baseFilters}
-          filterValues={filterValues}
-          rowActions={(row) => (
-            <RowActions
-              items={[
-                { id: 'edit', label: 'Edit', href: `/backend/entities/user/${encodeURIComponent(entityId)}/records/${encodeURIComponent(String((row as any).id))}` },
-                { id: 'delete', label: 'Delete', destructive: true, onSelect: async () => {
-                  const recordId = String((row as any).id)
-                  try {
-                    const confirmed = await confirm({
-                      title: 'Delete this record?',
-                      variant: 'destructive',
-                    })
-                    if (!confirmed) return
-                    await runDeleteMutation({
-                      operation: async () => {
-                        const deleteCall = await withScopedApiRequestHeaders(
-                          buildOptimisticLockHeader((row as any).updatedAt),
-                          () => apiCall(
-                            `/api/entities/records?entityId=${encodeURIComponent(entityId)}&recordId=${encodeURIComponent(recordId)}`,
-                            { method: 'DELETE' },
-                          ),
-                        )
-                        if (!deleteCall.ok) {
-                          await raiseCrudError(deleteCall.response, 'Failed to delete record')
-                        }
-                      },
-                      context: {
-                        formId: deleteMutationContextId,
-                        resourceKind: 'entities.record',
-                        resourceId: recordId,
-                        retryLastMutation: retryDeleteMutation,
-                      },
-                    })
-                    const j = await readApiResultOrThrow<RecordsResponse>(
-                      `/api/entities/records?entityId=${encodeURIComponent(entityId)}&page=${page}&pageSize=${pageSize}`,
-                      undefined,
-                      {
-                        errorMessage: 'Failed to reload records',
-                        fallback: { items: [], total: 0, page, pageSize, totalPages: 1 },
-                      },
-                    )
-                    setRawData(j.items || [])
-                    setTotal(j.total || 0)
-                    setTotalPages(j.totalPages || 1)
-                    flash('Record has been removed', 'success')
-                  } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Failed to delete record'
-                    flash(message, 'error')
-                  }
-                } },
-              ]}
-            />
-          )}
-          sortable
-          sorting={sorting}
-          onSortingChange={setSorting}
-          searchValue={search}
-          onSearchChange={(v) => { setSearch(v); setPage(1) }}
-          onFiltersApply={(vals) => { setFilterValues(vals); setPage(1) }}
-          onFiltersClear={() => { setFilterValues({}); setPage(1) }}
-          pagination={{ page, pageSize, total, totalPages, onPageChange: setPage }}
-          isLoading={loading}
-        />
+        <RelationDisplaysProvider displaysByField={relationDisplaysByField}>
+          <DataTable
+            stickyActionsColumn
+            title={`Records: ${entityId}`}
+            entityId={entityId}
+            actions={actions}
+            columns={columns}
+            data={data}
+            perspective={{
+              tableId: resolveExtensionPointPattern(extensionPoints.hosts.userRecordsTable.pattern, { entityId }),
+            }}
+            exporter={exportConfig}
+            filters={baseFilters}
+            filterValues={filterValues}
+            rowActions={(row) => (
+              <RowActions
+                items={[
+                  { id: 'edit', label: 'Edit', href: `/backend/entities/user/${encodeURIComponent(entityId)}/records/${encodeURIComponent(String((row as any).id))}` },
+                  { id: 'delete', label: 'Delete', destructive: true, onSelect: async () => {
+                    const recordId = String((row as any).id)
+                    try {
+                      const confirmed = await confirm({
+                        title: 'Delete this record?',
+                        variant: 'destructive',
+                      })
+                      if (!confirmed) return
+                      await runDeleteMutation({
+                        operation: async () => {
+                          const deleteCall = await withScopedApiRequestHeaders(
+                            buildOptimisticLockHeader((row as any).updatedAt),
+                            () => apiCall(
+                              `/api/entities/records?entityId=${encodeURIComponent(entityId)}&recordId=${encodeURIComponent(recordId)}`,
+                              { method: 'DELETE' },
+                            ),
+                          )
+                          if (!deleteCall.ok) {
+                            await raiseCrudError(deleteCall.response, 'Failed to delete record')
+                          }
+                        },
+                        context: {
+                          formId: deleteMutationContextId,
+                          resourceKind: 'entities.record',
+                          resourceId: recordId,
+                          retryLastMutation: retryDeleteMutation,
+                        },
+                      })
+                      const j = await readApiResultOrThrow<RecordsResponse>(
+                        `/api/entities/records?entityId=${encodeURIComponent(entityId)}&page=${page}&pageSize=${pageSize}`,
+                        undefined,
+                        {
+                          errorMessage: 'Failed to reload records',
+                          fallback: { items: [], total: 0, page, pageSize, totalPages: 1 },
+                        },
+                      )
+                      setRawData(j.items || [])
+                      setTotal(j.total || 0)
+                      setTotalPages(j.totalPages || 1)
+                      flash('Record has been removed', 'success')
+                    } catch (error) {
+                      const message = error instanceof Error ? error.message : 'Failed to delete record'
+                      flash(message, 'error')
+                    }
+                  } },
+                ]}
+              />
+            )}
+            sortable
+            sorting={sorting}
+            onSortingChange={setSorting}
+            searchValue={search}
+            onSearchChange={(v) => { setSearch(v); setPage(1) }}
+            onFiltersApply={(vals) => { setFilterValues(vals); setPage(1) }}
+            onFiltersClear={() => { setFilterValues({}); setPage(1) }}
+            pagination={{ page, pageSize, total, totalPages, onPageChange: setPage }}
+            isLoading={loading}
+          />
+        </RelationDisplaysProvider>
       </PageBody>
       {ConfirmDialogElement}
     </Page>

package/src/modules/entities/components/RecordListRelationCell.tsx

@@ -0,0 +1,90 @@
+"use client"
+import * as React from 'react'
+import Link from 'next/link'
+import type { CustomFieldDefDto } from '@open-mercato/ui/backend/utils/customFieldDefs'
+import {
+  getRecordListRelationDisplays,
+  resolveRecordListRelationDisplays,
+  type RelationDisplaysByField,
+} from './recordListRelationDisplays'
+
+const RelationDisplaysContext = React.createContext<RelationDisplaysByField>({})
+
+export function RelationDisplaysProvider({
+  displaysByField,
+  children,
+}: {
+  displaysByField: RelationDisplaysByField
+  children: React.ReactNode
+}) {
+  return (
+    <RelationDisplaysContext.Provider value={displaysByField}>
+      {children}
+    </RelationDisplaysContext.Provider>
+  )
+}
+
+export function useRecordListRelationDisplays(
+  definitions: CustomFieldDefDto[],
+  records: Array<Record<string, unknown>>,
+): RelationDisplaysByField {
+  const [displaysByField, setDisplaysByField] = React.useState<RelationDisplaysByField>({})
+
+  React.useEffect(() => {
+    const abortController = new AbortController()
+    setDisplaysByField((current) => (Object.keys(current).length ? {} : current))
+    if (!definitions.length || !records.length) {
+      return () => abortController.abort()
+    }
+
+    void resolveRecordListRelationDisplays(definitions, records, abortController.signal)
+      .then((resolvedDisplays) => {
+        if (!abortController.signal.aborted) setDisplaysByField(resolvedDisplays)
+      })
+      .catch(() => {
+        if (!abortController.signal.aborted) setDisplaysByField({})
+      })
+
+    return () => abortController.abort()
+  }, [definitions, records])
+
+  return displaysByField
+}
+
+export function RelationCell({
+  fieldKey,
+  value,
+  fallbackText,
+}: {
+  fieldKey: string
+  value: unknown
+  fallbackText: string
+}) {
+  const displaysByField = React.useContext(RelationDisplaysContext)
+  const resolvedDisplays = getRecordListRelationDisplays(value, displaysByField[fieldKey])
+  const rawValue = resolvedDisplays.map((display) => display.id).join(', ') || fallbackText
+
+  if (!resolvedDisplays.length) {
+    return <span className="inline-block max-w-60 truncate align-top" title={rawValue}>{rawValue}</span>
+  }
+
+  return (
+    <span className="inline-block max-w-60 truncate align-top" title={rawValue}>
+      {resolvedDisplays.map((display, index) => (
+        <React.Fragment key={`${display.id}-${index}`}>
+          {index > 0 ? ', ' : null}
+          {display.href ? (
+            <Link
+              href={display.href}
+              className="font-medium text-primary underline-offset-2 hover:underline focus-visible:underline"
+              onClick={(event) => event.stopPropagation()}
+              onKeyDown={(event) => event.stopPropagation()}
+            >
+              {display.label}
+            </Link>
+          ) : display.label}
+        </React.Fragment>
+      ))}
+    </span>
+  )
+}

package/src/modules/entities/components/recordListRelationDisplays.ts

@@ -0,0 +1,109 @@
+import type { CustomFieldDefDto } from '@open-mercato/ui/backend/utils/customFieldDefs'
+import {
+  buildRelationHref,
+  collectRelationValueIds,
+  fetchRelationRecordDisplays,
+  parseRelationOptionsMetadata,
+  type RelationOptionsMetadata,
+  type ResolvedValueDisplay,
+} from '@open-mercato/ui/backend/utils/customFieldRelationDisplay'
+
+export type RelationDisplaysByField = Record<string, Record<string, ResolvedValueDisplay>>
+
+type RelationLookup = {
+  optionsUrl: string
+  relation: RelationOptionsMetadata
+  recordIds: Set<string>
+  recordIdsByField: Map<string, Set<string>>
+}
+
+export function resolveRelationOptionsUrl(definition: CustomFieldDefDto): string | null {
+  if (definition.kind !== 'relation') return null
+
+  const configuredUrl = definition.optionsUrl?.trim()
+  if (configuredUrl && parseRelationOptionsMetadata(configuredUrl)) return configuredUrl
+
+  const relatedEntityId = definition.relatedEntityId?.trim()
+  if (!relatedEntityId) return null
+  return `/api/entities/relations/options?entityId=${encodeURIComponent(relatedEntityId)}`
+}
+
+function collectRelationLookups(
+  definitions: CustomFieldDefDto[],
+  records: Array<Record<string, unknown>>,
+): RelationLookup[] {
+  const lookups = new Map<string, RelationLookup>()
+
+  definitions.forEach((definition) => {
+    const optionsUrl = resolveRelationOptionsUrl(definition)
+    if (!optionsUrl) return
+    const relation = parseRelationOptionsMetadata(optionsUrl)
+    if (!relation) return
+
+    const recordIds = new Set(
+      records.flatMap((record) => collectRelationValueIds(record[definition.key])),
+    )
+    if (!recordIds.size) return
+
+    const lookupKey = JSON.stringify([relation.entityId, optionsUrl])
+    const lookup = lookups.get(lookupKey) ?? {
+      optionsUrl,
+      relation,
+      recordIds: new Set<string>(),
+      recordIdsByField: new Map<string, Set<string>>(),
+    }
+    recordIds.forEach((recordId) => lookup.recordIds.add(recordId))
+    lookup.recordIdsByField.set(definition.key, recordIds)
+    lookups.set(lookupKey, lookup)
+  })
+
+  return Array.from(lookups.values())
+}
+
+export async function resolveRecordListRelationDisplays(
+  definitions: CustomFieldDefDto[],
+  records: Array<Record<string, unknown>>,
+  signal?: AbortSignal,
+): Promise<RelationDisplaysByField> {
+  const displaysByField: RelationDisplaysByField = {}
+  const lookups = collectRelationLookups(definitions, records)
+
+  await Promise.all(lookups.map(async (lookup) => {
+    let fetchedDisplays: Record<string, ResolvedValueDisplay> = {}
+    try {
+      fetchedDisplays = await fetchRelationRecordDisplays(
+        lookup.optionsUrl,
+        lookup.relation,
+        Array.from(lookup.recordIds),
+        signal,
+      )
+    } catch {
+      fetchedDisplays = {}
+    }
+
+    if (signal?.aborted) return
+    lookup.recordIdsByField.forEach((recordIds, fieldKey) => {
+      const fieldDisplays: Record<string, ResolvedValueDisplay> = {}
+      recordIds.forEach((recordId) => {
+        fieldDisplays[recordId] = fetchedDisplays[recordId] ?? {
+          label: recordId,
+          href: buildRelationHref(lookup.relation.entityId, recordId),
+        }
+      })
+      displaysByField[fieldKey] = fieldDisplays
+    })
+  }))
+
+  return displaysByField
+}
+
+export function getRecordListRelationDisplays(
+  value: unknown,
+  displays: Record<string, ResolvedValueDisplay> | undefined,
+): Array<{ id: string; label: string; href?: string }> {
+  return collectRelationValueIds(value).map((recordId) => ({
+    id: recordId,
+    label: displays?.[recordId]?.label ?? recordId,
+    href: displays?.[recordId]?.href,
+  }))
+}