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

codeforms/export.py

@@ -1,18 +1,39 @@
 from enum import Enum
+from typing import Any, Dict
+
+from codeforms.fields import (
+    CheckboxField,
+    CheckboxGroupField,
+    DateField,
+    EmailField,
+    FieldGroup,
+    FileField,
+    FormFieldBase,
+    FormStep,
+    HiddenField,
+    ListField,
+    ObjectListField,
+    NumberField,
+    RadioField,
+    SelectField,
+    TextareaField,
+    TextField,
+    UrlField,
+)
 from codeforms.forms import Form
-from codeforms.fields import FormFieldBase, FieldGroup, FormStep
 from codeforms.i18n import t
 
 
 class ExportFormat(Enum):
-    HTML = 'html'
-    BOOTSTRAP4 = 'html_bootstrap4'
-    BOOTSTRAP5 = 'html_bootstrap5'
+    HTML = "html"
+    BOOTSTRAP4 = "html_bootstrap4"
+    BOOTSTRAP5 = "html_bootstrap5"
+    JSON_SCHEMA = "json_schema"
 
 
 def generate_validation_code(form, output_format: str) -> str:
     """Genera el código de validación en Javascript"""
-    if output_format == 'html':
+    if output_format == "html":
         validation_code = f"""
         <script>
         function validate_{form.name}(form) {{
@@ -97,67 +118,75 @@ def js_generate_field_validations(form) -> str:
 
     return "\n".join(validations)
 
+
 def field_exporter(field: FormFieldBase, output_format: str, **kwargs) -> str:
     """Exporta un campo individual al formato especificado"""
-    if output_format == 'html':
+    if output_format == "html":
         return field_to_html(field, kwargs=kwargs)
     return ""
 
 
 def group_exporter(group, output_format: str, **kwargs) -> str:
     """Exporta un grupo de campos al formato especificado"""
-    if output_format == 'html':
+    if output_format == "html":
         return group_to_html(group, kwargs=kwargs)
     return ""
 
 
 def step_exporter(step, output_format: str, **kwargs) -> str:
     """Exporta un paso de formulario (wizard) al formato especificado"""
-    if output_format in ('html', ExportFormat.HTML.value,
-                         ExportFormat.BOOTSTRAP4.value,
-                         ExportFormat.BOOTSTRAP5.value):
-        actual_kwargs = kwargs.get('kwargs', kwargs)
-        actual_kwargs['output_format'] = output_format
+    if output_format in (
+        "html",
+        ExportFormat.HTML.value,
+        ExportFormat.BOOTSTRAP4.value,
+        ExportFormat.BOOTSTRAP5.value,
+    ):
+        actual_kwargs = kwargs.get("kwargs", kwargs)
+        actual_kwargs["output_format"] = output_format
         return step_to_html(step, **actual_kwargs)
     return ""
 
 
 def group_to_html(group, **kwargs) -> str:
     """Genera la representación HTML del grupo de campos usando fieldset y legend"""
-    output_format = kwargs.get('output_format', ExportFormat.HTML.value)
-    is_bootstrap = output_format in [ExportFormat.BOOTSTRAP4.value, ExportFormat.BOOTSTRAP5.value]
-    
+    output_format = kwargs.get("output_format", ExportFormat.HTML.value)
+    is_bootstrap = output_format in [
+        ExportFormat.BOOTSTRAP4.value,
+        ExportFormat.BOOTSTRAP5.value,
+    ]
+
     # Clases CSS para el fieldset
-    fieldset_class = f"mb-4 {group.css_classes or ''}".strip() if is_bootstrap else group.css_classes or ""
+    fieldset_class = (
+        f"mb-4 {group.css_classes or ''}".strip()
+        if is_bootstrap
+        else group.css_classes or ""
+    )
     legend_class = "h5 mb-3" if is_bootstrap else ""
-    
+
     # Atributos del fieldset
-    fieldset_attrs = {
-        "id": f"group_{group.id}",
-        "class": fieldset_class
-    }
-    
+    fieldset_attrs = {"id": f"group_{group.id}", "class": fieldset_class}
+
     # Agregar atributos personalizados del grupo
     fieldset_attrs.update(group.attributes)
-    
+
     # Generar string de atributos
     attrs_str = " ".join(f'{k}="{v}"' for k, v in fieldset_attrs.items() if v)
-    
+
     # Generar HTML de los campos dentro del grupo
     fields_html = "\n".join(field_to_html(field, **kwargs) for field in group.fields)
-    
+
     # Generar descripción si existe
     description_html = ""
     if group.description:
         desc_class = "text-muted small mb-3" if is_bootstrap else "group-description"
         description_html = f'<p class="{desc_class}">{group.description}</p>'
-    
+
     # Construir el HTML del fieldset
-    html = f'<fieldset {attrs_str}>'
+    html = f"<fieldset {attrs_str}>"
     html += f'<legend class="{legend_class}">{group.title}</legend>'
     html += description_html
     html += fields_html
-    html += '</fieldset>'
+    html += "</fieldset>"
 
     return html
 
@@ -167,11 +196,18 @@ def step_to_html(step, **kwargs) -> str:
 
     Diferente de FieldGroup (que usa <fieldset>) para distinguir semánticamente.
     """
-    output_format = kwargs.get('output_format', ExportFormat.HTML.value)
-    is_bootstrap = output_format in [ExportFormat.BOOTSTRAP4.value, ExportFormat.BOOTSTRAP5.value]
+    output_format = kwargs.get("output_format", ExportFormat.HTML.value)
+    is_bootstrap = output_format in [
+        ExportFormat.BOOTSTRAP4.value,
+        ExportFormat.BOOTSTRAP5.value,
+    ]
 
     # Clases CSS para el section
-    step_class = f"form-step mb-4 {step.css_classes or ''}".strip() if is_bootstrap else f"form-step {step.css_classes or ''}".strip()
+    step_class = (
+        f"form-step mb-4 {step.css_classes or ''}".strip()
+        if is_bootstrap
+        else f"form-step {step.css_classes or ''}".strip()
+    )
     title_class = "h4 mb-3" if is_bootstrap else "step-title"
 
     # Atributos del section
@@ -180,7 +216,7 @@ def step_to_html(step, **kwargs) -> str:
         "class": step_class,
         "data-step": "true",
         "data-validation-mode": step.validation_mode,
-        "data-skippable": str(step.skippable).lower()
+        "data-skippable": str(step.skippable).lower(),
     }
     step_attrs.update(step.attributes)
 
@@ -201,19 +237,24 @@ def step_to_html(step, **kwargs) -> str:
         desc_class = "text-muted mb-3" if is_bootstrap else "step-description"
         description_html = f'<p class="{desc_class}">{step.description}</p>'
 
-    html = f'<section {attrs_str}>'
+    html = f"<section {attrs_str}>"
     html += f'<h2 class="{title_class}">{step.title}</h2>'
     html += description_html
     html += content_html
-    html += '</section>'
+    html += "</section>"
 
     return html
 
 
 def form_to_html(form: Form, **kwargs) -> str:
     """Genera el HTML completo del formulario"""
-    output_format = kwargs.get('output_format', ExportFormat.HTML.value)
-    form_class = "needs-validation" if output_format in [ExportFormat.BOOTSTRAP4.value, ExportFormat.BOOTSTRAP5.value] else ""
+    output_format = kwargs.get("output_format", ExportFormat.HTML.value)
+    form_class = (
+        "needs-validation"
+        if output_format
+        in [ExportFormat.BOOTSTRAP4.value, ExportFormat.BOOTSTRAP5.value]
+        else ""
+    )
 
     # Detectar si es wizard
     is_wizard = any(isinstance(item, FormStep) for item in form.content)
@@ -221,10 +262,10 @@ def form_to_html(form: Form, **kwargs) -> str:
         form_class = f"{form_class} form-wizard".strip()
 
     attributes = {
-        "id": kwargs.get('id') or str(form.id),
+        "id": kwargs.get("id") or str(form.id),
         "name": form.name,
         "class": f"{form_class} {form.css_classes or ''}".strip(),
-        "enctype": kwargs.get('enctype') or "application/x-www-form-urlencoded"
+        "enctype": kwargs.get("enctype") or "application/x-www-form-urlencoded",
     }
     if is_wizard:
         attributes["data-wizard"] = "true"
@@ -240,11 +281,16 @@ def form_to_html(form: Form, **kwargs) -> str:
             content_html_parts.append(group_to_html(item, **kwargs))
         else:  # Es un campo individual
             content_html_parts.append(field_to_html(item, **kwargs))
-    
+
     content_html = "\n".join(content_html_parts)
-    
-    if kwargs.get('submit'):
-        submit_class = "btn btn-primary" if output_format in [ExportFormat.BOOTSTRAP4.value, ExportFormat.BOOTSTRAP5.value] else ""
+
+    if kwargs.get("submit"):
+        submit_class = (
+            "btn btn-primary"
+            if output_format
+            in [ExportFormat.BOOTSTRAP4.value, ExportFormat.BOOTSTRAP5.value]
+            else ""
+        )
         submit_html = f'<button type="submit" class="{submit_class}">{t("export.submit")}</button>'
     else:
         submit_html = ""
@@ -252,89 +298,104 @@ def form_to_html(form: Form, **kwargs) -> str:
     html = f"<form {attrs_str}>"
     html += f"\t{content_html}"
     html += f"\t{submit_html}"
-    html += f"</form>"
+    html += "</form>"
     return html
 
 
 def field_to_html(field: FormFieldBase, **kwargs) -> str:
     """Genera la representación HTML del campo"""
-    output_format = kwargs.get('output_format', ExportFormat.HTML.value)
-    is_bootstrap = output_format in [ExportFormat.BOOTSTRAP4.value, ExportFormat.BOOTSTRAP5.value]
-    
+    output_format = kwargs.get("output_format", ExportFormat.HTML.value)
+    is_bootstrap = output_format in [
+        ExportFormat.BOOTSTRAP4.value,
+        ExportFormat.BOOTSTRAP5.value,
+    ]
+
     # Clases base para Bootstrap 4/5
     if is_bootstrap:
         base_input_class = "form-control"
-        form_group_class = "mb-3" if output_format == ExportFormat.BOOTSTRAP5.value else "form-group"
+        form_group_class = (
+            "mb-3" if output_format == ExportFormat.BOOTSTRAP5.value else "form-group"
+        )
         help_text_class = "form-text"  # Bootstrap 5 removed text-muted
     else:
         base_input_class = ""
         form_group_class = "form-field"
         help_text_class = "help-text"
 
-    skip_label = ['hidden']
-    
-    label_html = ''
+    skip_label = ["hidden"]
+
+    label_html = ""
     if field.field_type_value not in skip_label:
         label_class = "form-label" if is_bootstrap else ""
-        label_html = f'<label class="{label_class}" for="{field.id}">{field.label}</label>'
-    
-    help_html = f'<small class="{help_text_class}">{field.help_text}</small>' if field.help_text else ""
+        label_html = (
+            f'<label class="{label_class}" for="{field.id}">{field.label}</label>'
+        )
+
+    help_html = (
+        f'<small class="{help_text_class}">{field.help_text}</small>'
+        if field.help_text
+        else ""
+    )
 
     # Manejar campos SELECT de manera especial
-    if field.field_type_value == 'select':
+    if field.field_type_value == "select":
         select_attrs = {
             "id": str(field.id),
             "name": field.name,
             "class": f"{base_input_class} {field.css_classes or ''}".strip(),
         }
-        
+
         if field.required:
             select_attrs["required"] = "required"
-            
-        if hasattr(field, 'multiple') and field.multiple:
+
+        if hasattr(field, "multiple") and field.multiple:
             select_attrs["multiple"] = "multiple"
-            
+
         # Agregar atributos personalizados
         select_attrs.update(field.attributes)
-        
+
         attrs_str = " ".join(f'{k}="{v}"' for k, v in select_attrs.items() if v)
-        
+
         # Generar opciones
         options_html = ""
-        if hasattr(field, 'options'):
+        if hasattr(field, "options"):
             for option in field.options:
                 selected = 'selected="selected"' if option.selected else ""
-                options_html += f'<option value="{option.value}" {selected}>{option.label}</option>'
-        
-        input_html = f'<select {attrs_str}>{options_html}</select>'
-    
+                options_html += (
+                    f'<option value="{option.value}" {selected}>{option.label}</option>'
+                )
+
+        input_html = f"<select {attrs_str}>{options_html}</select>"
+
     # Manejar campos RADIO de manera especial
-    elif field.field_type_value == 'radio':
+    elif field.field_type_value == "radio":
         radio_html_parts = []
-        if hasattr(field, 'options'):
+        if hasattr(field, "options"):
             for option in field.options:
                 radio_attrs = {
                     "id": f"{field.id}_{option.value}",
                     "name": field.name,
                     "type": "radio",
                     "value": option.value,
-                    "class": field.css_classes or ""
+                    "class": field.css_classes or "",
                 }
-                
+
                 if option.selected:
                     radio_attrs["checked"] = "checked"
-                    
+
                 if field.required:
                     radio_attrs["required"] = "required"
-                
+
                 attrs_str = " ".join(f'{k}="{v}"' for k, v in radio_attrs.items() if v)
-                radio_label = f'<label for="{field.id}_{option.value}">{option.label}</label>'
-                radio_html_parts.append(f'<input {attrs_str}>{radio_label}')
-        
-        input_html = '<div class="radio-group">' + ''.join(radio_html_parts) + '</div>'
-    
+                radio_label = (
+                    f'<label for="{field.id}_{option.value}">{option.label}</label>'
+                )
+                radio_html_parts.append(f"<input {attrs_str}>{radio_label}")
+
+        input_html = '<div class="radio-group">' + "".join(radio_html_parts) + "</div>"
+
     # Manejar campos CHECKBOX con opciones múltiples
-    elif field.field_type_value == 'checkbox' and hasattr(field, 'options'):
+    elif field.field_type_value == "checkbox" and hasattr(field, "options"):
         checkbox_html_parts = []
         for option in field.options:
             checkbox_attrs = {
@@ -342,21 +403,25 @@ def field_to_html(field: FormFieldBase, **kwargs) -> str:
                 "name": field.name,
                 "type": "checkbox",
                 "value": option.value,
-                "class": field.css_classes or ""
+                "class": field.css_classes or "",
             }
-            
+
             if option.selected:
                 checkbox_attrs["checked"] = "checked"
-                
+
             if field.required:
                 checkbox_attrs["required"] = "required"
-            
+
             attrs_str = " ".join(f'{k}="{v}"' for k, v in checkbox_attrs.items() if v)
-            checkbox_label = f'<label for="{field.id}_{option.value}">{option.label}</label>'
-            checkbox_html_parts.append(f'<input {attrs_str}>{checkbox_label}')
-        
-        input_html = '<div class="checkbox-group">' + ''.join(checkbox_html_parts) + '</div>'
-    
+            checkbox_label = (
+                f'<label for="{field.id}_{option.value}">{option.label}</label>'
+            )
+            checkbox_html_parts.append(f"<input {attrs_str}>{checkbox_label}")
+
+        input_html = (
+            '<div class="checkbox-group">' + "".join(checkbox_html_parts) + "</div>"
+        )
+
     # Manejar campos normales (input)
     else:
         attributes = {
@@ -366,18 +431,22 @@ def field_to_html(field: FormFieldBase, **kwargs) -> str:
             "class": f"{base_input_class} {field.css_classes or ''}".strip(),
             "placeholder": field.placeholder or "",
         }
-        
-        if hasattr(field, 'value'):
-            attributes["value"] = getattr(field, 'value')
+
+        if hasattr(field, "value"):
+            attributes["value"] = field.value
 
         if field.required:
             attributes["required"] = "required"
 
         if field.default_value is not None:
             attributes["value"] = str(field.default_value)
-            
+
         # Para checkbox simple, manejar el atributo checked
-        if field.field_type_value == 'checkbox' and hasattr(field, 'checked') and field.checked:
+        if (
+            field.field_type_value == "checkbox"
+            and hasattr(field, "checked")
+            and field.checked
+        ):
             attributes["checked"] = "checked"
 
         # Agregar atributos personalizados
@@ -385,16 +454,200 @@ def field_to_html(field: FormFieldBase, **kwargs) -> str:
 
         # Convertir atributos a string
         attrs_str = " ".join(f'{k}="{v}"' for k, v in attributes.items() if v)
-        input_html = f'<input {attrs_str}>'
+        input_html = f"<input {attrs_str}>"
+
+    return (
+        f"""<div class="{form_group_class}">{label_html}{input_html}{help_html}</div>"""
+    )
 
-    return f"""<div class="{form_group_class}">{label_html}{input_html}{help_html}</div>"""
 
 def exporter(form: Form, output_format: str, **kwargs) -> dict:
-    export_result = {'format': output_format}
-    if output_format in [format.value for format in ExportFormat]:
-        actual_kwargs = kwargs.get('kwargs', kwargs)
-        actual_kwargs['output_format'] = output_format
-        export_result['output'] = form_to_html(form, **actual_kwargs)
-        export_result['javascript_validation_code'] = generate_validation_code(form, output_format)
-
-    return export_result
+    export_result = {"format": output_format}
+
+    if output_format == ExportFormat.JSON_SCHEMA.value:
+        export_result["output"] = form_to_json_schema(form)
+    elif output_format in [fmt.value for fmt in ExportFormat]:
+        actual_kwargs = kwargs.get("kwargs", kwargs)
+        actual_kwargs["output_format"] = output_format
+        export_result["output"] = form_to_html(form, **actual_kwargs)
+        export_result["javascript_validation_code"] = generate_validation_code(
+            form, output_format
+        )
+
+    return export_result
+
+
+_LIST_ITEM_TYPE_MAP: Dict[str, str] = {
+    "text": "string",
+    "number": "number",
+    "email": "string",
+    "url": "string",
+    "date": "string",
+}
+
+
+def _object_list_item_schema(field: ObjectListField) -> Dict[str, Any]:
+    properties: Dict[str, Any] = {}
+    required = []
+
+    for subfield in field.fields:
+        properties[subfield.name] = _field_to_json_schema_property(subfield)
+        if subfield.required:
+            required.append(subfield.name)
+
+    item_schema: Dict[str, Any] = {
+        "type": "object",
+        "properties": properties,
+        "additionalProperties": False,
+    }
+    if required:
+        item_schema["required"] = required
+
+    return item_schema
+
+
+def _field_to_json_schema_property(field: FormFieldBase) -> Dict[str, Any]:
+    """Convert a single form field to a JSON Schema property definition."""
+    prop: Dict[str, Any] = {}
+
+    if isinstance(field, SelectField):
+        enum_values = [opt.value for opt in field.options]
+        if field.multiple:
+            prop["type"] = "array"
+            prop["items"] = {"type": "string", "enum": enum_values}
+            prop["uniqueItems"] = True
+            if field.min_selected is not None:
+                prop["minItems"] = field.min_selected
+            if field.max_selected is not None:
+                prop["maxItems"] = field.max_selected
+        else:
+            prop["type"] = "string"
+            prop["enum"] = enum_values
+
+    elif isinstance(field, RadioField):
+        prop["type"] = "string"
+        prop["enum"] = [opt.value for opt in field.options]
+
+    elif isinstance(field, CheckboxGroupField):
+        prop["type"] = "array"
+        prop["items"] = {
+            "type": "string",
+            "enum": [opt.value for opt in field.options],
+        }
+        prop["uniqueItems"] = True
+
+    elif isinstance(field, CheckboxField):
+        prop["type"] = "boolean"
+
+    elif isinstance(field, EmailField):
+        prop["type"] = "string"
+        prop["format"] = "email"
+
+    elif isinstance(field, NumberField):
+        prop["type"] = "number"
+        if field.min_value is not None:
+            prop["minimum"] = field.min_value
+        if field.max_value is not None:
+            prop["maximum"] = field.max_value
+        if field.step is not None:
+            prop["multipleOf"] = field.step
+
+    elif isinstance(field, DateField):
+        prop["type"] = "string"
+        prop["format"] = "date"
+
+    elif isinstance(field, FileField):
+        if field.multiple:
+            prop["type"] = "array"
+            prop["items"] = {"type": "string", "contentEncoding": "base64"}
+        else:
+            prop["type"] = "string"
+            prop["contentEncoding"] = "base64"
+
+    elif isinstance(field, HiddenField):
+        prop["type"] = "string"
+
+    elif isinstance(field, UrlField):
+        prop["type"] = "string"
+        prop["format"] = "uri"
+        if field.minlength is not None:
+            prop["minLength"] = field.minlength
+        if field.maxlength is not None:
+            prop["maxLength"] = field.maxlength
+
+    elif isinstance(field, TextareaField):
+        prop["type"] = "string"
+        if field.minlength is not None:
+            prop["minLength"] = field.minlength
+        if field.maxlength is not None:
+            prop["maxLength"] = field.maxlength
+
+    elif isinstance(field, ListField):
+        item_type = _LIST_ITEM_TYPE_MAP.get(field.item_type, "string")
+        prop["type"] = "array"
+        prop["items"] = {"type": item_type}
+        if field.min_items is not None:
+            prop["minItems"] = field.min_items
+        if field.max_items is not None:
+            prop["maxItems"] = field.max_items
+
+    elif isinstance(field, ObjectListField):
+        prop["type"] = "array"
+        prop["items"] = _object_list_item_schema(field)
+        if field.min_items is not None:
+            prop["minItems"] = field.min_items
+        if field.max_items is not None:
+            prop["maxItems"] = field.max_items
+
+    elif isinstance(field, TextField):
+        prop["type"] = "string"
+        if field.minlength is not None:
+            prop["minLength"] = field.minlength
+        if field.maxlength is not None:
+            prop["maxLength"] = field.maxlength
+        if field.pattern is not None:
+            prop["pattern"] = field.pattern
+
+    else:
+        prop["type"] = "string"
+
+    if field.label:
+        prop["title"] = field.label
+    if field.help_text:
+        prop["description"] = field.help_text
+    if field.default_value is not None:
+        prop["default"] = field.default_value
+    if field.readonly:
+        prop["readOnly"] = True
+
+    return prop
+
+
+def form_to_json_schema(form: Form) -> Dict[str, Any]:
+    """Convert a Form definition to a JSON Schema (draft-07) object.
+
+    All fields (including those inside FieldGroups and FormSteps) are
+    flattened into a single ``properties`` mapping via ``form.fields``.
+
+    Returns:
+        A Python dict representing the JSON Schema.
+    """
+    properties: Dict[str, Any] = {}
+    required = []
+
+    for field in form.fields:
+        properties[field.name] = _field_to_json_schema_property(field)
+        if field.required:
+            required.append(field.name)
+
+    schema: Dict[str, Any] = {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "type": "object",
+        "title": form.name,
+        "properties": properties,
+        "additionalProperties": False,
+    }
+    if required:
+        schema["required"] = required
+
+    return schema