@open-mercato/core 0.6.7 → 0.6.8-develop.6874.1.982d6097d8

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,
+  }))
+}

package/src/modules/entities/extension-points.ts

@@ -0,0 +1,18 @@
+import { dataTableExtensionHost, defineModuleExtensionPoints, injectionExtensionHost } from '@open-mercato/shared/modules/widgets/extension-points'
+
+export const extensionPoints = defineModuleExtensionPoints({
+  moduleId: 'entities',
+  hosts: {
+    systemEntitiesTable: dataTableExtensionHost({ tableId: 'entities.system.list', source: 'components/SystemEntitiesTable.tsx' }),
+    userEntitiesTable: dataTableExtensionHost({ tableId: 'entities.user.list', source: 'components/UserEntitiesTable.tsx' }),
+    userRecordsTable: injectionExtensionHost({
+      family: 'entity',
+      pattern: 'data-table:entities.user.records.{entityId}',
+      parameters: { entityId: { source: 'route.params.entityId' } },
+      supported: ['render-widget', 'headless-widget', 'column-widget', 'row-action', 'bulk-action', 'filter-widget'],
+      source: 'backend/entities/user/[entityId]/records/page.tsx',
+    }),
+  },
+})
+
+export default extensionPoints

package/src/modules/entities/i18n/de.json

@@ -196,6 +196,14 @@
   "entities.nav.systemEntities": "Systementitäten",
   "entities.nav.userEntities": "Benutzerentitäten",
   "entities.nav.userEntities.create": "Entität erstellen",
+  "entities.settings.description": "Globale Konfigurationen für benutzerdefinierte Entitäten verwalten.",
+  "entities.settings.errors.conflict": "Die Einstellungen wurden von einem anderen Benutzer geändert. Bitte neu laden.",
+  "entities.settings.errors.loadFailed": "Laden der Einstellungen fehlgeschlagen",
+  "entities.settings.errors.saveFailed": "Speichern der Einstellungen fehlgeschlagen",
+  "entities.settings.flash.saved": "Einstellungen gespeichert",
+  "entities.settings.newEntitiesRestrictedByDefault.description": "Für Datensätze neu erstellter benutzerdefinierter Entitäten standardmäßig explizite Berechtigungen pro Entität erfordern.",
+  "entities.settings.newEntitiesRestrictedByDefault.label": "Datensatzzugriff standardmäßig einschränken",
+  "entities.settings.title": "Benutzerdefinierte Entitäten",
   "entities.userEntities.edit.errors.deleteEntityFailed": "Entität konnte nicht gelöscht werden",
   "entities.userEntities.edit.errors.invalidEntityDescription": "Die angeforderte Entitäts-ID fehlt oder ist ungültig.",
   "entities.userEntities.edit.errors.invalidEntityId": "Ungültige Entitäts-ID",
@@ -221,6 +229,7 @@
   "entities.userEntities.errors.entityIdExists": "Entitäts-ID ist bereits vorhanden",
   "entities.userEntities.errors.entityIdRequired": "Entitäts-ID ist erforderlich",
   "entities.userEntities.errors.loadFailed": "Entitäten konnten nicht geladen werden",
+  "entities.userEntities.errors.settingsLoadFailed": "Standardeinschränkungsrichtlinie konnte nicht geladen werden; Standardwert wird verwendet",
   "entities.userEntities.flash.created": "Entität erstellt",
   "entities.userEntities.form.accessRestricted.help": "Erfordert eine explizite entitätsspezifische Berechtigung zum Anzeigen oder Verwalten der Datensätze dieser Entität. Deaktiviert lassen, um allen Benutzern mit der allgemeinen Datensatzberechtigung Zugriff zu gewähren.",
   "entities.userEntities.form.accessRestricted.label": "Datensatzzugriff einschränken",

package/src/modules/entities/i18n/en.json

@@ -196,6 +196,14 @@
   "entities.nav.systemEntities": "System Entities",
   "entities.nav.userEntities": "User Entities",
   "entities.nav.userEntities.create": "Create Entity",
+  "entities.settings.description": "Manage global custom entity configurations.",
+  "entities.settings.errors.conflict": "Settings were modified by another user. Please reload.",
+  "entities.settings.errors.loadFailed": "Failed to load settings",
+  "entities.settings.errors.saveFailed": "Failed to save settings",
+  "entities.settings.flash.saved": "Settings saved",
+  "entities.settings.newEntitiesRestrictedByDefault.description": "Require explicit per-entity permissions for records of newly created custom entities by default.",
+  "entities.settings.newEntitiesRestrictedByDefault.label": "Restrict record access by default",
+  "entities.settings.title": "Custom Entities",
   "entities.userEntities.edit.errors.deleteEntityFailed": "Failed to delete entity",
   "entities.userEntities.edit.errors.invalidEntityDescription": "The requested entity ID is missing or invalid.",
   "entities.userEntities.edit.errors.invalidEntityId": "Invalid entity ID",
@@ -221,6 +229,7 @@
   "entities.userEntities.errors.entityIdExists": "Entity ID already exists",
   "entities.userEntities.errors.entityIdRequired": "Entity ID is required",
   "entities.userEntities.errors.loadFailed": "Failed to load entities",
+  "entities.userEntities.errors.settingsLoadFailed": "Could not load default restriction policy; using default",
   "entities.userEntities.flash.created": "Entity created",
   "entities.userEntities.form.accessRestricted.help": "Require an explicit per-entity permission to view or manage this entity’s records. Leave off to allow anyone with the general records permission.",
   "entities.userEntities.form.accessRestricted.label": "Restrict record access",

package/src/modules/entities/i18n/es.json

@@ -196,6 +196,14 @@
   "entities.nav.systemEntities": "Entidades del sistema",
   "entities.nav.userEntities": "Entidades de usuario",
   "entities.nav.userEntities.create": "Crear entidad",
+  "entities.settings.description": "Administrar configuraciones globales de entidades personalizadas.",
+  "entities.settings.errors.conflict": "La configuración fue modificada por otro usuario. Por favor recarga.",
+  "entities.settings.errors.loadFailed": "Error al cargar la configuración",
+  "entities.settings.errors.saveFailed": "Error al guardar la configuración",
+  "entities.settings.flash.saved": "Configuración guardada",
+  "entities.settings.newEntitiesRestrictedByDefault.description": "Requerir permisos explícitos por entidad para registros de nuevas entidades creadas por defecto.",
+  "entities.settings.newEntitiesRestrictedByDefault.label": "Restringir acceso a registros por defecto",
+  "entities.settings.title": "Entidades personalizadas",
   "entities.userEntities.edit.errors.deleteEntityFailed": "No se pudo eliminar la entidad",
   "entities.userEntities.edit.errors.invalidEntityDescription": "Falta el ID de la entidad solicitada o no es válido.",
   "entities.userEntities.edit.errors.invalidEntityId": "ID de entidad no válido",
@@ -221,6 +229,7 @@
   "entities.userEntities.errors.entityIdExists": "El ID de la entidad ya existe",
   "entities.userEntities.errors.entityIdRequired": "El ID de la entidad es obligatorio",
   "entities.userEntities.errors.loadFailed": "No se pudieron cargar las entidades",
+  "entities.userEntities.errors.settingsLoadFailed": "No se pudo cargar la política de restricción por defecto; usando valor predeterminado",
   "entities.userEntities.flash.created": "Entidad creada",
   "entities.userEntities.form.accessRestricted.help": "Requiere un permiso explícito por entidad para ver o gestionar los registros de esta entidad. Déjalo desactivado para permitir el acceso a cualquiera con el permiso general de registros.",
   "entities.userEntities.form.accessRestricted.label": "Restringir acceso a registros",

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

@@ -0,0 +1,260 @@
+{
+  "entities.customFields.addFirst": "첫 항목 추가",
+  "entities.customFields.defaultFieldset": "기본값",
+  "entities.customFields.editor.active": "활동적인",
+  "entities.customFields.editor.add": "추가하다",
+  "entities.customFields.editor.addField": "필드 추가",
+  "entities.customFields.editor.addFirstFieldset": "첫 번째 필드세트 추가",
+  "entities.customFields.editor.addOption": "옵션 추가",
+  "entities.customFields.editor.addOptionDescription": "사용자에게 표시되는 저장된 값과 선택적 라벨을 제공합니다.",
+  "entities.customFields.editor.addRule": "규칙 추가",
+  "entities.customFields.editor.assignToFieldset": "필드세트에 할당",
+  "entities.customFields.editor.cancel": "취소",
+  "entities.customFields.editor.code": "암호",
+  "entities.customFields.editor.createGroup": "그룹 만들기",
+  "entities.customFields.editor.defaultOption": "기본",
+  "entities.customFields.editor.delete": "삭제",
+  "entities.customFields.editor.deleteFieldsetText": "그러면 해당 필드가 할당되지 않음으로 이동됩니다.",
+  "entities.customFields.editor.deleteFieldsetTitle": "필드 세트 \"{code}\"를 삭제하시겠습니까?",
+  "entities.customFields.editor.deleteGroupAria": "{code} 삭제",
+  "entities.customFields.editor.description": "설명",
+  "entities.customFields.editor.dragToReorder": "드래그하여 재정렬하세요.",
+  "entities.customFields.editor.editGroup": "그룹 수정",
+  "entities.customFields.editor.editGroupAria": "{code} 편집",
+  "entities.customFields.editor.editGroupDescription": "이 필드 세트에 대해 선택한 그룹을 업데이트합니다.",
+  "entities.customFields.editor.editGroups": "그룹 수정",
+  "entities.customFields.editor.editor": "편집자",
+  "entities.customFields.editor.editorHtmlRichText": "HTML 리치 텍스트",
+  "entities.customFields.editor.editorMarkdown": "마크다운(UIW)",
+  "entities.customFields.editor.editorPlain": "일반 텍스트 영역",
+  "entities.customFields.editor.editorSimpleMarkdown": "간단한 마크다운",
+  "entities.customFields.editor.existingGroups": "기존 그룹",
+  "entities.customFields.editor.group": "그룹",
+  "entities.customFields.editor.groupCode": "그룹 코드",
+  "entities.customFields.editor.groupCodePlaceholder": "예를 들어 구매위원회",
+  "entities.customFields.editor.groupCodeRequired": "그룹 코드가 필요합니다.",
+  "entities.customFields.editor.groupHintPlaceholder": "판매자에게 표시",
+  "entities.customFields.editor.groupLabelPlaceholder": "구매위원회",
+  "entities.customFields.editor.hint": "힌트",
+  "entities.customFields.editor.icon": "상",
+  "entities.customFields.editor.iconOption.bookOpen": "도서 오픈",
+  "entities.customFields.editor.iconOption.bookmark": "서표",
+  "entities.customFields.editor.iconOption.briefcase": "서류가방",
+  "entities.customFields.editor.iconOption.building": "건물",
+  "entities.customFields.editor.iconOption.camera": "카메라",
+  "entities.customFields.editor.iconOption.car": "자동차",
+  "entities.customFields.editor.iconOption.clock": "시계",
+  "entities.customFields.editor.iconOption.cloud": "구름",
+  "entities.customFields.editor.iconOption.coins": "동전",
+  "entities.customFields.editor.iconOption.compass": "나침반",
+  "entities.customFields.editor.iconOption.creditCard": "신용카드",
+  "entities.customFields.editor.iconOption.database": "데이터 베이스",
+  "entities.customFields.editor.iconOption.flame": "불꽃",
+  "entities.customFields.editor.iconOption.gift": "선물",
+  "entities.customFields.editor.iconOption.globe": "지구",
+  "entities.customFields.editor.iconOption.grid": "그리드",
+  "entities.customFields.editor.iconOption.heart": "마음",
+  "entities.customFields.editor.iconOption.key": "열쇠",
+  "entities.customFields.editor.iconOption.layers": "레이어",
+  "entities.customFields.editor.iconOption.map": "지도",
+  "entities.customFields.editor.iconOption.package": "패키지",
+  "entities.customFields.editor.iconOption.palette": "팔레트",
+  "entities.customFields.editor.iconOption.shield": "방패",
+  "entities.customFields.editor.iconOption.shirt": "셔츠",
+  "entities.customFields.editor.iconOption.shoppingBag": "쇼핑백",
+  "entities.customFields.editor.iconOption.shoppingCart": "장바구니",
+  "entities.customFields.editor.iconOption.sparkles": "반짝임",
+  "entities.customFields.editor.iconOption.star": "별",
+  "entities.customFields.editor.iconOption.store": "가게",
+  "entities.customFields.editor.iconOption.tag": "꼬리표",
+  "entities.customFields.editor.iconOption.truck": "트럭",
+  "entities.customFields.editor.iconOption.users": "사용자",
+  "entities.customFields.editor.iconOption.zap": "기력",
+  "entities.customFields.editor.key": "열쇠",
+  "entities.customFields.editor.kind": "친절한",
+  "entities.customFields.editor.kindOption.attachment": "부착",
+  "entities.customFields.editor.kindOption.boolean": "부울",
+  "entities.customFields.editor.kindOption.currency": "통화",
+  "entities.customFields.editor.kindOption.date": "날짜",
+  "entities.customFields.editor.kindOption.datetime": "날짜/시간",
+  "entities.customFields.editor.kindOption.dictionary": "사전",
+  "entities.customFields.editor.kindOption.float": "뜨다",
+  "entities.customFields.editor.kindOption.integer": "정수",
+  "entities.customFields.editor.kindOption.multiline": "여러 줄",
+  "entities.customFields.editor.kindOption.relation": "관계",
+  "entities.customFields.editor.kindOption.select": "선택하다",
+  "entities.customFields.editor.kindOption.text": "텍스트",
+  "entities.customFields.editor.label": "상표",
+  "entities.customFields.editor.listboxSearchable": "목록 상자(검색 가능)",
+  "entities.customFields.editor.multiSelectInputStyle": "다중 선택 입력 스타일",
+  "entities.customFields.editor.multiple": "다수의",
+  "entities.customFields.editor.newFieldsetLabel": "새로운 필드셋",
+  "entities.customFields.editor.newGroup": "새 그룹",
+  "entities.customFields.editor.newGroupDescription": "이 필드 세트에 대해 재사용 가능한 그룹을 추가하십시오.",
+  "entities.customFields.editor.noFieldsets": "아직 정의된 필드 세트가 없습니다. 필드 세트를 사용하면 동일한 엔터티의 다양한 변형(예: 패션 제품과 스포츠 제품)에 대한 사용자 정의 필드를 그룹화할 수 있습니다.",
+  "entities.customFields.editor.noGroup": "그룹 없음",
+  "entities.customFields.editor.noOptionsDefined": "정의된 옵션이 없습니다.",
+  "entities.customFields.editor.noParameterPlaceholder": "-",
+  "entities.customFields.editor.noValidationRules": "정의된 유효성 검사 규칙이 없습니다.",
+  "entities.customFields.editor.optionLabelPlaceholder": "사용자에게 표시되는 라벨(선택사항)",
+  "entities.customFields.editor.options": "옵션",
+  "entities.customFields.editor.optionsSource": "옵션 소스",
+  "entities.customFields.editor.optionsUrl": "옵션 URL",
+  "entities.customFields.editor.relatedEntityId": "관련 엔터티 ID",
+  "entities.customFields.editor.removeField": "필드 삭제",
+  "entities.customFields.editor.removeOption": "옵션 제거",
+  "entities.customFields.editor.removeRule": "규칙 삭제",
+  "entities.customFields.editor.reorderedSavingSoon": "재정렬됨 - 곧 저장됨",
+  "entities.customFields.editor.restoreDeletedFields": "삭제된 필드 복원:",
+  "entities.customFields.editor.ruleErrorMessagePlaceholder": "오류 메시지",
+  "entities.customFields.editor.ruleNumberPlaceholder": "숫자",
+  "entities.customFields.editor.rulePatternPlaceholder": "패턴(예: ^[a-z]+$)",
+  "entities.customFields.editor.ruleRequiredMessage": "이 필드는 필수입니다",
+  "entities.customFields.editor.saveGroup": "그룹 저장",
+  "entities.customFields.editor.savingOrder": "주문 저장 중…",
+  "entities.customFields.editor.singleFieldsetPerEntity": "엔터티당 단일 필드 세트",
+  "entities.customFields.editor.singleFieldsetToggleHint": "(토글하려면 최소 두 개의 필드 세트를 추가하세요)",
+  "entities.customFields.editor.supportedKindsNote": "지원되는 종류: 텍스트, 여러 줄, 정수, 부동 소수점, 부울, 선택(옵션/옵션 URL 포함), 통화(고정 통화 목록), 관계(관련 엔터티 및 옵션 URL 포함).",
+  "entities.customFields.editor.translateField": "필드 번역",
+  "entities.customFields.editor.unassigned": "할당되지 않음",
+  "entities.customFields.editor.unassignedFields": "할당되지 않은 필드",
+  "entities.customFields.editor.unitsOptional": "단위(선택사항)",
+  "entities.customFields.editor.unitsPlaceholder": "kg, cm 등",
+  "entities.customFields.editor.validation.date": "날짜",
+  "entities.customFields.editor.validation.eq": "eq",
+  "entities.customFields.editor.validation.float": "뜨다",
+  "entities.customFields.editor.validation.gt": "gt",
+  "entities.customFields.editor.validation.gte": "gte",
+  "entities.customFields.editor.validation.integer": "정수",
+  "entities.customFields.editor.validation.lt": "lt",
+  "entities.customFields.editor.validation.lte": "LTE",
+  "entities.customFields.editor.validation.ne": "네",
+  "entities.customFields.editor.validation.regex": "정규식",
+  "entities.customFields.editor.validation.required": "필수의",
+  "entities.customFields.editor.validationRules": "검증 규칙",
+  "entities.customFields.editor.value": "값",
+  "entities.customFields.editor.valueRequired": "값은 필수 항목입니다.",
+  "entities.customFields.empty": "아직 지정된 커스텀 속성이 없습니다.",
+  "entities.customFields.emptyFieldset": "이 필드셋에 정의된 필드가 없습니다.",
+  "entities.customFields.errors.deleteFailed": "필드 삭제에 실패했습니다.",
+  "entities.customFields.errors.loadFailed": "필드 정의를 불러오지 못했습니다.",
+  "entities.customFields.errors.restoreFailed": "필드 복원에 실패했습니다.",
+  "entities.customFields.errors.saveFailed": "필드 정의 저장에 실패했습니다.",
+  "entities.customFields.errors.title": "문제가 발생했습니다",
+  "entities.customFields.errors.validation": "필드 정의의 유효성 검사 오류를 수정하세요.",
+  "entities.customFields.fields.defaultValue": "기본값",
+  "entities.customFields.fields.defaultValueFalse": "선택 안 됨 (false)",
+  "entities.customFields.fields.defaultValueNone": "기본값 없음",
+  "entities.customFields.fields.defaultValuePlaceholder": "기본값 없음",
+  "entities.customFields.fields.defaultValueTrue": "선택됨 (true)",
+  "entities.customFields.fields.encrypted": "암호화됨",
+  "entities.customFields.fields.filterable": "필터",
+  "entities.customFields.fields.formEditable": "양식",
+  "entities.customFields.fields.listVisible": "목록",
+  "entities.customFields.fields.visibility": "표시 여부:",
+  "entities.customFields.fieldsetSelectorLabel": "필드셋",
+  "entities.customFields.flash.restored": "필드가 복원되었습니다",
+  "entities.customFields.flash.saved": "정의가 저장되었습니다",
+  "entities.customFields.manageDialogTitle": "커스텀 필드 편집",
+  "entities.customFields.manageDialogUnavailable": "필드 정의 페이지를 사용할 수 없습니다.",
+  "entities.customFields.manageFieldset": "필드 관리",
+  "entities.customFields.openInNewTab": "전체 편집기 열기",
+  "entities.customFields.orderNotice": "순서가 변경되었습니다 — 저장하는 것을 잊지 마세요",
+  "entities.customFields.title": "커스텀 속성",
+  "entities.encryption.actions.add": "필드 추가",
+  "entities.encryption.actions.refresh": "새로고침",
+  "entities.encryption.actions.remove": "제거",
+  "entities.encryption.actions.retry": "재시도",
+  "entities.encryption.actions.save": "암호화 맵 저장",
+  "entities.encryption.actions.saving": "저장 중…",
+  "entities.encryption.active": "이 엔터티에 암호화가 활성화되어 있습니다",
+  "entities.encryption.description": "테넌트 키와 선택적 해시 열로 암호화되는 엔터티 필드를 관리합니다.",
+  "entities.encryption.empty": "아직 암호화된 필드가 없습니다. 아래에서 첫 필드를 추가하세요.",
+  "entities.encryption.entityHint": "맵은 테넌트/조직별로 적용됩니다. 엔터티의 필드 이름을 사용하세요.",
+  "entities.encryption.errors.loadEntities": "엔터티를 불러오지 못했습니다",
+  "entities.encryption.errors.loadMap": "암호화 맵을 불러오지 못했습니다",
+  "entities.encryption.errors.noFields": "암호화할 필드를 하나 이상 추가하세요",
+  "entities.encryption.errors.save": "암호화 맵 저장에 실패했습니다",
+  "entities.encryption.errors.selectEntity": "저장하기 전에 엔터티를 선택하세요",
+  "entities.encryption.fields.actions": "작업",
+  "entities.encryption.fields.field": "필드 이름",
+  "entities.encryption.fields.hash": "해시 필드 (선택 사항)",
+  "entities.encryption.fields.hashHint": "조회가 결정적이어야 할 때 사용합니다 (예: 이메일로 로그인).",
+  "entities.encryption.fields.row": "필드 {{index}}",
+  "entities.encryption.fields.selectField": "필드 선택",
+  "entities.encryption.fields.selectHash": "해시 필드 선택 (선택 사항)",
+  "entities.encryption.fields.subtitle": "테넌트 키로 암호화해야 하는 속성을 나열하세요.",
+  "entities.encryption.fields.title": "암호화된 필드",
+  "entities.encryption.flash.saved": "암호화 맵이 저장되었습니다",
+  "entities.encryption.loading": "암호화 맵을 불러오는 중…",
+  "entities.encryption.placeholder": "엔터티 선택",
+  "entities.encryption.selectEntity": "엔터티 선택",
+  "entities.encryption.source.custom": "커스텀",
+  "entities.encryption.title": "암호화",
+  "entities.nav.entityRecords": "엔터티 레코드",
+  "entities.nav.group": "데이터 디자이너",
+  "entities.nav.systemEntities": "시스템 엔터티",
+  "entities.nav.userEntities": "사용자 엔터티",
+  "entities.nav.userEntities.create": "엔터티 생성",
+  "entities.settings.description": "전역 사용자 지정 엔터티 구성을 관리합니다.",
+  "entities.settings.errors.conflict": "다른 사용자가 설정을 수정했습니다. 새로고침하세요.",
+  "entities.settings.errors.loadFailed": "설정을 로드하지 못했습니다.",
+  "entities.settings.errors.saveFailed": "설정을 저장하지 못했습니다.",
+  "entities.settings.flash.saved": "설정이 저장되었습니다.",
+  "entities.settings.newEntitiesRestrictedByDefault.description": "기본적으로 새로 생성된 사용자 지정 엔터티의 레코드에 대해 명시적인 엔터티별 권한이 필요합니다.",
+  "entities.settings.newEntitiesRestrictedByDefault.label": "기본적으로 레코드 액세스 제한",
+  "entities.settings.title": "사용자 정의 엔터티",
+  "entities.userEntities.edit.errors.deleteEntityFailed": "항목을 삭제하지 못했습니다.",
+  "entities.userEntities.edit.errors.invalidEntityDescription": "요청한 엔터티 ID가 누락되었거나 잘못되었습니다.",
+  "entities.userEntities.edit.errors.invalidEntityId": "잘못된 엔터티 ID",
+  "entities.userEntities.edit.errors.invalidEntityTitle": "잘못된 엔터티",
+  "entities.userEntities.edit.errors.loadDefinitionsFailed": "엔터티 정의를 로드하지 못했습니다.",
+  "entities.userEntities.edit.errors.loadFailed": "로드하지 못했습니다.",
+  "entities.userEntities.edit.errors.loadMetadataFailed": "항목 메타데이터를 로드하지 못했습니다.",
+  "entities.userEntities.edit.errors.reloadDefinitionsFailed": "필드 정의를 다시 로드하지 못했습니다.",
+  "entities.userEntities.edit.errors.restoreFieldFailed": "필드를 복원하지 못했습니다.",
+  "entities.userEntities.edit.errors.saveEntityFailed": "항목을 저장하지 못했습니다.",
+  "entities.userEntities.edit.errors.saveOrderFailed": "주문을 저장하지 못했습니다.",
+  "entities.userEntities.edit.errors.validationFailed": "검증 실패",
+  "entities.userEntities.edit.fieldsetTitle": "필드셋 편집: {{name}}",
+  "entities.userEntities.edit.flash.entityDeleted": "항목이 삭제되었습니다.",
+  "entities.userEntities.edit.flash.orderSaved": "주문이 저장되었습니다.",
+  "entities.userEntities.edit.flash.restoredField": "복원된 {{key}}",
+  "entities.userEntities.edit.groups.definitions": "필드 정의",
+  "entities.userEntities.edit.groups.settings": "엔터티 설정",
+  "entities.userEntities.edit.orderNotice": "재정렬됨 - 흐림 시 자동 저장됩니다.",
+  "entities.userEntities.edit.pageTitle": "정의 편집",
+  "entities.userEntities.edit.showRecords": "기록 표시",
+  "entities.userEntities.edit.title": "엔터티 편집: {{entityId}}",
+  "entities.userEntities.errors.entityIdExists": "이미 존재하는 엔터티 ID입니다",
+  "entities.userEntities.errors.entityIdRequired": "엔터티 ID는 필수입니다",
+  "entities.userEntities.errors.loadFailed": "엔터티를 불러오지 못했습니다",
+  "entities.userEntities.errors.settingsLoadFailed": "기본 제한 정책을 로드할 수 없습니다. 기본값 사용",
+  "entities.userEntities.flash.created": "엔터티가 생성되었습니다",
+  "entities.userEntities.form.accessRestricted.help": "이 엔터티의 레코드를 보거나 관리하려면 명시적인 엔터티별 권한이 필요합니다. 일반 기록 권한이 있는 사람은 누구나 허용하도록 설정하세요.",
+  "entities.userEntities.form.accessRestricted.label": "기록 접근 제한",
+  "entities.userEntities.form.defaultEditor.label": "기본 편집기 (여러 줄)",
+  "entities.userEntities.form.defaultEditor.options.default": "기본값 (Markdown)",
+  "entities.userEntities.form.defaultEditor.options.htmlRichText": "HTML 서식 있는 텍스트",
+  "entities.userEntities.form.defaultEditor.options.markdown": "Markdown (UIW)",
+  "entities.userEntities.form.defaultEditor.options.plain": "일반 텍스트 영역",
+  "entities.userEntities.form.defaultEditor.options.simpleMarkdown": "간단한 Markdown",
+  "entities.userEntities.form.description.label": "설명",
+  "entities.userEntities.form.entityId.label": "엔터티 ID",
+  "entities.userEntities.form.entityId.placeholder": "module_name:entity_id",
+  "entities.userEntities.form.label.label": "라벨",
+  "entities.userEntities.form.loading": "로드 중…",
+  "entities.userEntities.form.showInSidebar.label": "사이드바에 표시",
+  "entities.userEntities.form.submit": "생성",
+  "entities.userEntities.form.systemEntityNotice": "이는 코드에 정의된 시스템 엔터티입니다. 해당 레이블과 설명은 코드로 관리되며 여기서 편집할 수 없습니다. 아래 필드 정의만 편집 가능합니다.",
+  "entities.userEntities.form.title": "엔터티 생성",
+  "entities.userEntities.records.errors.deleteFailed": "레코드 삭제에 실패했습니다",
+  "entities.userEntities.records.errors.entityIdRequired": "엔터티 식별자는 필수입니다",
+  "entities.userEntities.records.errors.recordIdRequired": "레코드 식별자는 필수입니다",
+  "entities.userEntities.records.errors.systemEntity": "이 엔터티는 시스템에서 관리합니다. 레코드는 커스텀 엔터티에서만 사용할 수 있습니다.",
+  "entities.userEntities.records.form.createTitle": "레코드 생성",
+  "entities.userEntities.records.form.editTitle": "레코드 편집",
+  "entities.userEntities.records.form.submitCreate": "생성",
+  "entities.userEntities.records.form.submitSave": "저장",
+  "entities.userEntities.records.loading": "레코드를 불러오는 중..."
+}

package/src/modules/entities/i18n/pl.json

@@ -196,6 +196,14 @@
   "entities.nav.systemEntities": "Encje systemowe",
   "entities.nav.userEntities": "Encje użytkownika",
   "entities.nav.userEntities.create": "Utwórz encję",
+  "entities.settings.description": "Zarządzaj globalnymi ustawieniami niestandardowych encji.",
+  "entities.settings.errors.conflict": "Ustawienia zostały zmodyfikowane przez innego użytkownika. Proszę przeładować.",
+  "entities.settings.errors.loadFailed": "Nie udało się załadować ustawień",
+  "entities.settings.errors.saveFailed": "Nie udało się zapisać ustawień",
+  "entities.settings.flash.saved": "Ustawienia zostały zapisane",
+  "entities.settings.newEntitiesRestrictedByDefault.description": "Domyślnie wymagaj jawnych uprawnień dla poszczególnych encji do rekordów nowo tworzonych niestandardowych encji.",
+  "entities.settings.newEntitiesRestrictedByDefault.label": "Domyślnie ograniczaj dostęp do rekordów",
+  "entities.settings.title": "Niestandardowe encje",
   "entities.userEntities.edit.errors.deleteEntityFailed": "Nie udało się usunąć encji",
   "entities.userEntities.edit.errors.invalidEntityDescription": "Brakuje identyfikatora encji albo jest on nieprawidłowy.",
   "entities.userEntities.edit.errors.invalidEntityId": "Nieprawidłowy identyfikator encji",
@@ -221,6 +229,7 @@
   "entities.userEntities.errors.entityIdExists": "Identyfikator encji już istnieje",
   "entities.userEntities.errors.entityIdRequired": "Identyfikator encji jest wymagany",
   "entities.userEntities.errors.loadFailed": "Nie udało się wczytać encji",
+  "entities.userEntities.errors.settingsLoadFailed": "Nie udało się załadować domyślnej polityki ograniczeń; używanie wartości domyślnej",
   "entities.userEntities.flash.created": "Encja została utworzona",
   "entities.userEntities.form.accessRestricted.help": "Wymaga jawnego uprawnienia dla tej encji, aby przeglądać lub zarządzać jej rekordami. Pozostaw wyłączone, aby zezwolić na dostęp każdemu z ogólnym uprawnieniem do rekordów.",
   "entities.userEntities.form.accessRestricted.label": "Ogranicz dostęp do rekordów",

package/src/modules/entities/lib/entityAcl.ts

@@ -1,6 +1,7 @@
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
-import { hasAllFeatures } from '@open-mercato/shared/security/features'
 import type { RbacService } from '@open-mercato/core/modules/auth/services/rbacService'
+import { getModules } from '@open-mercato/shared/lib/i18n/server'
+import { authorizeFeatures } from '@open-mercato/shared/security/featurePolicy'
 import { deriveCustomEntityRecordFeature } from './recordFeatures'
 
 export type EntityAclRequirement = {
@@ -65,10 +66,79 @@ const ENTITY_ACL_REQUIREMENTS: Record<string, EntityAclRequirement> = {
   },
 }
 
+let declaredCustomEntityRestrictions: Map<string, boolean> | null = null
+
+function loadDeclaredCustomEntityRestrictions(): Map<string, boolean> {
+  if (declaredCustomEntityRestrictions === null) {
+    try {
+      const modules = getModules() as Array<{
+        customEntities?: Array<{ id?: string; accessRestricted?: boolean }>
+      }>
+      const restrictions = new Map<string, boolean>()
+      for (const moduleEntry of modules ?? []) {
+        for (const spec of moduleEntry.customEntities ?? []) {
+          if (spec.id) restrictions.set(spec.id, spec.accessRestricted === true)
+        }
+      }
+      declaredCustomEntityRestrictions = restrictions
+    } catch {}
+  }
+  return declaredCustomEntityRestrictions ?? new Map<string, boolean>()
+}
+
+export function getDeclaredCustomEntityRestriction(entityId: string): boolean | undefined {
+  return loadDeclaredCustomEntityRestrictions().get(entityId)
+}
+
+export function isDeclaredCustomEntity(entityId: string): boolean {
+  return loadDeclaredCustomEntityRestrictions().has(entityId)
+}
+
 export function resolveEntityAclRequirement(entityId: string): EntityAclRequirement | null {
   return ENTITY_ACL_REQUIREMENTS[entityId] ?? null
 }
 
+export function canReadAllEntityMetadata(acl: {
+  isSuperAdmin?: boolean
+  features?: readonly string[]
+}): boolean {
+  return authorizeFeatures(['entities.definitions.view'], {
+    grantedFeatures: acl.features ?? [],
+    unrestricted: Boolean(acl.isSuperAdmin),
+  })
+}
+
+export function canReadEntityMetadata(args: {
+  entityId: string
+  isCustomEntity: boolean
+  isRestricted?: boolean
+  acl: { isSuperAdmin?: boolean; features?: readonly string[] }
+}): boolean {
+  const requirement = resolveEntityAclRequirement(args.entityId)
+  if (requirement?.platformOnly) {
+    return Boolean(args.acl.isSuperAdmin) && authorizeFeatures(requirement.view, {
+      grantedFeatures: args.acl.features ?? [],
+      unrestricted: true,
+    })
+  }
+  if (canReadAllEntityMetadata(args.acl)) return true
+  if (args.isCustomEntity) {
+    const requiredFeatures = ['entities.records.view']
+    if (args.isRestricted) {
+      requiredFeatures.push(deriveCustomEntityRecordFeature(args.entityId, 'view'))
+    }
+    return authorizeFeatures(requiredFeatures, {
+      grantedFeatures: args.acl.features ?? [],
+      unrestricted: Boolean(args.acl.isSuperAdmin),
+    })
+  }
+  if (!requirement) return Boolean(args.acl.isSuperAdmin)
+  return authorizeFeatures(requirement.view, {
+    grantedFeatures: args.acl.features ?? [],
+    unrestricted: Boolean(args.acl.isSuperAdmin),
+  })
+}
+
 type EntityAclActor = {
   sub?: string | null
   tenantId?: string | null
@@ -105,11 +175,16 @@ export async function assertEntityAclForRequest(args: AssertEntityAclArgs): Prom
     // entities.records.view/.manage route guard is the whole authorization.
     if (!args.isRestricted) return
 
-    const acl = await loadActorAcl(args)
-    if (acl?.isSuperAdmin) return
-
     const required = deriveCustomEntityRecordFeature(args.entityId, args.action)
-    if (!hasAllFeatures(acl?.features, [required])) {
+    const allowed = await args.rbac.userHasAllFeatures(
+      args.auth.sub ?? '',
+      [required],
+      {
+        tenantId: args.auth.tenantId ?? null,
+        organizationId: args.auth.orgId ?? null,
+      },
+    )
+    if (!allowed) {
       throw forbiddenEntityAccess()
     }
     return
@@ -117,14 +192,26 @@ export async function assertEntityAclForRequest(args: AssertEntityAclArgs): Prom
 
   const requirement = resolveEntityAclRequirement(args.entityId)
 
-  const acl = await loadActorAcl(args)
-
-  if (acl?.isSuperAdmin) return
+  if (!requirement) {
+    const acl = await loadActorAcl(args)
+    if (!acl.isSuperAdmin) throw forbiddenEntityAccess()
+    return
+  }
 
-  if (!requirement) throw forbiddenEntityAccess()
-  if (requirement.platformOnly) throw forbiddenEntityAccess()
+  if (requirement.platformOnly) {
+    const acl = await loadActorAcl(args)
+    if (!acl.isSuperAdmin) throw forbiddenEntityAccess()
+  }
 
-  if (!hasAllFeatures(acl?.features, requirement[args.action])) {
+  const allowed = await args.rbac.userHasAllFeatures(
+    args.auth.sub ?? '',
+    requirement[args.action],
+    {
+      tenantId: args.auth.tenantId ?? null,
+      organizationId: args.auth.orgId ?? null,
+    },
+  )
+  if (!allowed) {
     throw forbiddenEntityAccess()
   }
 }