@asteby/metacore-runtime-react 32.0.0 → 32.1.0

package/src/validation-catalog.ts

@@ -0,0 +1,60 @@
+/** Laravel-style validation catalogs. Hosts override any key via i18next
+ *  `validation.<code>`; these are the defaults when the key is missing, picked
+ *  by the operator's language (es by default — the product language). */
+
+export const VALIDATION_CATALOGS: Record<string, Record<string, string>> = {
+    es: {
+        failed: 'Revisa los campos marcados',
+        required: 'El campo {{label}} es obligatorio',
+        invalid_option: 'El valor de {{label}} no es válido',
+        not_found: 'El {{label}} seleccionado no existe',
+        duplicate: 'Ya existe un registro con ese {{label}}',
+        invalid_type: 'El campo {{label}} tiene un formato inválido',
+        min: 'El campo {{label}} debe ser al menos {{min}}',
+        min_length: '{{label}} debe tener al menos {{min}} caracteres',
+        max: 'El campo {{label}} no puede ser mayor que {{max}}',
+        max_length: '{{label}} no puede tener más de {{max}} caracteres',
+        regex: 'El formato de {{label}} no es válido',
+        email: '{{label}} debe ser un correo válido',
+        uuid: '{{label}} no es un identificador válido',
+        url: '{{label}} debe ser una URL válida',
+        numeric: '{{label}} debe ser un número',
+        integer: '{{label}} debe ser un entero',
+        custom: '{{label}} no es válido',
+        line_items_required: '{{label}} requiere al menos un renglón',
+        fallback: '{{label}}: valor inválido',
+    },
+    en: {
+        failed: 'Please check the highlighted fields',
+        required: 'The {{label}} field is required',
+        invalid_option: 'The selected {{label}} is invalid',
+        not_found: 'The selected {{label}} does not exist',
+        duplicate: 'A record with that {{label}} already exists',
+        invalid_type: 'The {{label}} field has an invalid format',
+        min: 'The {{label}} must be at least {{min}}',
+        min_length: 'The {{label}} must be at least {{min}} characters',
+        max: 'The {{label}} may not be greater than {{max}}',
+        max_length: 'The {{label}} may not be greater than {{max}} characters',
+        regex: 'The {{label}} format is invalid',
+        email: 'The {{label}} must be a valid email address',
+        uuid: 'The {{label}} is not a valid identifier',
+        url: 'The {{label}} must be a valid URL',
+        numeric: 'The {{label}} must be a number',
+        integer: 'The {{label}} must be an integer',
+        custom: 'The {{label}} is invalid',
+        line_items_required: '{{label}} requires at least one row',
+        fallback: '{{label}}: invalid value',
+    },
+}
+
+export function validationCatalog(language?: string): Record<string, string> {
+    const short = (language ?? 'es').split(/[-_]/)[0]!.toLowerCase()
+    return VALIDATION_CATALOGS[short] ?? VALIDATION_CATALOGS.es!
+}
+
+/** Pick the catalog key for a code, folding min/max + kind=length into *_length. */
+export function validationMessageKey(code: string, params?: Record<string, unknown>): string {
+    if (code === 'min' && params?.kind === 'length') return 'min_length'
+    if (code === 'max' && params?.kind === 'length') return 'max_length'
+    return code
+}

package/src/validator.ts

@@ -0,0 +1,275 @@
+// Client-side twin of kernel `validate`: Laravel / go-playground rule strings
+// plus the structured {regex,min,max,custom} object. Produces the same
+// {code, params} issues the 422 envelope carries, so UI and server paint
+// the same keys.
+import type { ActionFieldDef, FieldValidation } from './types'
+import type { FieldIssue } from './server-error'
+
+const NIL_UUID = '00000000-0000-0000-0000-000000000000'
+const NUMERIC_TYPES = new Set(['int', 'integer', 'bigint', 'decimal', 'numeric', 'number', 'float', 'double'])
+
+export interface ValidationSpec {
+    required?: boolean
+    type?: string
+    regex?: string
+    min?: number
+    max?: number
+    custom?: string
+    options?: string[]
+}
+
+const RULE_NAMES = new Set([
+    'required', 'nullable', 'sometimes', 'present',
+    'min', 'max', 'regex', 'email', 'uuid', 'url',
+    'numeric', 'integer', 'int', 'in',
+])
+
+/** Parse `required|min:2|email` or `required,min=2,max=100` or a custom slug. */
+export function parseRuleString(s: string): ValidationSpec {
+    const spec: ValidationSpec = {}
+    const trimmed = s.trim()
+    if (!trimmed) return spec
+    for (const part of splitRules(trimmed)) {
+        const { name, param } = splitNameParam(part)
+        switch (name.toLowerCase()) {
+            case 'required':
+                spec.required = true
+                break
+            case 'min': {
+                const n = Number(param)
+                if (!Number.isNaN(n)) spec.min = n
+                break
+            }
+            case 'max': {
+                const n = Number(param)
+                if (!Number.isNaN(n)) spec.max = n
+                break
+            }
+            case 'regex':
+                spec.regex = trimLaravelRegex(param)
+                break
+            case 'email':
+            case 'uuid':
+            case 'url':
+            case 'numeric':
+            case 'integer':
+                spec.custom = name.toLowerCase()
+                break
+            case 'int':
+                spec.custom = 'integer'
+                break
+            case 'in':
+                spec.options = param.split(',').map(x => x.trim()).filter(Boolean)
+                break
+            default:
+                if (!spec.custom) spec.custom = part
+        }
+    }
+    return spec
+}
+
+function splitRules(s: string): string[] {
+    if (s.includes('|')) return s.split('|').map(x => x.trim()).filter(Boolean)
+    const raw = s.split(',')
+    const out: string[] = []
+    for (const p of raw) {
+        const part = p.trim()
+        if (!part) continue
+        const { name } = splitNameParam(part)
+        if (!RULE_NAMES.has(name.toLowerCase()) && out.length) {
+            const prev = splitNameParam(out[out.length - 1]!).name
+            if (prev.toLowerCase() === 'in') {
+                out[out.length - 1] += `,${part}`
+                continue
+            }
+        }
+        out.push(part)
+    }
+    return out
+}
+
+function splitNameParam(p: string): { name: string; param: string } {
+    const colon = p.indexOf(':')
+    const eq = p.indexOf('=')
+    const i = colon >= 0 && (eq < 0 || colon < eq) ? colon : eq
+    if (i < 0) return { name: p.trim(), param: '' }
+    return { name: p.slice(0, i).trim(), param: p.slice(i + 1).trim() }
+}
+
+function trimLaravelRegex(p: string): string {
+    if (p.length >= 2 && p.startsWith('/') && p.lastIndexOf('/') > 0) {
+        return p.slice(1, p.lastIndexOf('/'))
+    }
+    return p
+}
+
+/** Normalize ActionFieldDef.validation (object, laravel string, or `rules`). */
+export function fieldValidationOf(field: ActionFieldDef | Record<string, unknown>): FieldValidation {
+    const rec = field as Record<string, unknown>
+    const raw = rec.validation ?? rec.rules ?? rec.validation_rule
+    if (!raw) return {}
+    if (typeof raw === 'string') {
+        const s = parseRuleString(raw)
+        return { regex: s.regex, min: s.min, max: s.max, custom: s.custom }
+    }
+    if (typeof raw === 'object' && !Array.isArray(raw)) return raw as FieldValidation
+    return {}
+}
+
+function isEmpty(raw: unknown): boolean {
+    if (raw == null) return true
+    if (typeof raw === 'string') {
+        const t = raw.trim()
+        return t === '' || t === NIL_UUID
+    }
+    if (Array.isArray(raw)) return raw.length === 0
+    return false
+}
+
+function asString(raw: unknown): string {
+    if (raw == null) return ''
+    return String(raw).trim()
+}
+
+function isNumeric(raw: unknown): boolean {
+    if (typeof raw === 'number' && Number.isFinite(raw)) return true
+    if (typeof raw === 'string') return raw.trim() !== '' && !Number.isNaN(Number(raw))
+    return false
+}
+
+function numericValue(raw: unknown): number {
+    return typeof raw === 'number' ? raw : Number(asString(raw))
+}
+
+function lengthOf(raw: unknown): number {
+    if (typeof raw === 'string') return [...raw.trim()].length
+    if (Array.isArray(raw)) return raw.length
+    return [...asString(raw)].length
+}
+
+/** Evaluate spec against one value; collect every issue (not fail-fast). */
+export function checkValue(value: unknown, spec: ValidationSpec): FieldIssue[] {
+    const empty = isEmpty(value)
+    if (spec.required && empty) return [{ code: 'required' }]
+    if (empty) return []
+    const out: FieldIssue[] = []
+    const typ = (spec.type ?? '').toLowerCase()
+    if (NUMERIC_TYPES.has(typ) && !isNumeric(value)) {
+        out.push({ code: 'invalid_type', params: { expected: 'number' } })
+        return out
+    }
+    if (spec.options && spec.options.length) {
+        const want = asString(value)
+        if (!spec.options.includes(want)) {
+            out.push({ code: 'invalid_option', params: { allowed: spec.options } })
+        }
+    }
+    if (spec.regex) {
+        try {
+            if (!new RegExp(spec.regex).test(asString(value))) {
+                out.push({ code: 'regex', params: { pattern: spec.regex } })
+            }
+        } catch { /* malformed — skip */ }
+    }
+    if (spec.min != null || spec.max != null) {
+        const isNum = NUMERIC_TYPES.has(typ)
+        const kind = isNum ? 'value' : 'length'
+        const n = isNum ? numericValue(value) : lengthOf(value)
+        if (spec.min != null && n < spec.min) out.push({ code: 'min', params: { min: spec.min, kind } })
+        if (spec.max != null && n > spec.max) out.push({ code: 'max', params: { max: spec.max, kind } })
+    }
+    if (spec.custom) {
+        const custom = checkBuiltin(spec.custom, value)
+        if (custom) out.push(custom)
+    }
+    return out
+}
+
+function checkBuiltin(slug: string, value: unknown): FieldIssue | undefined {
+    const s = asString(value)
+    switch (slug) {
+        case 'email':
+            return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(s) ? undefined : { code: 'email' }
+        case 'uuid':
+            return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(s)
+                ? undefined : { code: 'uuid' }
+        case 'url':
+            try { const u = new URL(s); return u.protocol && u.host ? undefined : { code: 'url' } }
+            catch { return { code: 'url' } }
+        case 'numeric':
+            return isNumeric(value) ? undefined : { code: 'numeric', params: { expected: 'number' } }
+        case 'integer':
+        case 'int':
+            return /^-?\d+$/.test(s) || (typeof value === 'number' && Number.isInteger(value))
+                ? undefined : { code: 'integer', params: { expected: 'integer' } }
+        default:
+            return undefined
+    }
+}
+
+function specFromField(field: ActionFieldDef): ValidationSpec {
+    const v = fieldValidationOf(field)
+    const spec: ValidationSpec = {
+        required: !!field.required,
+        type: field.type,
+        regex: v.regex,
+        min: v.min,
+        max: v.max,
+        custom: v.custom,
+    }
+    if (field.options?.length) spec.options = field.options.map(o => String(o.value))
+    return spec
+}
+
+function isLineItems(field: ActionFieldDef): boolean {
+    const raw = field.itemFields ?? (field as { item_fields?: ActionFieldDef[] }).item_fields
+    return Array.isArray(raw) && raw.length > 0
+}
+
+function itemFieldsOf(field: ActionFieldDef): ActionFieldDef[] {
+    const raw = field.itemFields ?? (field as { item_fields?: ActionFieldDef[] }).item_fields
+    return Array.isArray(raw) ? raw : []
+}
+
+/** Validate a form payload the way Laravel's Validator does: collect every
+ *  field issue, dotted keys for line-items (`items.0.qty`). */
+export function validateValues(
+    fields: readonly ActionFieldDef[],
+    values: Record<string, unknown>,
+): Record<string, FieldIssue[]> {
+    const bag: Record<string, FieldIssue[]> = {}
+    walk(fields, values ?? {}, '', bag)
+    return bag
+}
+
+function walk(
+    fields: readonly ActionFieldDef[],
+    values: Record<string, unknown>,
+    prefix: string,
+    bag: Record<string, FieldIssue[]>,
+): void {
+    for (const field of fields) {
+        const key = field.key
+        if (!key) continue
+        const path = prefix ? `${prefix}.${key}` : key
+        const raw = values[key]
+        if (isLineItems(field)) {
+            const rows = Array.isArray(raw) ? raw : []
+            if (field.required && rows.length === 0) {
+                bag[path] = [{ code: 'line_items_required' }]
+                continue
+            }
+            rows.forEach((row, i) => {
+                const obj = row && typeof row === 'object' ? (row as Record<string, unknown>) : {}
+                walk(itemFieldsOf(field), obj, `${path}.${i}`, bag)
+            })
+            continue
+        }
+        const issues = checkValue(raw, specFromField(field))
+        if (issues.length) bag[path] = issues
+    }
+}
+
+export function bagHasErrors(bag: Record<string, FieldIssue[]>): boolean {
+    return Object.keys(bag).length > 0
+}