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

package/src/modules/entities/cli.ts

@@ -23,6 +23,7 @@ import {
   parseDecryptedFieldValue,
 } from '@open-mercato/shared/lib/encryption/tenantDataEncryptionService'
 import { resolveEntityIdFromMetadata } from '@open-mercato/shared/lib/encryption/entityIds'
+import { listEntityMetadata } from '@open-mercato/shared/lib/db/entityMetadata'
 import { Organization } from '../directory/data/entities'
 import crypto from 'node:crypto'
 
@@ -263,8 +264,28 @@ function resolveEncryptionMapModules(): Module[] {
   }
 }
 
+/**
+ * Entity ids whose encryption map is declared in module code with `keyScope: 'system'`.
+ *
+ * Their ciphertext is sealed under a `system:<entityId>` DEK that has no tenant, so every
+ * tenant-scoped command here MUST leave them alone: re-wrapping such a value under a tenant
+ * DEK produces a payload runtime decryption can never read again. `backfill-system-encryption`
+ * is the one command that handles them.
+ */
+function getSystemScopedEntityIds(): Set<string> {
+  return new Set(
+    getDefaultEncryptionMaps(resolveEncryptionMapModules())
+      .filter((map) => map.keyScope === 'system')
+      .map((map) => map.entityId),
+  )
+}
+
 async function upsertEncryptionMaps(em: any, tenantId: string, organizationId: string | null, logger: (msg: string) => void) {
   for (const spec of getDefaultEncryptionMaps(resolveEncryptionMapModules())) {
+    if (spec.keyScope === 'system') {
+      logger(`Skipping ${spec.entityId}: system-scoped map, resolved from module code rather than a tenant row.`)
+      continue
+    }
     const existing = await em.findOne(EncryptionMap, {
       entityId: spec.entityId,
       tenantId,
@@ -378,9 +399,7 @@ function resolveProperty(meta: any, field: string): { columnName: string | null;
 }
 
 function buildEntityMetaRegistry(em: any): Map<string, any> {
-  const registry = em?.getMetadata?.()
-  const allMetaRaw = typeof registry?.getAll === 'function' ? registry.getAll() : []
-  const allMeta = Array.isArray(allMetaRaw) ? allMetaRaw : Object.values(allMetaRaw ?? {})
+  const allMeta = listEntityMetadata(em)
   const metaByEntityId = new Map<string, any>()
   for (const meta of allMeta) {
     const resolved = resolveEntityIdFromMetadata(meta)
@@ -414,6 +433,21 @@ function resolveMapMeta(
   return { entityId, meta, fields, tenantId }
 }
 
+function isEncryptedPayload(value: unknown): boolean {
+  if (typeof value !== 'string') return false
+  const parts = value.split(':')
+  return parts.length === 4 && parts[3] === 'v1'
+}
+
+function formatValueForColumn(prop: any, value: unknown): unknown {
+  if (value === null || value === undefined) return value
+  const types = Array.isArray(prop?.columnTypes) ? prop.columnTypes : []
+  const type = String(prop?.type ?? '').toLowerCase()
+  const isJson = types.some((entry: string) => entry.toLowerCase().includes('json')) || type === 'json' || type === 'jsonb'
+  if (!isJson) return value
+  return JSON.stringify(value)
+}
+
 const rotateEncryptionKey: ModuleCli = {
   command: 'rotate-encryption-key',
   async run(rest) {
@@ -470,32 +504,25 @@ const rotateEncryptionKey: ModuleCli = {
       }
     }
 
-    const isEncryptedPayload = (value: unknown): boolean => {
-      if (typeof value !== 'string') return false
-      const parts = value.split(':')
-      return parts.length === 4 && parts[3] === 'v1'
-    }
-
     const metaByEntityId = buildEntityMetaRegistry(em)
 
     const where: any = { deletedAt: null }
     if (tenantIdArg) where.tenantId = tenantIdArg
     if (organizationIdArg) where.organizationId = organizationIdArg
-    const maps = await em.find(EncryptionMap, where)
+    const allMaps = await em.find(EncryptionMap, where)
+    const systemScopedEntityIds = getSystemScopedEntityIds()
+    const maps = allMaps.filter((map: EncryptionMap) => {
+      if (!systemScopedEntityIds.has(String(map.entityId))) return true
+      console.warn(
+        `Skipping ${map.entityId}: system-scoped entity. Its ciphertext is sealed under a system key and cannot be rotated with a tenant key — use "mercato entities backfill-system-encryption" instead.`,
+      )
+      return false
+    })
     if (!maps.length) {
       console.log('No encryption maps found for the selected scope.')
       return
     }
 
-    const formatValueForColumn = (prop: any, value: unknown): unknown => {
-      if (value === null || value === undefined) return value
-      const types = Array.isArray(prop?.columnTypes) ? prop.columnTypes : []
-      const type = String(prop?.type ?? '').toLowerCase()
-      const isJson = types.some((entry: string) => entry.toLowerCase().includes('json')) || type === 'json' || type === 'jsonb'
-      if (!isJson) return value
-      return JSON.stringify(value)
-    }
-
     const resolveScopes = async (tenantId: string, organizationId: string | null) => {
       if (organizationId) return [{ tenantId, organizationId }]
       const orgs = await em.find(Organization, { tenant: tenantId })
@@ -699,7 +726,15 @@ const decryptDatabase: ModuleCli = {
     const mapWhere: any = { tenantId: tenantIdArg, deletedAt: null, isActive: true }
     if (organizationIdArg) mapWhere.organizationId = organizationIdArg
     if (entityIdArg) mapWhere.entityId = entityIdArg
-    const maps = await em.find(EncryptionMap, mapWhere)
+    const allMaps = await em.find(EncryptionMap, mapWhere)
+    const systemScopedEntityIds = getSystemScopedEntityIds()
+    const maps = allMaps.filter((map: EncryptionMap) => {
+      if (!systemScopedEntityIds.has(String(map.entityId))) return true
+      console.warn(
+        `Skipping ${map.entityId}: system-scoped entity. Its ciphertext is sealed under a system key that the tenant DEK cannot open, so this command leaves it untouched.`,
+      )
+      return false
+    })
 
     if (!maps.length) {
       console.log('No active encryption maps found for the selected scope.')
@@ -986,5 +1021,187 @@ const decryptDatabase: ModuleCli = {
   },
 }
 
+/**
+ * Encrypt rows that a **system-scoped** encryption map covers but that were written
+ * before the map existed.
+ *
+ * `rotate-encryption-key` cannot reach them: it walks the `encryption_maps` table and
+ * skips every row without a `tenant_id`, while system-scoped maps are declared in module
+ * code (`defaultEncryptionMaps` with `keyScope: 'system'`) and cover pre-tenant records
+ * that have no tenant at all — onboarding requests being the first such entity. Without a
+ * backfill those historical rows stay plaintext forever, since only the write path
+ * encrypts.
+ *
+ * The command is forward-only (plaintext → ciphertext), never accepts an old key and never
+ * decrypts, so it cannot re-encrypt data under the wrong key. It is idempotent: values that
+ * already decrypt under the current system DEK are left untouched by
+ * `encryptEntityPayload`, so a partial run can simply be repeated.
+ */
+const backfillSystemEncryption: ModuleCli = {
+  command: 'backfill-system-encryption',
+  async run(rest) {
+    const args = parseArgs(rest)
+    const entityIdArg = (args.entity as string) || null
+    const dryRun = Boolean(args['dry-run'] || args.dry)
+    const batchSize = Math.max(1, parseInt(String(args['batch-size'] || args.batchSize || '500'), 10) || 500)
+    const debug = Boolean(args.debug)
+
+    if (!isTenantDataEncryptionEnabled()) {
+      console.error('TENANT_DATA_ENCRYPTION is disabled; aborting. Enable encryption before backfilling.')
+      return
+    }
+
+    const systemMaps = getDefaultEncryptionMaps(resolveEncryptionMapModules()).filter((map) => map.keyScope === 'system')
+    if (!systemMaps.length) {
+      console.log('No system-scoped encryption maps are declared by the installed modules. Nothing to backfill.')
+      return
+    }
+    const selectedMaps = entityIdArg ? systemMaps.filter((map) => map.entityId === entityIdArg) : systemMaps
+    if (!selectedMaps.length) {
+      console.error(`No system-scoped encryption map declared for entity "${entityIdArg}".`)
+      console.error(`Known system-scoped entities: ${systemMaps.map((map) => map.entityId).join(', ')}`)
+      return
+    }
+
+    const { resolve } = await createRequestContainer()
+    const em = resolve('em') as any
+    const conn: any = em?.getConnection?.()
+    if (!conn || typeof conn.execute !== 'function') {
+      console.error('Unable to access raw database connection; aborting.')
+      return
+    }
+
+    const encryptionService = new TenantDataEncryptionService(em as any, {
+      kms: createKmsService(),
+      defaultEncryptionMaps: systemMaps,
+    })
+    if (!encryptionService.isEnabled()) {
+      console.error('Encryption service is not enabled (KMS unhealthy). Aborting without touching any row.')
+      return
+    }
+
+    const metaByEntityId = buildEntityMetaRegistry(em)
+    const prefix = dryRun ? '[dry-run] ' : ''
+    let totalRowsScanned = 0
+    let totalRowsUpdated = 0
+    let totalRowsUnchanged = 0
+
+    for (const map of selectedMaps) {
+      const entityId = map.entityId
+      const meta = metaByEntityId.get(entityId)
+      if (!meta) {
+        console.warn(`Skipping ${entityId}: entity metadata not found (is the owning module enabled?).`)
+        continue
+      }
+      const tableName = meta?.tableName
+      if (!tableName) {
+        console.warn(`Skipping ${entityId}: entity has no table name.`)
+        continue
+      }
+      const primaryKey = Array.isArray(meta?.primaryKeys) && meta.primaryKeys.length ? meta.primaryKeys[0] : 'id'
+      const { columnName: primaryKeyColumn } = resolveProperty(meta, primaryKey)
+      const pkColumn = primaryKeyColumn ?? primaryKey
+      const qualifiedTable = meta?.schema ? `"${meta.schema}"."${tableName}"` : `"${tableName}"`
+
+      const columns = new Set<string>([pkColumn])
+      for (const rule of map.fields) {
+        const resolved = resolveProperty(meta, rule.field)
+        if (resolved.columnName) columns.add(resolved.columnName)
+        if (rule.hashField) {
+          const resolvedHash = resolveProperty(meta, rule.hashField)
+          if (resolvedHash.columnName) columns.add(resolvedHash.columnName)
+        }
+      }
+      const columnList = Array.from(columns)
+      const selectList = columnList.map((column) => `"${column}"`).join(', ')
+
+      let cursor: unknown = null
+      let entityRowsScanned = 0
+      let entityRowsUpdated = 0
+      let entityRowsUnchanged = 0
+
+      for (;;) {
+        const selectSql = cursor === null
+          ? `select ${selectList} from ${qualifiedTable} order by "${pkColumn}" asc limit ?`
+          : `select ${selectList} from ${qualifiedTable} where "${pkColumn}" > ? order by "${pkColumn}" asc limit ?`
+        const params = cursor === null ? [batchSize] : [cursor, batchSize]
+        const rows = await conn.execute(selectSql, params)
+        const list = Array.isArray(rows) ? rows : []
+        if (!list.length) break
+
+        for (const row of list) {
+          entityRowsScanned += 1
+          cursor = row[pkColumn]
+          const payload: Record<string, unknown> = {}
+          let hasPlaintext = false
+          for (const rule of map.fields) {
+            const resolved = resolveProperty(meta, rule.field)
+            if (!resolved.columnName) continue
+            const rawValue = row[resolved.columnName]
+            payload[rule.field] = rawValue
+            if (rawValue !== null && rawValue !== undefined && !isEncryptedPayload(rawValue)) hasPlaintext = true
+            if (rule.hashField) {
+              const resolvedHash = resolveProperty(meta, rule.hashField)
+              if (resolvedHash.columnName) payload[rule.hashField] = row[resolvedHash.columnName]
+            }
+          }
+          if (!hasPlaintext) continue
+
+          const encrypted = await encryptionService.encryptEntityPayload(entityId, payload, null, null)
+          const updates: Record<string, unknown> = {}
+          for (const rule of map.fields) {
+            const resolved = resolveProperty(meta, rule.field)
+            if (resolved.columnName) {
+              const nextValue = encrypted[rule.field]
+              if (nextValue !== undefined && nextValue !== row[resolved.columnName]) {
+                updates[resolved.columnName] = formatValueForColumn(resolved.prop, nextValue)
+              }
+            }
+            if (rule.hashField) {
+              const resolvedHash = resolveProperty(meta, rule.hashField)
+              const nextHash = encrypted[rule.hashField]
+              if (resolvedHash.columnName && nextHash !== undefined && nextHash !== row[resolvedHash.columnName]) {
+                updates[resolvedHash.columnName] = formatValueForColumn(resolvedHash.prop, nextHash)
+              }
+            }
+          }
+          if (!Object.keys(updates).length) {
+            entityRowsUnchanged += 1
+            if (debug) console.warn(`[backfill-system-encryption] ${entityId} ${String(row[pkColumn])}: plaintext left unchanged`)
+            continue
+          }
+          if (!dryRun) {
+            const setSql = Object.keys(updates).map((column) => `"${column}" = ?`).join(', ')
+            await conn.execute(
+              `update ${qualifiedTable} set ${setSql} where "${pkColumn}" = ?`,
+              [...Object.values(updates), row[pkColumn]],
+            )
+          }
+          entityRowsUpdated += 1
+        }
+
+        if (list.length < batchSize) break
+      }
+
+      totalRowsScanned += entityRowsScanned
+      totalRowsUpdated += entityRowsUpdated
+      totalRowsUnchanged += entityRowsUnchanged
+      console.log(`${prefix}${entityId}: scanned ${entityRowsScanned}, encrypted ${entityRowsUpdated}`)
+    }
+
+    console.log(`\n${prefix}Backfill summary:`)
+    console.log(`  Rows scanned:   ${totalRowsScanned}`)
+    console.log(`  Rows encrypted: ${totalRowsUpdated}`)
+    if (totalRowsUnchanged > 0) {
+      console.warn(
+        `  ⚠ ${totalRowsUnchanged} row(s) held plaintext that could not be encrypted — the system DEK was unavailable. Verify the KMS/fallback key, then re-run (use --debug to list the rows).`,
+      )
+    }
+    if (!dryRun && totalRowsUpdated > 0) {
+      console.log('\n✅ Backfill complete. Re-run with --dry-run to confirm no plaintext rows remain.')
+    }
+  },
+}
+
 // Keep default export stable (install first for help listing)
-export default [seedDefs, reinstallDefs, addField, seedEncryptionMaps, rotateEncryptionKey, decryptDatabase]
+export default [seedDefs, reinstallDefs, addField, seedEncryptionMaps, rotateEncryptionKey, decryptDatabase, backfillSystemEncryption]

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

@@ -0,0 +1,160 @@
+"use client"
+
+import * as React from 'react'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { Checkbox } from '@open-mercato/ui/primitives/checkbox'
+import { Label } from '@open-mercato/ui/primitives/label'
+import { Spinner } from '@open-mercato/ui/primitives/spinner'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { apiCall, apiCallOrThrow, readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { ErrorMessage } from '@open-mercato/ui/backend/detail'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
+import { buildOptimisticLockHeader, extractOptimisticLockConflict } from '@open-mercato/ui/backend/utils/optimisticLock'
+import { withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
+
+export function EntitySettingsManager(): React.ReactElement {
+  const t = useT()
+  const [loading, setLoading] = React.useState(true)
+  const [loadError, setLoadError] = React.useState(false)
+  const [saving, setSaving] = React.useState(false)
+  const [restricted, setRestricted] = React.useState(false)
+  const [updatedAt, setUpdatedAt] = React.useState<string | null>(null)
+
+  const { runMutation } = useGuardedMutation({
+    contextId: 'custom-entities-settings',
+  })
+
+  const loadSettings = React.useCallback(async () => {
+    setLoading(true)
+    setLoadError(false)
+    try {
+      const data = await readApiResultOrThrow<{ newEntitiesRestrictedByDefault?: boolean; updatedAt?: string | null }>(
+        '/api/entities/entity-settings',
+        undefined,
+        {
+          errorMessage: t('entities.settings.errors.loadFailed', 'Failed to load settings'),
+        }
+      )
+      setRestricted(data.newEntitiesRestrictedByDefault === true)
+      setUpdatedAt(data.updatedAt ?? null)
+    } catch {
+      setLoadError(true)
+    } finally {
+      setLoading(false)
+    }
+  }, [t])
+
+  React.useEffect(() => {
+    void loadSettings()
+  }, [loadSettings])
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+    setSaving(true)
+    try {
+      const headers = buildOptimisticLockHeader(updatedAt)
+      await runMutation({
+        operation: () =>
+          withScopedApiRequestHeaders(headers, async () => {
+            const res = await apiCallOrThrow<{ ok: boolean; newEntitiesRestrictedByDefault: boolean; updatedAt: string | null }>(
+              '/api/entities/entity-settings',
+              {
+                method: 'PUT',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                  newEntitiesRestrictedByDefault: restricted,
+                  expectedUpdatedAt: updatedAt ?? undefined,
+                }),
+              },
+              {
+                errorMessage: t('entities.settings.errors.saveFailed', 'Failed to save settings'),
+              }
+            )
+
+            if (res.ok && res.result) {
+              setUpdatedAt(res.result.updatedAt)
+              flash(t('entities.settings.flash.saved', 'Settings saved'), 'success')
+            }
+            return res
+          }),
+        context: {},
+        mutationPayload: {
+          newEntitiesRestrictedByDefault: restricted,
+        },
+      })
+    } catch (err) {
+      const conflict = extractOptimisticLockConflict(err)
+      if (conflict) {
+        setLoading(true)
+        await loadSettings()
+      } else {
+        flash(t('entities.settings.errors.saveFailed', 'Failed to save settings'), 'error')
+      }
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  if (loading) {
+    return (
+      <div className="flex items-center gap-2 text-sm text-muted-foreground">
+        <Spinner className="h-4 w-4" />
+        <span>{t('entities.userEntities.form.loading', 'Loading…')}</span>
+      </div>
+    )
+  }
+
+  if (loadError) {
+    return (
+      <ErrorMessage
+        label={t('entities.settings.errors.loadFailed', 'Failed to load settings')}
+        action={(
+          <Button type="button" variant="outline" size="sm" onClick={() => void loadSettings()}>
+            {t('common.retry', 'Retry')}
+          </Button>
+        )}
+      />
+    )
+  }
+
+  return (
+    <form onSubmit={(e) => void handleSubmit(e)} className="space-y-6 max-w-2xl">
+      <div className="space-y-1">
+        <h3 className="text-base font-semibold">
+          {t('entities.settings.title', 'Custom Entities')}
+        </h3>
+        <p className="text-sm text-muted-foreground">
+          {t('entities.settings.description', 'Manage global custom entity configurations.')}
+        </p>
+      </div>
+
+      <div className="rounded-lg border bg-card p-4 space-y-4">
+        <div className="flex items-start gap-3">
+          <Checkbox
+            id="newEntitiesRestrictedByDefault"
+            checked={restricted}
+            onCheckedChange={(checked) => setRestricted(checked === true)}
+            disabled={saving}
+            className="mt-1"
+          />
+          <div className="space-y-1">
+            <Label htmlFor="newEntitiesRestrictedByDefault" className="font-medium cursor-pointer">
+              {t('entities.settings.newEntitiesRestrictedByDefault.label', 'Restrict record access by default')}
+            </Label>
+            <p className="text-sm text-muted-foreground">
+              {t('entities.settings.newEntitiesRestrictedByDefault.description', 'Require explicit per-entity permissions for records of newly created custom entities by default.')}
+            </p>
+          </div>
+        </div>
+      </div>
+
+      <div className="flex items-center justify-end gap-3 border-t pt-4">
+        <Button type="submit" disabled={saving}>
+          {saving ? <Spinner className="mr-2 h-4 w-4" /> : null}
+          {t('common.save', 'Save')}
+        </Button>
+      </div>
+    </form>
+  )
+}

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/SystemEntitiesTable.tsx

@@ -1,5 +1,6 @@
 "use client"
 import * as React from 'react'
+import { extensionPoints } from '@open-mercato/core/modules/entities/extension-points'
 import { useQuery } from '@tanstack/react-query'
 import type { ColumnDef, SortingState } from '@tanstack/react-table'
 import { DataTable } from '@open-mercato/ui/backend/DataTable'
@@ -73,7 +74,7 @@ export default function SystemEntitiesTable() {
       sortable
       sorting={sorting}
       onSortingChange={setSorting}
-      perspective={{ tableId: 'entities.system.list' }}
+      perspective={{ tableId: extensionPoints.hosts.systemEntitiesTable.tableId }}
       rowActions={(row) => (
         <RowActions
           items={[

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

@@ -1,6 +1,7 @@
 
 "use client"
 import * as React from 'react'
+import { extensionPoints } from '@open-mercato/core/modules/entities/extension-points'
 import Link from 'next/link'
 import { useQuery } from '@tanstack/react-query'
 import type { ColumnDef, SortingState } from '@tanstack/react-table'
@@ -96,7 +97,7 @@ export default function UserEntitiesTable() {
       sortable
       sorting={sorting}
       onSortingChange={setSorting}
-      perspective={{ tableId: 'entities.user.list' }}
+      perspective={{ tableId: extensionPoints.hosts.userEntitiesTable.tableId }}
       emptyState={(
         <ListEmptyState
           entityName={t('entities.user.table.title', 'User Entities')}