codeforms 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

codeforms/forms.py

@@ -1,9 +1,11 @@
+import json
+import re
+from typing import Any, Type
+
 from codeforms.fields import *
 from codeforms.fields import FieldGroup, FormStep
 from codeforms.i18n import t
-import json
-import re
-from typing import Any
+
 
 class Form(BaseModel):
     id: UUID = Field(default_factory=uuid4)
@@ -14,8 +16,8 @@ class Form(BaseModel):
     schema_version: Optional[int] = None  # Para compatibilidad entre versiones (RISK-5)
     attributes: Dict[str, str] = Field(default_factory=dict)
     action: Optional[str] = None
-    
-    @model_validator(mode='before')
+
+    @model_validator(mode="before")
     @classmethod
     def convert_fields_to_content(cls, data: Any) -> Any:
         """
@@ -25,20 +27,21 @@ class Form(BaseModel):
         """
         if isinstance(data, dict):
             # Si tiene 'fields' pero no 'content', convertir
-            if 'fields' in data and 'content' not in data:
+            if "fields" in data and "content" not in data:
                 data = data.copy()
-                data['content'] = data.pop('fields')
+                data["content"] = data.pop("fields")
             # Si tiene ambos, 'content' tiene prioridad
-            elif 'fields' in data and 'content' in data:
+            elif "fields" in data and "content" in data:
                 data = data.copy()
-                data.pop('fields')  # Remover 'fields' redundante
+                data.pop("fields")  # Remover 'fields' redundante
 
             # Resolver cada item del contenido usando el registry
-            if 'content' in data:
+            if "content" in data:
                 from codeforms.registry import resolve_content_item
+
                 data = data.copy() if data is not data else data
-                data['content'] = [
-                    resolve_content_item(item) for item in data['content']
+                data["content"] = [
+                    resolve_content_item(item) for item in data["content"]
                 ]
         return data
 
@@ -51,9 +54,9 @@ class Form(BaseModel):
         """
         all_fields = []
         for item in self.content:
-            if isinstance(item, FormStep):  # Es un FormStep (wizard)
-                all_fields.extend(item.fields)
-            elif isinstance(item, FieldGroup):  # Es un FieldGroup
+            if isinstance(item, FormStep) or isinstance(
+                item, FieldGroup
+            ):  # Es un FormStep (wizard)
                 all_fields.extend(item.fields)
             else:  # Es un campo individual
                 all_fields.append(item)
@@ -67,7 +70,7 @@ class Form(BaseModel):
             return Form.model_validate(form)
 
     @classmethod
-    def create_from_fields(cls, name: str, fields: List, **kwargs) -> 'Form':
+    def create_from_fields(cls, name: str, fields: List, **kwargs) -> "Form":
         """
         Método de conveniencia para crear un formulario usando la estructura anterior
         donde se pasaba directamente una lista de campos.
@@ -75,11 +78,11 @@ class Form(BaseModel):
         """
         return cls(name=name, content=fields, **kwargs)
 
-    def to_dict(self, exclude_none: bool=True) -> Dict[str, Any]:
+    def to_dict(self, exclude_none: bool = True) -> Dict[str, Any]:
         return json.loads(self.model_dump_json(exclude_none=exclude_none))
 
-    @model_validator(mode='after')
-    def validate_field_names(self) -> 'Form':
+    @model_validator(mode="after")
+    def validate_field_names(self) -> "Form":
         """Valida que todos los nombres de campos sean únicos en todo el formulario"""
         names = [field.name for field in self.fields]
         if len(names) != len(set(names)):
@@ -96,10 +99,12 @@ class Form(BaseModel):
 
             # Validar campo requerido
             if field.required and field_value is None:
-                errors.append({
-                    "field": field.name,
-                    "message": t("field.required_named", name=field.name)
-                })
+                errors.append(
+                    {
+                        "field": field.name,
+                        "message": t("field.required_named", name=field.name),
+                    }
+                )
                 continue
 
             # Validar según el tipo de campo
@@ -114,69 +119,129 @@ class Form(BaseModel):
                 try:
                     num_value = float(field_value)
                     if field.min_value is not None and num_value < field.min_value:
-                        errors.append({"field": field.name, "message": t("number.min_value", min=field.min_value)})
+                        errors.append(
+                            {
+                                "field": field.name,
+                                "message": t("number.min_value", min=field.min_value),
+                            }
+                        )
                     if field.max_value is not None and num_value > field.max_value:
-                        errors.append({"field": field.name, "message": t("number.max_value", max=field.max_value)})
+                        errors.append(
+                            {
+                                "field": field.name,
+                                "message": t("number.max_value", max=field.max_value),
+                            }
+                        )
                 except (ValueError, TypeError):
                     errors.append({"field": field.name, "message": t("number.invalid")})
             elif isinstance(field, DateField):
                 try:
                     date_value = date.fromisoformat(field_value)
                     if field.min_date is not None and date_value < field.min_date:
-                        errors.append({"field": field.name, "message": t("date.min_date", min=field.min_date)})
+                        errors.append(
+                            {
+                                "field": field.name,
+                                "message": t("date.min_date", min=field.min_date),
+                            }
+                        )
                     if field.max_date is not None and date_value > field.max_date:
-                        errors.append({"field": field.name, "message": t("date.max_date", max=field.max_date)})
+                        errors.append(
+                            {
+                                "field": field.name,
+                                "message": t("date.max_date", max=field.max_date),
+                            }
+                        )
                 except (ValueError, TypeError):
-                    errors.append({"field": field.name, "message": t("date.invalid_format")})
+                    errors.append(
+                        {"field": field.name, "message": t("date.invalid_format")}
+                    )
             elif isinstance(field, SelectField):
                 valid_options = [opt.value for opt in field.options]
                 if field.multiple:
-                    if not isinstance(field_value, list) or not all(v in valid_options for v in field_value):
-                        errors.append({"field": field.name, "message": t("select.invalid_options")})
+                    if not isinstance(field_value, list) or not all(
+                        v in valid_options for v in field_value
+                    ):
+                        errors.append(
+                            {
+                                "field": field.name,
+                                "message": t("select.invalid_options"),
+                            }
+                        )
                 elif field_value not in valid_options:
-                    errors.append({"field": field.name, "message": t("select.invalid_option")})
+                    errors.append(
+                        {"field": field.name, "message": t("select.invalid_option")}
+                    )
             elif isinstance(field, RadioField):
                 if field_value not in [opt.value for opt in field.options]:
-                    errors.append({"field": field.name, "message": t("radio.invalid_option")})
+                    errors.append(
+                        {"field": field.name, "message": t("radio.invalid_option")}
+                    )
             elif isinstance(field, CheckboxField):
                 if not isinstance(field_value, bool):
-                    errors.append({"field": field.name, "message": t("checkbox.must_be_boolean")})
+                    errors.append(
+                        {"field": field.name, "message": t("checkbox.must_be_boolean")}
+                    )
             elif isinstance(field, CheckboxGroupField):
-                if not isinstance(field_value, list) or not all(v in [opt.value for opt in field.options] for v in field_value):
-                    errors.append({"field": field.name, "message": t("checkbox_group.invalid_options")})
+                if not isinstance(field_value, list) or not all(
+                    v in [opt.value for opt in field.options] for v in field_value
+                ):
+                    errors.append(
+                        {
+                            "field": field.name,
+                            "message": t("checkbox_group.invalid_options"),
+                        }
+                    )
+            elif isinstance(field, ListField):
+                value, field_errors = _validate_list_field_value(field, field_value)
+                if field_errors:
+                    errors.extend(field_errors)
+                else:
+                    validated_data[field.name] = value
+            elif isinstance(field, ObjectListField):
+                value, field_errors = _validate_object_list_field_value(
+                    field, field_value
+                )
+                if field_errors:
+                    errors.extend(field_errors)
+                else:
+                    validated_data[field.name] = value
 
-            if not errors:
+            if not errors and field.name not in validated_data:
                 validated_data[field.name] = field_value
 
         return {
             "success": len(errors) == 0,
             "data": validated_data if not errors else None,
             "errors": errors,
-            "message": t("form.validation_success") if not errors else t("form.validation_error")
+            "message": t("form.validation_success")
+            if not errors
+            else t("form.validation_error"),
         }
 
-    def export(self, output_format: str = 'html', **kwargs) -> dict:
+    def export(self, output_format: str = "html", **kwargs) -> dict:
         from codeforms.export import ExportFormat
-        export_result = {'format': output_format}
+
+        export_result = {"format": output_format}
         if output_format in [format.value for format in ExportFormat]:
             from codeforms.export import exporter
+
             export_result = exporter(self, output_format=output_format, **kwargs)
 
-        elif output_format == 'dict':
-            export_result['output'] = self.to_dict()
+        elif output_format == "dict":
+            export_result["output"] = self.to_dict()
+
+        elif output_format == "json":
+            export_result["output"] = self.model_dump_json()
 
-        elif output_format == 'json':
-            export_result['output'] = self.model_dump_json()
-        
         else:
             raise ValueError(f"Unsupported export format: {output_format}")
-        
+
         return export_result
 
     def to_json(self) -> str:
-        return self.export(output_format='json').get('output')
+        return self.export(output_format="json").get("output")
 
-    def set_default_values(self, data: Dict[str, Any]) -> 'Form':
+    def set_default_values(self, data: Dict[str, Any]) -> "Form":
         """Establece los valores por defecto para los campos del formulario"""
         for field in self.fields:
             field.default_value = data.get(field.name)
@@ -191,8 +256,9 @@ class Form(BaseModel):
         """Retorna solo los campos visibles según las reglas visible_when."""
         return [f for f in self.fields if evaluate_visibility(f, data)]
 
-    def validate_step(self, step_index: int, data: Dict[str, Any],
-                      respect_visibility: bool = True) -> Dict[str, Any]:
+    def validate_step(
+        self, step_index: int, data: Dict[str, Any], respect_visibility: bool = True
+    ) -> Dict[str, Any]:
         """Valida un paso específico del wizard.
 
         Args:
@@ -210,16 +276,16 @@ class Form(BaseModel):
         if not steps:
             raise ValueError(t("wizard.not_a_wizard_form"))
         if not (0 <= step_index < len(steps)):
-            raise ValueError(t("wizard.invalid_step_index",
-                              index=step_index, max=len(steps) - 1))
+            raise ValueError(
+                t("wizard.invalid_step_index", index=step_index, max=len(steps) - 1)
+            )
         return validate_form_data_dynamic(
-            self, data,
-            respect_visibility=respect_visibility,
-            current_step=step_index
+            self, data, respect_visibility=respect_visibility, current_step=step_index
         )
 
-    def validate_all_steps(self, data: Dict[str, Any],
-                           respect_visibility: bool = True) -> Dict[str, Any]:
+    def validate_all_steps(
+        self, data: Dict[str, Any], respect_visibility: bool = True
+    ) -> Dict[str, Any]:
         """Valida todos los pasos del wizard secuencialmente.
 
         Returns:
@@ -247,7 +313,9 @@ class Form(BaseModel):
             "data": all_validated_data if success else None,
             "errors": all_errors if all_errors else [],
             "step_errors": step_errors if step_errors else None,
-            "message": t("form.validation_success") if success else t("wizard.validation_failed")
+            "message": t("form.validation_success")
+            if success
+            else t("wizard.validation_failed"),
         }
 
 
@@ -270,19 +338,23 @@ class FormDataModel(BaseModel):
                 fields[field.name] = (float, ... if field.required else None)
             elif isinstance(field, DateField):
                 fields[field.name] = (date, ... if field.required else None)
+            elif isinstance(field, ListField):
+                fields[field.name] = (List[Any], ... if field.required else [])
+            elif isinstance(field, ObjectListField):
+                fields[field.name] = (List[Dict[str, Any]], ... if field.required else [])
             else:
                 fields[field.name] = (str, ... if field.required else None)
 
         # Crear el modelo dinámicamente
         self.__class__ = type(
-            'DynamicFormData',
+            "DynamicFormData",
             (BaseModel,),
             {
-                '__annotations__': fields,
-                'model_config': {
-                    'extra': 'forbid'  # No permitir campos extra
-                }
-            }
+                "__annotations__": fields,
+                "model_config": {
+                    "extra": "forbid"  # No permitir campos extra
+                },
+            },
         )
         super().__init__()
 
@@ -302,9 +374,11 @@ class FormDataValidator:
                     field_type = List[str]
 
                     # Crear validador para la lista de valores
-                    def create_validator(valid_values=valid_values,
-                                         min_selected=field.min_selected,
-                                         max_selected=field.max_selected):
+                    def create_validator(
+                        valid_values=valid_values,
+                        min_selected=field.min_selected,
+                        max_selected=field.max_selected,
+                    ):
                         def validate_select_values(v: List[str]) -> List[str]:
                             if not v and field.required:
                                 raise ValueError(t("field.required"))
@@ -313,7 +387,10 @@ class FormDataValidator:
                             invalid_values = set(v) - valid_values
                             if invalid_values:
                                 raise ValueError(
-                                    t("select.invalid_values", values=', '.join(invalid_values))
+                                    t(
+                                        "select.invalid_values",
+                                        values=", ".join(invalid_values),
+                                    )
                                 )
 
                             # Validar cantidad mínima de selecciones
@@ -345,7 +422,10 @@ class FormDataValidator:
                                 raise ValueError(t("field.required"))
                             if v not in valid_values:
                                 raise ValueError(
-                                    t("select.invalid_value_must_be_one_of", valid=', '.join(valid_values))
+                                    t(
+                                        "select.invalid_value_must_be_one_of",
+                                        valid=", ".join(valid_values),
+                                    )
                                 )
                             return v
 
@@ -364,6 +444,10 @@ class FormDataValidator:
                 field_type = float
             elif isinstance(field, DateField):
                 field_type = date
+            elif isinstance(field, ListField):
+                field_type = List[Any]
+            elif isinstance(field, ObjectListField):
+                field_type = List[Dict[str, Any]]
             else:
                 field_type = str
 
@@ -372,9 +456,11 @@ class FormDataValidator:
                 fields[field.name] = Field(..., description=field.help_text)
             else:
                 default_value = None
-                if field_type == List[str]:
+                if field_type in (List[str], List[Any], List[Dict[str, Any]]):
                     default_value = []
-                fields[field.name] = Field(default=default_value, description=field.help_text)
+                fields[field.name] = Field(
+                    default=default_value, description=field.help_text
+                )
 
             annotations[field.name] = field_type
 
@@ -384,213 +470,150 @@ class FormDataValidator:
             model_name,
             (BaseModel,),
             {
-                '__annotations__': annotations,
+                "__annotations__": annotations,
                 **fields,
                 **validations,
-                'model_config': ConfigDict(
-                    arbitrary_types_allowed=True,
-                    extra='forbid'
-                )
-            }
+                "model_config": ConfigDict(
+                    arbitrary_types_allowed=True, extra="forbid"
+                ),
+            },
         )
 
         return model
 
 
+def _make_error(field_name: str, message: str) -> dict:
+    return {"field": field_name, "message": message}
+
+
+def _validate_primitive_list_item(item_type: str, value: Any) -> tuple[Any, Optional[str]]:
+    if item_type == "number":
+        try:
+            return float(value), None
+        except (TypeError, ValueError):
+            return None, t("number.invalid")
+
+    if item_type == "email":
+        if not re.match(r"[^@]+@[^@]+\.[^@]+", str(value)):
+            return None, t("email.invalid")
+        return str(value), None
+
+    if item_type == "url":
+        if not isinstance(value, str) or not value.startswith(("http://", "https://")):
+            return None, t("url.invalid_scheme")
+        return value, None
+
+    if item_type == "date":
+        try:
+            return date.fromisoformat(str(value)).isoformat(), None
+        except (TypeError, ValueError):
+            return None, t("date.invalid_format")
+
+    if not isinstance(value, str):
+        value = str(value)
+    return value, None
+
+
+def _validate_list_field_value(field: ListField, field_value: Any, field_path: Optional[str] = None) -> tuple[Any, List[dict]]:
+    field_name = field_path or field.name
+    if isinstance(field_value, str):
+        field_value = [field_value]
+
+    if not isinstance(field_value, list):
+        return None, [_make_error(field_name, t("select.value_must_be_list"))]
+
+    if field.min_items is not None and len(field_value) < field.min_items:
+        return None, [_make_error(field_name, f"Expected at least {field.min_items} items")]
+
+    if field.max_items is not None and len(field_value) > field.max_items:
+        return None, [_make_error(field_name, f"Expected at most {field.max_items} items")]
+
+    validated_items = []
+    errors = []
+    for index, item in enumerate(field_value):
+        validated_item, error_message = _validate_primitive_list_item(field.item_type, item)
+        if error_message:
+            errors.append(_make_error(f"{field_name}[{index}]", error_message))
+        else:
+            validated_items.append(validated_item)
+
+    return (validated_items if not errors else None), errors
+
+
+def _validate_object_list_field_value(field: ObjectListField, field_value: Any, field_path: Optional[str] = None) -> tuple[Any, List[dict]]:
+    field_name = field_path or field.name
+    if not isinstance(field_value, list):
+        return None, [_make_error(field_name, t("select.value_must_be_list"))]
+
+    if field.min_items is not None and len(field_value) < field.min_items:
+        return None, [_make_error(field_name, f"Expected at least {field.min_items} items")]
+
+    if field.max_items is not None and len(field_value) > field.max_items:
+        return None, [_make_error(field_name, f"Expected at most {field.max_items} items")]
+
+    allowed_fields = {subfield.name for subfield in field.fields}
+    validated_items = []
+    errors = []
+
+    for index, item in enumerate(field_value):
+        item_path = f"{field_name}[{index}]"
+        if not isinstance(item, dict):
+            errors.append(_make_error(item_path, "Each item must be an object"))
+            continue
+
+        extra_fields = sorted(set(item.keys()) - allowed_fields)
+        if extra_fields:
+            errors.append(_make_error(item_path, f"Unknown fields: {', '.join(extra_fields)}"))
+
+        validated_item = {}
+        item_errors = []
+        for subfield in field.fields:
+            subvalue = item.get(subfield.name)
+            validated_value, suberrors = _validate_field_value(
+                subfield,
+                subvalue,
+                item,
+                field_path=f"{item_path}.{subfield.name}",
+            )
+            if suberrors:
+                item_errors.extend(suberrors)
+            elif validated_value is not None:
+                validated_item[subfield.name] = validated_value
+
+        if item_errors:
+            errors.extend(item_errors)
+        else:
+            validated_items.append(validated_item)
+
+    return (validated_items if not errors else None), errors
+
+
 def validate_form_data(form: Form, data: Dict[str, Any]) -> Dict[str, Any]:
     try:
         validated_data = {}
         for field in form.fields:
             field_value = data.get(field.name)
-
-            # Si no hay valor, usar el valor por defecto
-            if field_value is None:
-                field_value = field.default_value
-                
-            # Validar campo requerido después de considerar el valor por defecto
-            if field.required and field_value is None:
+            value, errors = _validate_field_value(field, field_value, data)
+            if errors:
                 return {
                     "success": False,
-                    "errors": [{
-                        "field": field.name,
-                        "message": t("field.required_named", name=field.name)
-                    }],
-                    "message": t("form.data_validation_error")
+                    "errors": errors,
+                    "message": t("form.data_validation_error"),
                 }
-            
-            # Procesar valores específicos por tipo
-            if field_value is not None:
-                # Select validation (debe ir antes de otros tipos)
-                if field.field_type == FieldType.SELECT:
-                    valid_options = [opt.value for opt in field.options]
-                    if field.multiple:
-                        # Asegurar que field_value sea una lista
-                        if isinstance(field_value, str):
-                            field_value = [field_value]
-                        if not isinstance(field_value, list):
-                            return {
-                                "success": False,
-                                "errors": [{
-                                    "field": field.name,
-                                    "message": t("select.value_must_be_list")
-                                }],
-                                "message": t("form.data_validation_error")
-                            }
-                        # Validar cada valor en la lista
-                        invalid_values = [v for v in field_value if v not in valid_options]
-                        if invalid_values:
-                            return {
-                                "success": False,
-                                "errors": [{
-                                    "field": field.name,
-                                    "message": t("select.invalid_values", values=str(invalid_values))
-                                }],
-                                "message": t("form.data_validation_error")
-                            }
-                    else:
-                        # Validar valor único
-                        if field_value not in valid_options:
-                            return {
-                                "success": False,
-                                "errors": [{
-                                    "field": field.name,
-                                    "message": t("select.invalid_option_value", value=field_value, valid=str(valid_options))
-                                }],
-                                "message": t("form.data_validation_error")
-                            }
-                    validated_data[field.name] = field_value
-
-                # Email validation
-                elif field.field_type == FieldType.EMAIL:
-                    try:
-                        if not re.match(r"[^@]+@[^@]+\.[^@]+", field_value):
-                            raise ValueError("Invalid email format")
-                        validated_data[field.name] = field_value
-                    except ValueError:
-                        return {
-                            "success": False,
-                            "errors": [{
-                                "field": field.name,
-                                "message": t("email.invalid")
-                            }],
-                            "message": t("form.data_validation_error")
-                        }
-                
-                # Checkbox group validation
-                elif field.field_type == FieldType.CHECKBOX and hasattr(field, 'options'):
-                    valid_options = [opt.value for opt in field.options]
-                    
-                    # Ensure field_value is a list
-                    if isinstance(field_value, str):
-                        field_value = [field_value]
-                    
-                    if not isinstance(field_value, list):
-                        return {
-                            "success": False,
-                            "errors": [{
-                                "field": field.name,
-                                "message": t("select.value_must_be_list")
-                            }],
-                            "message": t("form.data_validation_error")
-                        }
-                    
-                    # Check if all values are valid options
-                    invalid_values = [v for v in field_value if v not in valid_options]
-                    if invalid_values:
-                        return {
-                            "success": False,
-                            "errors": [{
-                                "field": field.name,
-                                "message": t("select.invalid_values", values=str(invalid_values))
-                            }],
-                            "message": t("form.data_validation_error")
-                        }
-                    validated_data[field.name] = field_value
-                
-                # Single checkbox validation
-                elif field.field_type == FieldType.CHECKBOX and not hasattr(field, 'options'):
-                    # Convertir a booleano si es necesario
-                    validated_data[field.name] = bool(field_value)
-                
-                # Radio validation
-                elif field.field_type == FieldType.RADIO:
-                    valid_options = [opt.value for opt in field.options]
-                    if field_value not in valid_options:
-                        return {
-                            "success": False,
-                            "errors": [{
-                                "field": field.name,
-                                "message": t("radio.invalid_option")
-                            }],
-                            "message": t("form.data_validation_error")
-                        }
-                    validated_data[field.name] = field_value
-                
-                # Number validation
-                elif field.field_type == FieldType.NUMBER:
-                    try:
-                        num_value = float(field_value)
-                        if hasattr(field, 'min_value') and field.min_value is not None:
-                            if num_value < field.min_value:
-                                raise ValueError(t("number.min_value", min=field.min_value))
-                        if hasattr(field, 'max_value') and field.max_value is not None:
-                            if num_value > field.max_value:
-                                raise ValueError(t("number.max_value", max=field.max_value))
-                        validated_data[field.name] = num_value
-                    except ValueError as e:
-                        return {
-                            "success": False,
-                            "errors": [{
-                                "field": field.name,
-                                "message": str(e)
-                            }],
-                            "message": t("form.data_validation_error")
-                        }
-                
-                # Text validation
-                elif field.field_type == FieldType.TEXT:
-                    if not isinstance(field_value, str):
-                        field_value = str(field_value)
-                    if hasattr(field, 'minlength') and field.minlength is not None:
-                        if len(field_value) < field.minlength:
-                            return {
-                                "success": False,
-                                "errors": [{
-                                    "field": field.name,
-                                    "message": t("text.minlength", min=field.minlength)
-                                }],
-                                "message": t("form.data_validation_error")
-                            }
-                    if hasattr(field, 'maxlength') and field.maxlength is not None:
-                        if len(field_value) > field.maxlength:
-                            return {
-                                "success": False,
-                                "errors": [{
-                                    "field": field.name,
-                                    "message": t("text.maxlength", max=field.maxlength)
-                                }],
-                                "message": t("form.data_validation_error")
-                            }
-                    validated_data[field.name] = field_value
-                
-                # Default validation for other types
-                else:
-                    validated_data[field.name] = field_value
+            if value is not None:
+                validated_data[field.name] = value
 
         return {
             "success": True,
             "data": validated_data,
-            "message": t("form.validation_success")
+            "message": t("form.validation_success"),
         }
 
     except Exception as e:
         return {
             "success": False,
-            "errors": [{
-                "field": "unknown",
-                "message": str(e)
-            }],
-            "message": t("form.data_validation_error")
+            "errors": [{"field": "unknown", "message": str(e)}],
+            "message": t("form.data_validation_error"),
         }
 
 
@@ -641,26 +664,26 @@ def evaluate_visibility(field: FormFieldBase, data: Dict[str, Any]) -> bool:
     return True
 
 
-def _validate_field_value(field: FormFieldBase, field_value: Any,
-                          data: Dict[str, Any]) -> tuple:
+def _validate_field_value(
+    field: FormFieldBase, field_value: Any, data: Dict[str, Any], field_path: Optional[str] = None
+) -> tuple[Any, List[dict]]:
     """Valida un campo individual y retorna (validated_value, error_dict_or_None).
 
     Lógica de validación compartida entre validate_form_data y
     validate_form_data_dynamic. No modifica la función legacy.
     """
+    field_name = field_path or field.name
+
     # Si no hay valor, usar el valor por defecto
     if field_value is None:
         field_value = field.default_value
 
     # Validar campo requerido
     if field.required and field_value is None:
-        return None, {
-            "field": field.name,
-            "message": t("field.required_named", name=field.name)
-        }
+        return None, [_make_error(field_name, t("field.required_named", name=field.name))]
 
     if field_value is None:
-        return field_value, None
+        return field_value, []
 
     # Select validation
     if field.field_type == FieldType.SELECT:
@@ -669,97 +692,92 @@ def _validate_field_value(field: FormFieldBase, field_value: Any,
             if isinstance(field_value, str):
                 field_value = [field_value]
             if not isinstance(field_value, list):
-                return None, {"field": field.name,
-                              "message": t("select.value_must_be_list")}
+                return None, [_make_error(field_name, t("select.value_must_be_list"))]
             invalid_values = [v for v in field_value if v not in valid_options]
             if invalid_values:
-                return None, {"field": field.name,
-                              "message": t("select.invalid_values",
-                                          values=str(invalid_values))}
+                return None, [_make_error(field_name, t("select.invalid_values", values=str(invalid_values)))]
         else:
             if field_value not in valid_options:
-                return None, {"field": field.name,
-                              "message": t("select.invalid_option_value",
-                                          value=field_value,
-                                          valid=str(valid_options))}
-        return field_value, None
+                return None, [_make_error(field_name, t(
+                        "select.invalid_option_value",
+                        value=field_value,
+                        valid=str(valid_options),
+                    ))]
+        return field_value, []
+
+    # Primitive list validation
+    if field.field_type == FieldType.LIST:
+        return _validate_list_field_value(field, field_value, field_name)
+
+    # Object list validation
+    if field.field_type == FieldType.OBJECT_LIST:
+        return _validate_object_list_field_value(field, field_value, field_name)
 
     # Email validation
     if field.field_type == FieldType.EMAIL:
         if not re.match(r"[^@]+@[^@]+\.[^@]+", str(field_value)):
-            return None, {"field": field.name,
-                          "message": t("email.invalid")}
-        return field_value, None
+            return None, [_make_error(field_name, t("email.invalid"))]
+        return field_value, []
 
     # Checkbox group validation
-    if field.field_type == FieldType.CHECKBOX and hasattr(field, 'options'):
+    if field.field_type == FieldType.CHECKBOX and hasattr(field, "options"):
         valid_options = [opt.value for opt in field.options]
         if isinstance(field_value, str):
             field_value = [field_value]
         if not isinstance(field_value, list):
-            return None, {"field": field.name,
-                          "message": t("select.value_must_be_list")}
+            return None, [_make_error(field_name, t("select.value_must_be_list"))]
         invalid_values = [v for v in field_value if v not in valid_options]
         if invalid_values:
-            return None, {"field": field.name,
-                          "message": t("select.invalid_values",
-                                      values=str(invalid_values))}
-        return field_value, None
+            return None, [_make_error(field_name, t("select.invalid_values", values=str(invalid_values)))]
+        return field_value, []
 
     # Single checkbox validation
-    if field.field_type == FieldType.CHECKBOX and not hasattr(field, 'options'):
+    if field.field_type == FieldType.CHECKBOX and not hasattr(field, "options"):
         return bool(field_value), None
 
     # Radio validation
     if field.field_type == FieldType.RADIO:
         valid_options = [opt.value for opt in field.options]
         if field_value not in valid_options:
-            return None, {"field": field.name,
-                          "message": t("radio.invalid_option")}
-        return field_value, None
+            return None, [_make_error(field_name, t("radio.invalid_option"))]
+        return field_value, []
 
     # Number validation
     if field.field_type == FieldType.NUMBER:
         try:
             num_value = float(field_value)
-            if hasattr(field, 'min_value') and field.min_value is not None:
+            if hasattr(field, "min_value") and field.min_value is not None:
                 if num_value < field.min_value:
-                    return None, {"field": field.name,
-                                  "message": t("number.min_value",
-                                              min=field.min_value)}
-            if hasattr(field, 'max_value') and field.max_value is not None:
+                    return None, [_make_error(field_name, t("number.min_value", min=field.min_value))]
+            if hasattr(field, "max_value") and field.max_value is not None:
                 if num_value > field.max_value:
-                    return None, {"field": field.name,
-                                  "message": t("number.max_value",
-                                              max=field.max_value)}
+                    return None, [_make_error(field_name, t("number.max_value", max=field.max_value))]
             return num_value, None
         except (ValueError, TypeError):
-            return None, {"field": field.name,
-                          "message": t("number.invalid")}
+            return None, [_make_error(field_name, t("number.invalid"))]
 
     # Text validation
     if field.field_type == FieldType.TEXT:
         if not isinstance(field_value, str):
             field_value = str(field_value)
-        if hasattr(field, 'minlength') and field.minlength is not None:
+        if hasattr(field, "minlength") and field.minlength is not None:
             if len(field_value) < field.minlength:
-                return None, {"field": field.name,
-                              "message": t("text.minlength",
-                                          min=field.minlength)}
-        if hasattr(field, 'maxlength') and field.maxlength is not None:
+                return None, [_make_error(field_name, t("text.minlength", min=field.minlength))]
+        if hasattr(field, "maxlength") and field.maxlength is not None:
             if len(field_value) > field.maxlength:
-                return None, {"field": field.name,
-                              "message": t("text.maxlength",
-                                          max=field.maxlength)}
-        return field_value, None
+                return None, [_make_error(field_name, t("text.maxlength", max=field.maxlength))]
+        return field_value, []
 
     # Default: pasar el valor sin validación adicional
-    return field_value, None
+    return field_value, []
 
 
-def validate_form_data_dynamic(form: 'Form', data: Dict[str, Any],
-                               respect_visibility: bool = True,
-                               current_step: Optional[int] = None) -> Dict[str, Any]:
+def validate_form_data_dynamic(
+    form: "Form",
+    data: Dict[str, Any],
+    respect_visibility: bool = True,
+    current_step: Optional[int] = None,
+) -> Dict[str, Any]:
     """Validación dinámica con soporte para visible_when y steps.
 
     A diferencia de validate_form_data(), esta función:
@@ -789,11 +807,17 @@ def validate_form_data_dynamic(form: 'Form', data: Dict[str, Any],
             else:
                 return {
                     "success": False,
-                    "errors": [{"field": "unknown",
-                               "message": t("wizard.invalid_step_index",
-                                           index=current_step,
-                                           max=len(steps) - 1)}],
-                    "message": t("form.data_validation_error")
+                    "errors": [
+                        {
+                            "field": "unknown",
+                            "message": t(
+                                "wizard.invalid_step_index",
+                                index=current_step,
+                                max=len(steps) - 1,
+                            ),
+                        }
+                    ],
+                    "message": t("form.data_validation_error"),
                 }
         else:
             fields_to_validate = form.fields
@@ -804,10 +828,10 @@ def validate_form_data_dynamic(form: 'Form', data: Dict[str, Any],
                 continue  # Campo oculto, no validar
 
             field_value = data.get(field.name)
-            value, error = _validate_field_value(field, field_value, data)
+            value, field_errors = _validate_field_value(field, field_value, data)
 
-            if error:
-                errors.append(error)
+            if field_errors:
+                errors.extend(field_errors)
             elif value is not None:
                 validated_data[field.name] = value
 
@@ -816,13 +840,14 @@ def validate_form_data_dynamic(form: 'Form', data: Dict[str, Any],
             "success": success,
             "data": validated_data if success else None,
             "errors": errors if errors else [],
-            "message": t("form.validation_success") if success else t("form.data_validation_error")
+            "message": t("form.validation_success")
+            if success
+            else t("form.data_validation_error"),
         }
 
     except Exception as e:
         return {
             "success": False,
             "errors": [{"field": "unknown", "message": str(e)}],
-            "message": t("form.data_validation_error")
+            "message": t("form.data_validation_error"),
         }
-