@open-mercato/core 0.6.6 → 0.6.7-develop.6553.1.2ec7246e04

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: 'Failed to load entity metadata', fallback: { items: [] } },
+          { errorMessage: t('entities.userEntities.edit.errors.loadMetadataFailed', '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: 'Failed to load entity definitions', fallback: { items: [], deletedKeys: [] } },
+          { errorMessage: t('entities.userEntities.edit.errors.loadDefinitionsFailed', '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 || 'Failed to load')
+        if (mounted) setError(e.message || t('entities.userEntities.edit.errors.loadFailed', 'Failed to load'))
       } finally {
         if (mounted) setLoading(false)
       }
     }
     if (entityId) load()
     return () => { mounted = false }
-  }, [entityId])
+  }, [entityId, t])
 
   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, 'Failed to restore field')
+        await raiseCrudError(call.response, t('entities.userEntities.edit.errors.restoreFieldFailed', 'Failed to restore field'))
       }
       // Reload definitions & deleted keys
       const j2 = await readApiResultOrThrow<DefinitionsManageResponse>(
         `/api/entities/definitions.manage?entityId=${encodeURIComponent(entityId)}`,
         undefined,
-        { errorMessage: 'Failed to reload field definitions', fallback: { items: [], deletedKeys: [] } },
+        { errorMessage: t('entities.userEntities.edit.errors.reloadDefinitionsFailed', '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(`Restored ${key}`, 'success')
+      flash(t('entities.userEntities.edit.flash.restoredField', 'Restored {{key}}', { key }), 'success')
       await invalidateCustomFieldDefs(queryClient, entityId)
     } catch (e: any) {
-      flash(e?.message || 'Failed to restore field', 'error')
+      flash(e?.message || t('entities.userEntities.edit.errors.restoreFieldFailed', 'Failed to restore field'), 'error')
     }
   }
 
@@ -276,8 +276,8 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
     setError(null)
     try {
       if (!validateAll()) {
-        flash('Please fix validation errors in field definitions', 'error')
-        throw new Error('Validation failed')
+        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'))
       }
       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, 'Failed to save definitions')
+        await raiseCrudError(call.response, t('entities.customFields.errors.saveFailed', 'Failed to save field definitions.'))
       }
       setDefsVersion(readVersionToken(call.result?.version))
       await invalidateCustomFieldDefs(queryClient, entityId)
-      router.push(`/backend/entities/user?flash=Definitions%20saved&type=success`)
+      router.push(`/backend/entities/user?flash=${encodeURIComponent(t('entities.customFields.flash.saved', 'Definitions saved'))}&type=success`)
     } catch (e: any) {
-      setError(e.message || 'Failed to save')
+      setError(e.message || t('entities.customFields.errors.saveFailed', 'Failed to save field definitions.'))
     } 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, 'Failed to delete field')
+          await raiseCrudError(call.response, t('entities.customFields.errors.deleteFailed', '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 : 'Failed to delete field'
+        const message = error instanceof Error ? error.message : t('entities.customFields.errors.deleteFailed', '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('Validation failed')
+      if (!validateAll()) throw new Error(t('entities.userEntities.edit.errors.validationFailed', '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, 'Failed to save order')
+        await raiseCrudError(call.response, t('entities.userEntities.edit.errors.saveOrderFailed', 'Failed to save order'))
       }
       setDefsVersion(readVersionToken(call.result?.version))
       setOrderDirty(false)
-      flash('Order saved', 'success')
+      flash(t('entities.userEntities.edit.flash.orderSaved', 'Order saved'), 'success')
       await invalidateCustomFieldDefs(queryClient, entityId)
     } catch (e: any) {
-      flash(e?.message || 'Failed to save order', 'error')
+      flash(e?.message || t('entities.userEntities.edit.errors.saveOrderFailed', '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: 'Label', type: 'text', required: true, readOnly: metadataFieldsReadOnly },
-    { id: 'description', label: 'Description', type: 'textarea', readOnly: metadataFieldsReadOnly },
+    { 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: 'defaultEditor',
-      label: 'Default Editor (multiline)',
+      label: t('entities.userEntities.form.defaultEditor.label', 'Default Editor (multiline)'),
       type: 'select',
       readOnly: metadataFieldsReadOnly,
       options: [
-        { value: '', label: 'Default (Markdown)' },
-        { value: 'markdown', label: 'Markdown (UIW)' },
-        { value: 'simpleMarkdown', label: 'Simple Markdown' },
-        { value: 'htmlRichText', label: 'HTML Rich Text' },
+        { 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') },
       ],
     } as any,
-    ...(entitySource === 'custom' ? [{ id: 'showInSidebar', label: 'Show in sidebar', type: 'checkbox' }] : []),
+    ...(entitySource === 'custom' ? [{ id: 'showInSidebar', label: t('entities.userEntities.form.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: 'Reordered — will auto-save on blur' } : undefined}
+        orderNotice={orderDirty ? { dirty: true, saving: orderSaving, message: t('entities.userEntities.edit.orderNotice', '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])
+  [defs, defErrors, deletedKeys, fieldsets, activeFieldset, singleFieldsetPerRecord, orderDirty, orderSaving, addField, removeField, restoreField, saveOrderIfDirty, t])
 
-  const definitionsGroup: CrudFormGroup = { id: 'definitions', title: 'Field Definitions', column: 1, component: renderFieldDefinitions }
+  const definitionsGroup: CrudFormGroup = { id: 'definitions', title: t('entities.userEntities.edit.groups.definitions', 'Field Definitions'), column: 1, component: renderFieldDefinitions }
 
   const groups: CrudFormGroup[] = [
-    { id: 'settings', title: 'Entity Settings', column: 1, fields: entitySource === 'custom' ? ['label','description','defaultEditor','showInSidebar'] : ['label','description','defaultEditor'] },
+    { id: 'settings', title: t('entities.userEntities.edit.groups.settings', '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('Invalid entity ID')
+      throw createCrudFormError(t('entities.userEntities.edit.errors.invalidEntityId', 'Invalid entity ID'))
     }
     if (!validateAll()) {
-      flash('Please fix validation errors in field definitions', 'error')
-      throw createCrudFormError('Please fix validation errors in field definitions')
+      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.'))
     }
     // 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('Validation failed')
+      if (!entityPayload) throw createCrudFormError(t('entities.userEntities.edit.errors.validationFailed', '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, 'Failed to save entity')
+        await raiseCrudError(callEntity.response, t('entities.userEntities.edit.errors.saveEntityFailed', '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, 'Failed to save definitions')
+      await raiseCrudError(callDefs.response, t('entities.customFields.errors.saveFailed', 'Failed to save field definitions.'))
     }
     setDefsVersion(readVersionToken(callDefs.result?.version))
     try { window.dispatchEvent(new Event('om:refresh-sidebar')) } catch {}
     await invalidateCustomFieldDefs(queryClient, entityId)
-    flash('Definitions saved', 'success')
-  }, [buildFieldsetPayload, defs, defsVersion, entityId, entitySource, queryClient, singleFieldsetPerRecord, validateAll])
+    flash(t('entities.customFields.flash.saved', 'Definitions saved'), 'success')
+  }, [buildFieldsetPayload, defs, defsVersion, entityId, entitySource, queryClient, singleFieldsetPerRecord, t, validateAll])
 
   if (!entityId) {
     return (
@@ -557,8 +557,8 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
         <PageBody>
           <div className="p-6">
             <Alert variant="destructive">
-              <AlertTitle>Invalid entity</AlertTitle>
-              <AlertDescription>The requested entity ID is missing or invalid.</AlertDescription>
+              <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>
             </Alert>
           </div>
         </PageBody>
@@ -571,12 +571,12 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       <div className="p-4">
         <CrudForm
           schema={entityFormSchema}
-          title={`Edit fieldset: ${requestedFieldset ?? entityId}`}
+          title={t('entities.userEntities.edit.fieldsetTitle', 'Edit fieldset: {{name}}', { name: requestedFieldset ?? entityId })}
           fields={[]}
           groups={[definitionsGroup]}
           initialValues={entityInitial as any}
           isLoading={entityFormLoading || loading}
-          submitLabel="Save"
+          submitLabel={t('entities.userEntities.records.form.submitSave', 'Save')}
           deleteVisible={false}
           backHref={undefined}
           cancelHref={undefined}
@@ -592,30 +592,32 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       <PageBody>
         <CrudForm
           schema={entityFormSchema}
-          title={`Edit Entity: ${entityId}`}
+          title={t('entities.userEntities.edit.title', 'Edit Entity: {{entityId}}', { entityId })}
           backHref={entitySource === 'code' ? "/backend/entities/system" : "/backend/entities/user"}
           fields={fields}
           groups={groups}
           initialValues={entityInitial as any}
           isLoading={entityFormLoading || loading}
-          submitLabel="Save"
+          submitLabel={t('entities.userEntities.records.form.submitSave', 'Save')}
           deleteVisible={entitySource === 'custom'}
           extraActions={entitySource === 'custom' ? (
             <Button variant="outline" asChild>
               <Link href={`/backend/entities/user/${encodeURIComponent(entityId)}/records`}>
-                Show Records
+                {t('entities.userEntities.edit.showRecords', 'Show Records')}
               </Link>
             </Button>
           ) : null}
           cancelHref={entitySource === 'code' ? "/backend/entities/system" : "/backend/entities/user"}
-          successRedirect={entitySource === 'code' ? "/backend/entities/system?flash=Definitions%20saved&type=success" : "/backend/entities/user?flash=Definitions%20saved&type=success"}
+          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`}
           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, 'Failed to delete entity')
+            await raiseCrudError(callDelete.response, t('entities.userEntities.edit.errors.deleteEntityFailed', 'Failed to delete entity'))
           }
-          flash('Entity deleted', 'success')
+          flash(t('entities.userEntities.edit.flash.entityDeleted', 'Entity deleted'), 'success')
           try { window.dispatchEvent(new Event('om:refresh-sidebar')) } catch {}
         } : undefined}
       />

package/src/modules/entities/cli.ts

@@ -10,6 +10,7 @@ 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,
@@ -193,7 +194,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 = raw.split(',').map((s) => s.trim()).filter(Boolean)
+        options = parseCommaSeparatedList(raw)
       }
       let defaultValue: any = undefined
       const defRaw = (args.default as string) ?? (args.defaultValue as string)

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

@@ -93,6 +93,7 @@
   "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",
@@ -118,6 +119,17 @@
   "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",
@@ -183,6 +195,28 @@
   "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,6 +93,7 @@
   "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",
@@ -118,6 +119,17 @@
   "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",
@@ -183,6 +195,28 @@
   "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,6 +93,7 @@
   "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",
@@ -118,6 +119,17 @@
   "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",
@@ -183,6 +195,28 @@
   "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",

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

@@ -93,6 +93,7 @@
   "entities.customFields.editor.noFieldsets": "Nie zdefiniowano jeszcze zestawów pól. Zestawy pól pozwalają grupować pola niestandardowe dla różnych wariantów tej samej encji (np. produkty Moda vs Sport).",
   "entities.customFields.editor.noGroup": "Bez grupy",
   "entities.customFields.editor.noOptionsDefined": "Nie zdefiniowano opcji.",
+  "entities.customFields.editor.noParameterPlaceholder": "-",
   "entities.customFields.editor.noValidationRules": "Nie zdefiniowano reguł walidacji.",
   "entities.customFields.editor.optionLabelPlaceholder": "Etykieta widoczna dla użytkowników (opcjonalnie)",
   "entities.customFields.editor.options": "Opcje",
@@ -118,6 +119,17 @@
   "entities.customFields.editor.unassignedFields": "Pola nieprzypisane",
   "entities.customFields.editor.unitsOptional": "Jednostki (opcjonalnie)",
   "entities.customFields.editor.unitsPlaceholder": "kg, cm itp.",
+  "entities.customFields.editor.validation.date": "data",
+  "entities.customFields.editor.validation.eq": "równe",
+  "entities.customFields.editor.validation.float": "liczba zmiennoprzecinkowa",
+  "entities.customFields.editor.validation.gt": "większe niż",
+  "entities.customFields.editor.validation.gte": "większe lub równe",
+  "entities.customFields.editor.validation.integer": "liczba całkowita",
+  "entities.customFields.editor.validation.lt": "mniejsze niż",
+  "entities.customFields.editor.validation.lte": "mniejsze lub równe",
+  "entities.customFields.editor.validation.ne": "różne",
+  "entities.customFields.editor.validation.regex": "regex",
+  "entities.customFields.editor.validation.required": "wymagane",
   "entities.customFields.editor.validationRules": "Reguły walidacji",
   "entities.customFields.editor.value": "Wartość",
   "entities.customFields.editor.valueRequired": "Wartość jest wymagana",
@@ -183,6 +195,28 @@
   "entities.nav.systemEntities": "Encje systemowe",
   "entities.nav.userEntities": "Encje użytkownika",
   "entities.nav.userEntities.create": "Utwórz encję",
+  "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",
+  "entities.userEntities.edit.errors.invalidEntityTitle": "Nieprawidłowa encja",
+  "entities.userEntities.edit.errors.loadDefinitionsFailed": "Nie udało się wczytać definicji encji",
+  "entities.userEntities.edit.errors.loadFailed": "Nie udało się wczytać",
+  "entities.userEntities.edit.errors.loadMetadataFailed": "Nie udało się wczytać metadanych encji",
+  "entities.userEntities.edit.errors.reloadDefinitionsFailed": "Nie udało się ponownie wczytać definicji pól",
+  "entities.userEntities.edit.errors.restoreFieldFailed": "Nie udało się przywrócić pola",
+  "entities.userEntities.edit.errors.saveEntityFailed": "Nie udało się zapisać encji",
+  "entities.userEntities.edit.errors.saveOrderFailed": "Nie udało się zapisać kolejności",
+  "entities.userEntities.edit.errors.validationFailed": "Walidacja nie powiodła się",
+  "entities.userEntities.edit.fieldsetTitle": "Edytuj zestaw pól: {{name}}",
+  "entities.userEntities.edit.flash.entityDeleted": "Encja została usunięta",
+  "entities.userEntities.edit.flash.orderSaved": "Kolejność została zapisana",
+  "entities.userEntities.edit.flash.restoredField": "Przywrócono {{key}}",
+  "entities.userEntities.edit.groups.definitions": "Definicje pól",
+  "entities.userEntities.edit.groups.settings": "Ustawienia encji",
+  "entities.userEntities.edit.orderNotice": "Zmieniono kolejność - zapisze się po opuszczeniu pola",
+  "entities.userEntities.edit.pageTitle": "Edytuj definicje",
+  "entities.userEntities.edit.showRecords": "Pokaż rekordy",
+  "entities.userEntities.edit.title": "Edytuj encję: {{entityId}}",
   "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",

package/src/modules/feature_toggles/api/check/boolean/route.ts

@@ -18,21 +18,6 @@ export async function GET(req: Request) {
         return NextResponse.json({ error: 'Missing required parameter: identifier' }, { status: 400 })
     }
 
-    if (auth.isSuperAdmin === true) {
-        return NextResponse.json({
-            ok: true,
-            value: true,
-            resolution: {
-                valueType: "boolean",
-                value: true,
-                source: "override",
-                toggleId: "superadmin",
-                identifier,
-                tenantId: "superadmin"
-            }
-        })
-    }
-
     const container = await createRequestContainer()
     const { scope } = await resolveFeatureCheckContext({
         container,

package/src/modules/feature_toggles/defaults.json

@@ -16,6 +16,14 @@
       "type": "string",
       "defaultValue": "Free shipping on orders over $50"
     },
+    {
+      "identifier": "sales_channels_enabled",
+      "name": "Sales Channels",
+      "description": "Show sales channel pickers, filters, and management UI. Disable for tenants that do not use sales channels.",
+      "category": "sales",
+      "type": "boolean",
+      "defaultValue": true
+    },
     {
       "identifier": "order_review_threshold",
       "name": "Order Review Threshold",