@open-mercato/core 0.6.6-develop.6543.1.49fadb4c31 → 0.6.6

package/src/modules/directory/utils/organizationScope.ts

@@ -18,13 +18,6 @@ export type OrganizationScope = {
   filterIds: string[] | null
   allowedIds: string[] | null
   tenantId: string | null
-  // True when the caller explicitly selected a concrete organization (cookie /
-  // selectedId param) that could not be honored — it does not exist for the
-  // tenant or is not accessible. Reads degrade gracefully (filterIds/selectedId
-  // fall back to the caller's accessible orgs), but writes MUST fail loudly on
-  // this so a record never lands under an org the caller did not intend. Absent
-  // (undefined) means the selection — if any — was honored.
-  selectionRejected?: boolean
 }
 
 // Phase 4 — short-TTL cache for resolveOrganizationScopeForRequest.
@@ -86,8 +79,7 @@ function isValidCachedScope(value: unknown): value is OrganizationScope {
   const record = value as Partial<OrganizationScope>
   const idOk = (v: unknown) => v === null || typeof v === 'string'
   const arrOk = (v: unknown) => v === null || (Array.isArray(v) && v.every((entry) => typeof entry === 'string'))
-  const flagOk = record.selectionRejected === undefined || typeof record.selectionRejected === 'boolean'
-  return idOk(record.selectedId) && idOk(record.tenantId) && arrOk(record.filterIds) && arrOk(record.allowedIds) && flagOk
+  return idOk(record.selectedId) && idOk(record.tenantId) && arrOk(record.filterIds) && arrOk(record.allowedIds)
 }
 
 function resolveCacheFromContainer(container: AwilixContainer | null | undefined): CacheStrategy | null {
@@ -328,18 +320,9 @@ export async function resolveOrganizationScope({
   const initialSelected =
     normalizedSelectedId
     ?? (widenToAllOrgs ? null : accountOrgId ?? null)
-  // A selection is only honored when it resolves to a real, non-deleted org for
-  // this tenant. `orgDescendants` holds exactly the existing orgs among the
-  // candidate ids, so a stale/dead id (e.g. a selected-org cookie or JWT org
-  // that no longer resolves after a DB reset) has no entry and is dropped here.
-  // Without the existence guard an unrestricted (all-orgs) principal — whose
-  // `allowedSet` is null — would accept the dead id as `effectiveSelected`, and
-  // writes derived from `selectedId` would land under an org the read scope
-  // (`filterIds`) never filters to, silently orphaning the record.
-  const selectionResolvesToOrg = (id: string): boolean => orgDescendants.has(id)
   let effectiveSelected: string | null = null
   if (initialSelected) {
-    if ((allowedSet === null || allowedSet.has(initialSelected)) && selectionResolvesToOrg(initialSelected)) {
+    if (allowedSet === null || allowedSet.has(initialSelected)) {
       effectiveSelected = initialSelected
     }
   }
@@ -353,13 +336,6 @@ export async function resolveOrganizationScope({
     filterSet = null
   } else if (auth.orgId) {
     filterSet = loadFallbackSet()
-    // Keep the write target (`selectedId`) aligned with the read scope
-    // (`filterIds`): when an unrestricted principal's requested selection was
-    // dropped above, fall the selection back to the account org too so a record
-    // created here is always readable back by the same caller.
-    if (!effectiveSelected && fallbackOrgId && filterSet && filterSet.size > 0) {
-      effectiveSelected = fallbackOrgId
-    }
   }
 
   if ((!filterSet || filterSet.size === 0) && fallbackOrgId && !widenToAllOrgs) {
@@ -372,21 +348,11 @@ export async function resolveOrganizationScope({
     }
   }
 
-  // A concrete organization was explicitly requested (`normalizedSelectedId` is
-  // null for both "no selection" and the "all organizations" token) but the
-  // resolver could not honor it — it was dropped as non-existent/inaccessible
-  // and the effective selection fell back to something else. Surface this so the
-  // write layer can reject the request instead of silently creating the record
-  // under the fallback org. Only set the field when true to keep the scope shape
-  // unchanged for the common (honored) case.
-  const selectionRejected = normalizedSelectedId !== null && effectiveSelected !== normalizedSelectedId
-
   return {
     selectedId: effectiveSelected,
     filterIds: filterSet ? Array.from(filterSet) : null,
     allowedIds: allowedSet ? Array.from(allowedSet) : null,
     tenantId,
-    ...(selectionRejected ? { selectionRejected: true } : {}),
   }
 }
 

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

@@ -8,7 +8,6 @@ import type { RbacService } from '@open-mercato/core/modules/auth/services/rbacS
 import { resolveOrganizationScope, getSelectedOrganizationFromRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
 import { SYSTEM_ENTITY_RECORDS_BLOCKED_CODE, isOrmBackedSystemEntityId } from '@open-mercato/shared/lib/data/engine'
 import { parseBooleanToken, parseBooleanWithDefault } from '@open-mercato/shared/lib/boolean'
-import { parseCommaSeparatedList } from '@open-mercato/shared/lib/string'
 import { setRecordCustomFields } from '../lib/helpers'
 import { CustomFieldValue } from '../data/entities'
 import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
@@ -152,7 +151,10 @@ export async function GET(req: Request) {
   const sortDir = (url.searchParams.get('sortDir') || 'asc').toLowerCase() === 'desc' ? 'desc' : 'asc'
   const withDeleted = parseBooleanWithDefault(url.searchParams.get('withDeleted'), false)
   const searchTerm = (url.searchParams.get('search') || '').trim()
-  const searchFields = parseCommaSeparatedList(url.searchParams.get('searchFields'))
+  const searchFields = (url.searchParams.get('searchFields') || '')
+    .split(',')
+    .map((field) => field.trim())
+    .filter(Boolean)
 
   const qpEntries: Array<[string, string]> = []
   for (const [key, val] of url.searchParams.entries()) {
@@ -209,11 +211,11 @@ export async function GET(req: Request) {
       if (key.startsWith('cf_')) {
         if (key.endsWith('In')) {
           const base = key.slice(0, -2)
-          const values = parseCommaSeparatedList(val)
+          const values = val.split(',').map((s) => s.trim()).filter(Boolean)
           ;(filtersObj as any)[base] = { $in: values }
         } else {
           if (val.includes(',')) {
-            const values = parseCommaSeparatedList(val)
+            const values = val.split(',').map((s) => s.trim()).filter(Boolean)
             ;(filtersObj as any)[key] = { $in: values }
           } else {
             const parsed = parseBooleanToken(val)
@@ -222,7 +224,7 @@ export async function GET(req: Request) {
         }
       } else if (allowAnyKey) {
         if (val.includes(',')) {
-          const values = parseCommaSeparatedList(val)
+          const values = val.split(',').map((s) => s.trim()).filter(Boolean)
           ;(filtersObj as any)[key] = { $in: values }
         } else {
           const parsed = parseBooleanToken(val)

package/src/modules/entities/backend/entities/system/[entityId]/page.meta.ts

@@ -2,7 +2,6 @@ export const metadata = {
   requireAuth: true,
   requireFeatures: ['entities.definitions.manage'],
   pageTitle: 'Edit Definitions',
-  pageTitleKey: 'entities.userEntities.edit.pageTitle',
   pageGroup: 'Data designer',
   navHidden: true,
 }

package/src/modules/entities/backend/entities/user/[entityId]/page.meta.ts

@@ -2,7 +2,6 @@ export const metadata = {
   requireAuth: true,
   requireFeatures: ['entities.definitions.manage'],
   pageTitle: 'Edit Definitions',
-  pageTitleKey: 'entities.userEntities.edit.pageTitle',
   pageGroup: 'Data designer',
   navHidden: true,
 }

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

@@ -167,7 +167,7 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
         const entJson = await readApiResultOrThrow<EntitiesListResponse>(
           '/api/entities/entities',
           undefined,
-          { errorMessage: t('entities.userEntities.edit.errors.loadMetadataFailed', 'Failed to load entity metadata'), fallback: { items: [] } },
+          { errorMessage: 'Failed to load entity metadata', fallback: { items: [] } },
         )
         const ent = (entJson.items || []).find((x: any) => x.entityId === entityId)
         if (mounted) {
@@ -197,7 +197,7 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
         const json = await readApiResultOrThrow<DefinitionsManageResponse>(
           `/api/entities/definitions.manage?entityId=${encodeURIComponent(entityId)}`,
           undefined,
-          { errorMessage: t('entities.userEntities.edit.errors.loadDefinitionsFailed', 'Failed to load entity definitions'), fallback: { items: [], deletedKeys: [] } },
+          { errorMessage: 'Failed to load entity definitions', fallback: { items: [], deletedKeys: [] } },
         )
         if (mounted) {
           const loaded: Def[] = (json.items || []).map((d: any) => ({ key: d.key, kind: d.kind, configJson: d.configJson || {}, isActive: d.isActive !== false }))
@@ -220,14 +220,14 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
           setSingleFieldsetPerRecord(json.settings?.singleFieldsetPerRecord !== false)
         }
       } catch (e: any) {
-        if (mounted) setError(e.message || t('entities.userEntities.edit.errors.loadFailed', 'Failed to load'))
+        if (mounted) setError(e.message || 'Failed to load')
       } finally {
         if (mounted) setLoading(false)
       }
     }
     if (entityId) load()
     return () => { mounted = false }
-  }, [entityId, t])
+  }, [entityId])
 
   function addField() {
     setDefs((arr) => [
@@ -249,13 +249,13 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
         body: JSON.stringify({ entityId, key }),
       })
       if (!call.ok) {
-        await raiseCrudError(call.response, t('entities.userEntities.edit.errors.restoreFieldFailed', 'Failed to restore field'))
+        await raiseCrudError(call.response, 'Failed to restore field')
       }
       // Reload definitions & deleted keys
       const j2 = await readApiResultOrThrow<DefinitionsManageResponse>(
         `/api/entities/definitions.manage?entityId=${encodeURIComponent(entityId)}`,
         undefined,
-        { errorMessage: t('entities.userEntities.edit.errors.reloadDefinitionsFailed', 'Failed to reload field definitions'), fallback: { items: [], deletedKeys: [] } },
+        { errorMessage: 'Failed to reload field definitions', fallback: { items: [], deletedKeys: [] } },
       )
       const loaded: Def[] = (j2.items || []).map((d: any) => ({ key: d.key, kind: d.kind, configJson: d.configJson || {}, isActive: d.isActive !== false }))
       loaded.sort(
@@ -264,10 +264,10 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       setDefs(loaded)
       setDefsVersion(readVersionToken(j2.version))
       setDeletedKeys(Array.isArray(j2.deletedKeys) ? j2.deletedKeys : [])
-      flash(t('entities.userEntities.edit.flash.restoredField', 'Restored {{key}}', { key }), 'success')
+      flash(`Restored ${key}`, 'success')
       await invalidateCustomFieldDefs(queryClient, entityId)
     } catch (e: any) {
-      flash(e?.message || t('entities.userEntities.edit.errors.restoreFieldFailed', 'Failed to restore field'), 'error')
+      flash(e?.message || 'Failed to restore field', 'error')
     }
   }
 
@@ -276,8 +276,8 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
     setError(null)
     try {
       if (!validateAll()) {
-        flash(t('entities.customFields.errors.validation', 'Please fix validation errors in field definitions.'), 'error')
-        throw new Error(t('entities.userEntities.edit.errors.validationFailed', 'Validation failed'))
+        flash('Please fix validation errors in field definitions', 'error')
+        throw new Error('Validation failed')
       }
       const payload = {
         entityId,
@@ -298,13 +298,13 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       )
       if (!call.ok) {
         if (surfaceRecordConflict({ status: call.status, body: call.result }, t)) return
-        await raiseCrudError(call.response, t('entities.customFields.errors.saveFailed', 'Failed to save field definitions.'))
+        await raiseCrudError(call.response, 'Failed to save definitions')
       }
       setDefsVersion(readVersionToken(call.result?.version))
       await invalidateCustomFieldDefs(queryClient, entityId)
-      router.push(`/backend/entities/user?flash=${encodeURIComponent(t('entities.customFields.flash.saved', 'Definitions saved'))}&type=success`)
+      router.push(`/backend/entities/user?flash=Definitions%20saved&type=success`)
     } catch (e: any) {
-      setError(e.message || t('entities.customFields.errors.saveFailed', 'Failed to save field definitions.'))
+      setError(e.message || 'Failed to save')
     } finally {
       setSaving(false)
     }
@@ -321,13 +321,13 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
           body: JSON.stringify({ entityId, key: def.key }),
         })
         if (!call.ok) {
-          await raiseCrudError(call.response, t('entities.customFields.errors.deleteFailed', 'Failed to delete field.'))
+          await raiseCrudError(call.response, 'Failed to delete field')
         }
         // Keep the optimistic-lock token in sync after an out-of-band delete so a
         // later Save does not falsely 409 against our own change (issue #3152).
         setDefsVersion(readVersionToken(call.result?.version))
       } catch (error) {
-        const message = error instanceof Error ? error.message : t('entities.customFields.errors.deleteFailed', 'Failed to delete field.')
+        const message = error instanceof Error ? error.message : 'Failed to delete field'
         flash(message, 'error')
         return
       }
@@ -372,7 +372,7 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
     setOrderSaving(true)
     try {
       // Do not save order when there are invalid keys/kinds
-      if (!validateAll()) throw new Error(t('entities.userEntities.edit.errors.validationFailed', 'Validation failed'))
+      if (!validateAll()) throw new Error('Validation failed')
       const payload = {
         entityId,
         definitions: defs.filter(d => !!d.key).map((d) => ({
@@ -396,14 +396,14 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
           setOrderDirty(false)
           return
         }
-        await raiseCrudError(call.response, t('entities.userEntities.edit.errors.saveOrderFailed', 'Failed to save order'))
+        await raiseCrudError(call.response, 'Failed to save order')
       }
       setDefsVersion(readVersionToken(call.result?.version))
       setOrderDirty(false)
-      flash(t('entities.userEntities.edit.flash.orderSaved', 'Order saved'), 'success')
+      flash('Order saved', 'success')
       await invalidateCustomFieldDefs(queryClient, entityId)
     } catch (e: any) {
-      flash(e?.message || t('entities.userEntities.edit.errors.saveOrderFailed', 'Failed to save order'), 'error')
+      flash(e?.message || 'Failed to save order', 'error')
     } finally {
       setOrderSaving(false)
     }
@@ -423,21 +423,21 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
 
   const metadataFieldsReadOnly = entitySource === 'code'
   const fields: CrudField[] = [
-    { id: 'label', label: t('entities.userEntities.form.label.label', 'Label'), type: 'text', required: true, readOnly: metadataFieldsReadOnly },
-    { id: 'description', label: t('entities.userEntities.form.description.label', 'Description'), type: 'textarea', readOnly: metadataFieldsReadOnly },
+    { id: 'label', label: 'Label', type: 'text', required: true, readOnly: metadataFieldsReadOnly },
+    { id: 'description', label: 'Description', type: 'textarea', readOnly: metadataFieldsReadOnly },
     {
       id: 'defaultEditor',
-      label: t('entities.userEntities.form.defaultEditor.label', 'Default Editor (multiline)'),
+      label: 'Default Editor (multiline)',
       type: 'select',
       readOnly: metadataFieldsReadOnly,
       options: [
-        { value: '', label: t('entities.userEntities.form.defaultEditor.options.default', 'Default (Markdown)') },
-        { value: 'markdown', label: t('entities.userEntities.form.defaultEditor.options.markdown', 'Markdown (UIW)') },
-        { value: 'simpleMarkdown', label: t('entities.userEntities.form.defaultEditor.options.simpleMarkdown', 'Simple Markdown') },
-        { value: 'htmlRichText', label: t('entities.userEntities.form.defaultEditor.options.htmlRichText', 'HTML Rich Text') },
+        { value: '', label: 'Default (Markdown)' },
+        { value: 'markdown', label: 'Markdown (UIW)' },
+        { value: 'simpleMarkdown', label: 'Simple Markdown' },
+        { value: 'htmlRichText', label: 'HTML Rich Text' },
       ],
     } as any,
-    ...(entitySource === 'custom' ? [{ id: 'showInSidebar', label: t('entities.userEntities.form.showInSidebar.label', 'Show in sidebar'), type: 'checkbox' }] : []),
+    ...(entitySource === 'custom' ? [{ id: 'showInSidebar', label: 'Show in sidebar', type: 'checkbox' }] : []),
   ]
   const renderFieldDefinitions = React.useCallback(() => (
       <FieldDefinitionsEditor
@@ -474,7 +474,7 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
           })
           setOrderDirty(true)
         }}
-        orderNotice={orderDirty ? { dirty: true, saving: orderSaving, message: t('entities.userEntities.edit.orderNotice', 'Reordered - will auto-save on blur') } : undefined}
+        orderNotice={orderDirty ? { dirty: true, saving: orderSaving, message: 'Reordered — will auto-save on blur' } : undefined}
         addButtonLabel={t('entities.customFields.editor.addField', 'Add Field')}
         translate={t}
         listRef={listRef}
@@ -491,22 +491,22 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
         }}
       />
     ),
-  [defs, defErrors, deletedKeys, fieldsets, activeFieldset, singleFieldsetPerRecord, orderDirty, orderSaving, addField, removeField, restoreField, saveOrderIfDirty, t])
+  [defs, defErrors, deletedKeys, fieldsets, activeFieldset, singleFieldsetPerRecord, orderDirty, orderSaving, addField, removeField, restoreField, saveOrderIfDirty])
 
-  const definitionsGroup: CrudFormGroup = { id: 'definitions', title: t('entities.userEntities.edit.groups.definitions', 'Field Definitions'), column: 1, component: renderFieldDefinitions }
+  const definitionsGroup: CrudFormGroup = { id: 'definitions', title: 'Field Definitions', column: 1, component: renderFieldDefinitions }
 
   const groups: CrudFormGroup[] = [
-    { id: 'settings', title: t('entities.userEntities.edit.groups.settings', 'Entity Settings'), column: 1, fields: entitySource === 'custom' ? ['label','description','defaultEditor','showInSidebar'] : ['label','description','defaultEditor'] },
+    { id: 'settings', title: 'Entity Settings', column: 1, fields: entitySource === 'custom' ? ['label','description','defaultEditor','showInSidebar'] : ['label','description','defaultEditor'] },
     definitionsGroup,
   ]
 
   const handleCrudFormSubmit = React.useCallback(async (vals: Record<string, unknown>) => {
     if (!entityId) {
-      throw createCrudFormError(t('entities.userEntities.edit.errors.invalidEntityId', 'Invalid entity ID'))
+      throw createCrudFormError('Invalid entity ID')
     }
     if (!validateAll()) {
-      flash(t('entities.customFields.errors.validation', 'Please fix validation errors in field definitions.'), 'error')
-      throw createCrudFormError(t('entities.customFields.errors.validation', 'Please fix validation errors in field definitions.'))
+      flash('Please fix validation errors in field definitions', 'error')
+      throw createCrudFormError('Please fix validation errors in field definitions')
     }
     // Code-declared system entities are not registered as custom entities — their
     // metadata is owned by code and `POST /api/entities/entities` is fail-closed for
@@ -514,14 +514,14 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
     // skip the registration call and persist definitions below.
     if (shouldRegisterEntityMetadata(entitySource)) {
       const entityPayload = buildEntityMetadataPayload(entitySource, vals)
-      if (!entityPayload) throw createCrudFormError(t('entities.userEntities.edit.errors.validationFailed', 'Validation failed'))
+      if (!entityPayload) throw createCrudFormError('Validation failed')
       const callEntity = await apiCall('/api/entities/entities', {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
         body: JSON.stringify({ entityId, ...entityPayload }),
       })
       if (!callEntity.ok) {
-        await raiseCrudError(callEntity.response, t('entities.userEntities.edit.errors.saveEntityFailed', 'Failed to save entity'))
+        await raiseCrudError(callEntity.response, 'Failed to save entity')
       }
       try { window.dispatchEvent(new Event('om:refresh-sidebar')) } catch {}
     }
@@ -543,13 +543,13 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       }),
     )
     if (!callDefs.ok) {
-      await raiseCrudError(callDefs.response, t('entities.customFields.errors.saveFailed', 'Failed to save field definitions.'))
+      await raiseCrudError(callDefs.response, 'Failed to save definitions')
     }
     setDefsVersion(readVersionToken(callDefs.result?.version))
     try { window.dispatchEvent(new Event('om:refresh-sidebar')) } catch {}
     await invalidateCustomFieldDefs(queryClient, entityId)
-    flash(t('entities.customFields.flash.saved', 'Definitions saved'), 'success')
-  }, [buildFieldsetPayload, defs, defsVersion, entityId, entitySource, queryClient, singleFieldsetPerRecord, t, validateAll])
+    flash('Definitions saved', 'success')
+  }, [buildFieldsetPayload, defs, defsVersion, entityId, entitySource, queryClient, singleFieldsetPerRecord, validateAll])
 
   if (!entityId) {
     return (
@@ -557,8 +557,8 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
         <PageBody>
           <div className="p-6">
             <Alert variant="destructive">
-              <AlertTitle>{t('entities.userEntities.edit.errors.invalidEntityTitle', 'Invalid entity')}</AlertTitle>
-              <AlertDescription>{t('entities.userEntities.edit.errors.invalidEntityDescription', 'The requested entity ID is missing or invalid.')}</AlertDescription>
+              <AlertTitle>Invalid entity</AlertTitle>
+              <AlertDescription>The requested entity ID is missing or invalid.</AlertDescription>
             </Alert>
           </div>
         </PageBody>
@@ -571,12 +571,12 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       <div className="p-4">
         <CrudForm
           schema={entityFormSchema}
-          title={t('entities.userEntities.edit.fieldsetTitle', 'Edit fieldset: {{name}}', { name: requestedFieldset ?? entityId })}
+          title={`Edit fieldset: ${requestedFieldset ?? entityId}`}
           fields={[]}
           groups={[definitionsGroup]}
           initialValues={entityInitial as any}
           isLoading={entityFormLoading || loading}
-          submitLabel={t('entities.userEntities.records.form.submitSave', 'Save')}
+          submitLabel="Save"
           deleteVisible={false}
           backHref={undefined}
           cancelHref={undefined}
@@ -592,32 +592,30 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       <PageBody>
         <CrudForm
           schema={entityFormSchema}
-          title={t('entities.userEntities.edit.title', 'Edit Entity: {{entityId}}', { entityId })}
+          title={`Edit Entity: ${entityId}`}
           backHref={entitySource === 'code' ? "/backend/entities/system" : "/backend/entities/user"}
           fields={fields}
           groups={groups}
           initialValues={entityInitial as any}
           isLoading={entityFormLoading || loading}
-          submitLabel={t('entities.userEntities.records.form.submitSave', 'Save')}
+          submitLabel="Save"
           deleteVisible={entitySource === 'custom'}
           extraActions={entitySource === 'custom' ? (
             <Button variant="outline" asChild>
               <Link href={`/backend/entities/user/${encodeURIComponent(entityId)}/records`}>
-                {t('entities.userEntities.edit.showRecords', 'Show Records')}
+                Show Records
               </Link>
             </Button>
           ) : null}
           cancelHref={entitySource === 'code' ? "/backend/entities/system" : "/backend/entities/user"}
-          successRedirect={entitySource === 'code'
-            ? `/backend/entities/system?flash=${encodeURIComponent(t('entities.customFields.flash.saved', 'Definitions saved'))}&type=success`
-            : `/backend/entities/user?flash=${encodeURIComponent(t('entities.customFields.flash.saved', 'Definitions saved'))}&type=success`}
+          successRedirect={entitySource === 'code' ? "/backend/entities/system?flash=Definitions%20saved&type=success" : "/backend/entities/user?flash=Definitions%20saved&type=success"}
           onSubmit={handleCrudFormSubmit}
         onDelete={entitySource === 'custom' ? async () => {
           const callDelete = await apiCall('/api/entities/entities', { method: 'DELETE', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ entityId }) })
           if (!callDelete.ok) {
-            await raiseCrudError(callDelete.response, t('entities.userEntities.edit.errors.deleteEntityFailed', 'Failed to delete entity'))
+            await raiseCrudError(callDelete.response, 'Failed to delete entity')
           }
-          flash(t('entities.userEntities.edit.flash.entityDeleted', 'Entity deleted'), 'success')
+          flash('Entity deleted', 'success')
           try { window.dispatchEvent(new Event('om:refresh-sidebar')) } catch {}
         } : undefined}
       />

package/src/modules/entities/cli.ts

@@ -10,7 +10,6 @@ import readline from 'node:readline/promises'
 import { stdin as input, stdout as output } from 'node:process'
 import { isTenantDataEncryptionEnabled } from '@open-mercato/shared/lib/encryption/toggles'
 import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
-import { parseCommaSeparatedList } from '@open-mercato/shared/lib/string'
 import { createKmsService, type KmsService, type TenantDek } from '@open-mercato/shared/lib/encryption/kms'
 import {
   decryptWithAesGcm,
@@ -194,7 +193,7 @@ const addField: ModuleCli = {
       let options: string[] | undefined
       if (kind === 'select') {
         const raw = (args.options as string) || await ask('Options (comma-separated)', 'low,medium,high')
-        options = parseCommaSeparatedList(raw)
+        options = raw.split(',').map((s) => s.trim()).filter(Boolean)
       }
       let defaultValue: any = undefined
       const defRaw = (args.default as string) ?? (args.defaultValue as string)

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

@@ -93,7 +93,6 @@
   "entities.customFields.editor.noFieldsets": "Noch keine Feldgruppen definiert. Mit Feldgruppen lassen sich benutzerdefinierte Felder für verschiedene Varianten derselben Entität gruppieren (z. B. Mode- vs. Sportprodukte).",
   "entities.customFields.editor.noGroup": "Keine Gruppe",
   "entities.customFields.editor.noOptionsDefined": "Keine Optionen definiert.",
-  "entities.customFields.editor.noParameterPlaceholder": "-",
   "entities.customFields.editor.noValidationRules": "Keine Validierungsregeln definiert.",
   "entities.customFields.editor.optionLabelPlaceholder": "Für Benutzer sichtbare Beschriftung (optional)",
   "entities.customFields.editor.options": "Optionen",
@@ -119,17 +118,6 @@
   "entities.customFields.editor.unassignedFields": "Nicht zugewiesene Felder",
   "entities.customFields.editor.unitsOptional": "Einheiten (optional)",
   "entities.customFields.editor.unitsPlaceholder": "kg, cm usw.",
-  "entities.customFields.editor.validation.date": "Datum",
-  "entities.customFields.editor.validation.eq": "gleich",
-  "entities.customFields.editor.validation.float": "Gleitkommazahl",
-  "entities.customFields.editor.validation.gt": "größer als",
-  "entities.customFields.editor.validation.gte": "größer oder gleich",
-  "entities.customFields.editor.validation.integer": "Ganzzahl",
-  "entities.customFields.editor.validation.lt": "kleiner als",
-  "entities.customFields.editor.validation.lte": "kleiner oder gleich",
-  "entities.customFields.editor.validation.ne": "ungleich",
-  "entities.customFields.editor.validation.regex": "Regex",
-  "entities.customFields.editor.validation.required": "erforderlich",
   "entities.customFields.editor.validationRules": "Validierungsregeln",
   "entities.customFields.editor.value": "Wert",
   "entities.customFields.editor.valueRequired": "Der Wert ist erforderlich",
@@ -195,28 +183,6 @@
   "entities.nav.systemEntities": "Systementitäten",
   "entities.nav.userEntities": "Benutzerentitäten",
   "entities.nav.userEntities.create": "Entität erstellen",
-  "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",
-  "entities.userEntities.edit.errors.invalidEntityTitle": "Ungültige Entität",
-  "entities.userEntities.edit.errors.loadDefinitionsFailed": "Entitätsdefinitionen konnten nicht geladen werden",
-  "entities.userEntities.edit.errors.loadFailed": "Laden fehlgeschlagen",
-  "entities.userEntities.edit.errors.loadMetadataFailed": "Entitätsmetadaten konnten nicht geladen werden",
-  "entities.userEntities.edit.errors.reloadDefinitionsFailed": "Felddefinitionen konnten nicht neu geladen werden",
-  "entities.userEntities.edit.errors.restoreFieldFailed": "Feld konnte nicht wiederhergestellt werden",
-  "entities.userEntities.edit.errors.saveEntityFailed": "Entität konnte nicht gespeichert werden",
-  "entities.userEntities.edit.errors.saveOrderFailed": "Reihenfolge konnte nicht gespeichert werden",
-  "entities.userEntities.edit.errors.validationFailed": "Validierung fehlgeschlagen",
-  "entities.userEntities.edit.fieldsetTitle": "Feldgruppe bearbeiten: {{name}}",
-  "entities.userEntities.edit.flash.entityDeleted": "Entität gelöscht",
-  "entities.userEntities.edit.flash.orderSaved": "Reihenfolge gespeichert",
-  "entities.userEntities.edit.flash.restoredField": "{{key}} wiederhergestellt",
-  "entities.userEntities.edit.groups.definitions": "Felddefinitionen",
-  "entities.userEntities.edit.groups.settings": "Entitätseinstellungen",
-  "entities.userEntities.edit.orderNotice": "Neu angeordnet - wird beim Verlassen gespeichert",
-  "entities.userEntities.edit.pageTitle": "Definitionen bearbeiten",
-  "entities.userEntities.edit.showRecords": "Datensätze anzeigen",
-  "entities.userEntities.edit.title": "Entität bearbeiten: {{entityId}}",
   "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",

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

@@ -93,7 +93,6 @@
   "entities.customFields.editor.noFieldsets": "No fieldsets defined yet. Fieldsets let you group custom fields for different variants of the same entity (e.g., Fashion vs. Sport products).",
   "entities.customFields.editor.noGroup": "No group",
   "entities.customFields.editor.noOptionsDefined": "No options defined.",
-  "entities.customFields.editor.noParameterPlaceholder": "-",
   "entities.customFields.editor.noValidationRules": "No validation rules defined.",
   "entities.customFields.editor.optionLabelPlaceholder": "Label shown to users (optional)",
   "entities.customFields.editor.options": "Options",
@@ -119,17 +118,6 @@
   "entities.customFields.editor.unassignedFields": "Unassigned fields",
   "entities.customFields.editor.unitsOptional": "Units (optional)",
   "entities.customFields.editor.unitsPlaceholder": "kg, cm, etc.",
-  "entities.customFields.editor.validation.date": "date",
-  "entities.customFields.editor.validation.eq": "eq",
-  "entities.customFields.editor.validation.float": "float",
-  "entities.customFields.editor.validation.gt": "gt",
-  "entities.customFields.editor.validation.gte": "gte",
-  "entities.customFields.editor.validation.integer": "integer",
-  "entities.customFields.editor.validation.lt": "lt",
-  "entities.customFields.editor.validation.lte": "lte",
-  "entities.customFields.editor.validation.ne": "ne",
-  "entities.customFields.editor.validation.regex": "regex",
-  "entities.customFields.editor.validation.required": "required",
   "entities.customFields.editor.validationRules": "Validation rules",
   "entities.customFields.editor.value": "Value",
   "entities.customFields.editor.valueRequired": "Value is required",
@@ -195,28 +183,6 @@
   "entities.nav.systemEntities": "System Entities",
   "entities.nav.userEntities": "User Entities",
   "entities.nav.userEntities.create": "Create Entity",
-  "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",
-  "entities.userEntities.edit.errors.invalidEntityTitle": "Invalid entity",
-  "entities.userEntities.edit.errors.loadDefinitionsFailed": "Failed to load entity definitions",
-  "entities.userEntities.edit.errors.loadFailed": "Failed to load",
-  "entities.userEntities.edit.errors.loadMetadataFailed": "Failed to load entity metadata",
-  "entities.userEntities.edit.errors.reloadDefinitionsFailed": "Failed to reload field definitions",
-  "entities.userEntities.edit.errors.restoreFieldFailed": "Failed to restore field",
-  "entities.userEntities.edit.errors.saveEntityFailed": "Failed to save entity",
-  "entities.userEntities.edit.errors.saveOrderFailed": "Failed to save order",
-  "entities.userEntities.edit.errors.validationFailed": "Validation failed",
-  "entities.userEntities.edit.fieldsetTitle": "Edit fieldset: {{name}}",
-  "entities.userEntities.edit.flash.entityDeleted": "Entity deleted",
-  "entities.userEntities.edit.flash.orderSaved": "Order saved",
-  "entities.userEntities.edit.flash.restoredField": "Restored {{key}}",
-  "entities.userEntities.edit.groups.definitions": "Field Definitions",
-  "entities.userEntities.edit.groups.settings": "Entity Settings",
-  "entities.userEntities.edit.orderNotice": "Reordered - will auto-save on blur",
-  "entities.userEntities.edit.pageTitle": "Edit definitions",
-  "entities.userEntities.edit.showRecords": "Show Records",
-  "entities.userEntities.edit.title": "Edit Entity: {{entityId}}",
   "entities.userEntities.errors.entityIdExists": "Entity ID already exists",
   "entities.userEntities.errors.entityIdRequired": "Entity ID is required",
   "entities.userEntities.errors.loadFailed": "Failed to load entities",

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

@@ -93,7 +93,6 @@
   "entities.customFields.editor.noFieldsets": "Aún no se han definido conjuntos de campos. Los conjuntos de campos permiten agrupar campos personalizados para distintas variantes de la misma entidad (p. ej. productos de Moda vs. Deporte).",
   "entities.customFields.editor.noGroup": "Sin grupo",
   "entities.customFields.editor.noOptionsDefined": "No se han definido opciones.",
-  "entities.customFields.editor.noParameterPlaceholder": "-",
   "entities.customFields.editor.noValidationRules": "No se han definido reglas de validación.",
   "entities.customFields.editor.optionLabelPlaceholder": "Etiqueta visible para los usuarios (opcional)",
   "entities.customFields.editor.options": "Opciones",
@@ -119,17 +118,6 @@
   "entities.customFields.editor.unassignedFields": "Campos sin asignar",
   "entities.customFields.editor.unitsOptional": "Unidades (opcional)",
   "entities.customFields.editor.unitsPlaceholder": "kg, cm, etc.",
-  "entities.customFields.editor.validation.date": "fecha",
-  "entities.customFields.editor.validation.eq": "igual",
-  "entities.customFields.editor.validation.float": "decimal",
-  "entities.customFields.editor.validation.gt": "mayor que",
-  "entities.customFields.editor.validation.gte": "mayor o igual",
-  "entities.customFields.editor.validation.integer": "entero",
-  "entities.customFields.editor.validation.lt": "menor que",
-  "entities.customFields.editor.validation.lte": "menor o igual",
-  "entities.customFields.editor.validation.ne": "distinto",
-  "entities.customFields.editor.validation.regex": "regex",
-  "entities.customFields.editor.validation.required": "obligatorio",
   "entities.customFields.editor.validationRules": "Reglas de validación",
   "entities.customFields.editor.value": "Valor",
   "entities.customFields.editor.valueRequired": "El valor es obligatorio",
@@ -195,28 +183,6 @@
   "entities.nav.systemEntities": "Entidades del sistema",
   "entities.nav.userEntities": "Entidades de usuario",
   "entities.nav.userEntities.create": "Crear entidad",
-  "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",
-  "entities.userEntities.edit.errors.invalidEntityTitle": "Entidad no válida",
-  "entities.userEntities.edit.errors.loadDefinitionsFailed": "No se pudieron cargar las definiciones de la entidad",
-  "entities.userEntities.edit.errors.loadFailed": "No se pudo cargar",
-  "entities.userEntities.edit.errors.loadMetadataFailed": "No se pudieron cargar los metadatos de la entidad",
-  "entities.userEntities.edit.errors.reloadDefinitionsFailed": "No se pudieron recargar las definiciones de campos",
-  "entities.userEntities.edit.errors.restoreFieldFailed": "No se pudo restaurar el campo",
-  "entities.userEntities.edit.errors.saveEntityFailed": "No se pudo guardar la entidad",
-  "entities.userEntities.edit.errors.saveOrderFailed": "No se pudo guardar el orden",
-  "entities.userEntities.edit.errors.validationFailed": "La validación falló",
-  "entities.userEntities.edit.fieldsetTitle": "Editar conjunto: {{name}}",
-  "entities.userEntities.edit.flash.entityDeleted": "Entidad eliminada",
-  "entities.userEntities.edit.flash.orderSaved": "Orden guardado",
-  "entities.userEntities.edit.flash.restoredField": "{{key}} restaurado",
-  "entities.userEntities.edit.groups.definitions": "Definiciones de campos",
-  "entities.userEntities.edit.groups.settings": "Configuración de la entidad",
-  "entities.userEntities.edit.orderNotice": "Reordenado - se guardará al salir del campo",
-  "entities.userEntities.edit.pageTitle": "Editar definiciones",
-  "entities.userEntities.edit.showRecords": "Mostrar registros",
-  "entities.userEntities.edit.title": "Editar entidad: {{entityId}}",
   "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",