Add cli commands tooling

Author: LeanderCS

docs/source/guides/cli.rst

@@ -11,4 +11,5 @@ Guides
     testing_debugging
     create_own_components
     frontend_validation
+    cli
     compile

docs/source/guides/index.rst

@@ -0,0 +1,3 @@
+from .cli import main
+
+__all__ = ["main"]

flask_inputfilter/cli/__init__.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+import click
+
+
+@click.group()
+def main() -> None:
+    """Flask InputFilter CLI."""

flask_inputfilter/cli/cli.py

@@ -0,0 +1,5 @@
+from .json_schema import JsonSchemaCodegen
+from .mapper import TypeMapper
+from .renderer import TemplateRenderer
+
+__all__ = ["JsonSchemaCodegen", "TemplateRenderer", "TypeMapper"]

flask_inputfilter/cli/codegen/__init__.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Union
+
+import jsonschema
+
+from .mapper import TypeMapper
+from .renderer import TemplateRenderer
+
+
+class JsonSchemaCodegen:
+    """JSON Schema to InputFilter code generator using jsonschema library."""
+
+    @staticmethod
+    def validate_schema(schema: Dict[str, Any]) -> None:
+        """Validate the JSON schema using jsonschema library."""
+        try:
+            jsonschema.Draft202012Validator.check_schema(schema)
+        except jsonschema.SchemaError as e:
+            raise ValueError(f"Invalid JSON Schema: {e}")
+
+    @staticmethod
+    def build_context(
+        schema: Dict[str, Any],
+        class_name: str,
+        base_class: str = "InputFilter",
+        base_module: str = "flask_inputfilter",
+        import_field_from: Union[str, None] = None,
+        field_name: str = "field",
+        strict: bool = False,
+        docstring: bool = True,
+    ) -> Dict[str, Any]:
+        """Build template context from JSON schema."""
+        mapper = TypeMapper()
+
+        if strict:
+            JsonSchemaCodegen.validate_schema(schema)
+
+        required_fields = set(schema.get("required", []))
+        properties: Dict[str, Any] = schema.get("properties", {})
+
+        if not properties and strict:
+            raise ValueError(
+                "No properties found in schema and strict mode is enabled"
+            )
+
+        fields = []
+        for name, spec in properties.items():
+            field_def = mapper.map_field(name, spec, required_fields)
+            fields.append(field_def)
+
+        global_validators = mapper.get_global_validators(schema)
+        imports = mapper.get_imports()
+
+        return {
+            "base_module": base_module,
+            "base_class": base_class,
+            "class_name": class_name,
+            "schema_title": schema.get("title", ""),
+            "schema_description": schema.get("description", ""),
+            "docstring": docstring,
+            "import_field_from": import_field_from,
+            "field_name": field_name,
+            "import_filters": imports["filters"],
+            "import_validators": imports["validators"],
+            "import_enums": imports["enums"],
+            "fields": fields,
+            "global_validators": global_validators,
+        }
+
+    @staticmethod
+    def generate_from_schema(
+        schema: Dict[str, Any],
+        class_name: str,
+        template_path: str,
+        **kwargs,
+    ) -> str:
+        """Generate InputFilter code from JSON schema."""
+        context = JsonSchemaCodegen.build_context(schema, class_name, **kwargs)
+        return TemplateRenderer().render_inputfilter(template_path, context)
+
+    @staticmethod
+    def generate_from_file(
+        schema_path: Union[str, Path],
+        class_name: str,
+        template_path: str,
+        **kwargs,
+    ) -> str:
+        """Generate InputFilter code from JSON schema file."""
+        schema = json.loads(Path(schema_path).read_text(encoding="utf-8"))
+        return JsonSchemaCodegen.generate_from_schema(
+            schema, class_name, template_path, **kwargs
+        )

flask_inputfilter/cli/codegen/json_schema.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Set
+
+
+class TypeMapper:
+    """Enhanced mapping from JSON Schema types to Flask InputFilter
+    components."""
+
+    FILTERS = {
+        "string": ["StringTrimFilter"],
+        "integer": [],
+        "number": ["ToFloatFilter"],
+        "boolean": [],
+    }
+
+    FORMAT_VALIDATORS = {
+        "email": "RegexValidator(RegexEnum.EMAIL.value, 'Invalid email format.')",
+        "uri": "RegexValidator(RegexEnum.URL.value, 'Invalid URL format.')",
+        "uuid": "IsUUIDValidator()",
+        "date": "IsDateValidator()",
+        "date-time": "IsDateTimeValidator()",
+        "ipv4": "RegexValidator(RegexEnum.IPV4.value, 'Invalid IPv4 address.')",
+        "ipv6": "RegexValidator(RegexEnum.IPV6.value, 'Invalid IPv6 address.')",
+    }
+
+    TYPE_VALIDATORS = {
+        "string": "IsStringValidator()",
+        "integer": "IsIntegerValidator()",
+        "number": "IsFloatValidator()",
+        "boolean": "IsBooleanValidator()",
+        "array": "IsArrayValidator()",
+    }
+
+    def __init__(self) -> None:
+        self.import_filters: Set[str] = set()
+        self.import_validators: Set[str] = set()
+        self.import_enums: Set[str] = set()
+
+    def map_field(
+        self, attr: str, spec: Dict[str, Any], required_fields: Set[str]
+    ) -> dict:
+        """Map a single field from JSON schema to InputFilter field
+        definition."""
+        filters: List[str] = []
+        validators: List[str] = []
+
+        field_type = spec.get("type")
+        field_format = spec.get("format")
+
+        # Add type-specific filters
+        for f in self.FILTERS.get(field_type, []):
+            filters.append(f"{f}()")
+            self.import_filters.add(f)
+
+        # Add format-specific validators
+        if field_format and field_format in self.FORMAT_VALIDATORS:
+            validator_def = self.FORMAT_VALIDATORS[field_format]
+            validators.append(validator_def)
+
+            # Extract validator class names for imports
+            if "RegexValidator" in validator_def:
+                self.import_validators.add("RegexValidator")
+                self.import_enums.add("RegexEnum")
+            elif "IsUUIDValidator" in validator_def:
+                self.import_validators.add("IsUUIDValidator")
+            elif "IsDateValidator" in validator_def:
+                self.import_validators.add("IsDateValidator")
+            elif "IsDateTimeValidator" in validator_def:
+                self.import_validators.add("IsDateTimeValidator")
+
+        # Add basic type validator if no format validator
+        elif field_type in self.TYPE_VALIDATORS and field_type not in [
+            "array"
+        ]:
+            validators.append(self.TYPE_VALIDATORS[field_type])
+            validator_name = self.TYPE_VALIDATORS[field_type].split("(")[0]
+            self.import_validators.add(validator_name)
+
+        # Handle numeric ranges
+        if field_type in ("integer", "number"):
+            minimum = spec.get("minimum")
+            maximum = spec.get("maximum")
+            if minimum is not None or maximum is not None:
+                args = []
+                if minimum is not None:
+                    args.append(f"min_value={minimum}")
+                if maximum is not None:
+                    args.append(f"max_value={maximum}")
+                validators.append(f"RangeValidator({', '.join(args)})")
+                self.import_validators.add("RangeValidator")
+
+        # Handle string constraints
+        if field_type == "string":
+            min_length = spec.get("minLength")
+            max_length = spec.get("maxLength")
+            if min_length is not None or max_length is not None:
+                args = []
+                if min_length is not None:
+                    args.append(f"min_length={min_length}")
+                if max_length is not None:
+                    args.append(f"max_length={max_length}")
+                validators.append(f"LengthValidator({', '.join(args)})")
+                self.import_validators.add("LengthValidator")
+
+        # Handle pattern validation
+        pattern = spec.get("pattern")
+        if pattern:
+            validators.append(
+                f"RegexValidator(r'{pattern}', 'Pattern validation failed.')"
+            )
+            self.import_validators.add("RegexValidator")
+
+        # Handle enum validation
+        enum_values = spec.get("enum")
+        if enum_values:
+            validators.append(f"InArrayValidator({json.dumps(enum_values)})")
+            self.import_validators.add("InArrayValidator")
+
+        # Handle arrays
+        if field_type == "array":
+            validators.append("IsArrayValidator()")
+            self.import_validators.add("IsArrayValidator")
+
+            # Add array length validation if specified
+            min_items = spec.get("minItems")
+            max_items = spec.get("maxItems")
+            if min_items is not None or max_items is not None:
+                args = []
+                if min_items is not None:
+                    args.append(f"min_length={min_items}")
+                if max_items is not None:
+                    args.append(f"max_length={max_items}")
+                validators.append(f"ArrayLengthValidator({', '.join(args)})")
+                self.import_validators.add("ArrayLengthValidator")
+
+        return {
+            "attr": attr,
+            "type": field_type,
+            "required": attr in required_fields,
+            "default": spec.get("default"),
+            "description": spec.get("description", ""),
+            "filters": filters,
+            "validators": validators,
+        }
+
+    def get_global_validators(self, schema: Dict[str, Any]) -> List[str]:
+        """Get global validators based on schema properties."""
+        global_validators = []
+
+        if schema.get("additionalProperties") is False:
+            gv = "CustomJsonValidator({'additionalProperties': False})"
+            global_validators.append(gv)
+            self.import_validators.add("CustomJsonValidator")
+
+        return global_validators
+
+    def get_imports(self) -> dict:
+        """Get all required imports based on used components."""
+        return {
+            "filters": sorted(self.import_filters),
+            "validators": sorted(self.import_validators),
+            "enums": sorted(self.import_enums),
+        }

flask_inputfilter/cli/codegen/mapper.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Union
+
+from jinja2 import Environment, FileSystemLoader, StrictUndefined
+
+
+class TemplateRenderer:
+    """Template rendering engine for code generation."""
+
+    def __init__(self, template_dir: Union[str, Path] = None):
+        if template_dir is None:
+            template_dir = Path(__file__).parent.parent / "templates"
+
+        self.env = Environment(
+            loader=FileSystemLoader(str(template_dir)),
+            undefined=StrictUndefined,
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+        self.env.filters["python_json"] = TemplateRenderer._python_json_filter
+
+    @staticmethod
+    def _python_json_filter(value):
+        """Convert value to Python-compatible representation."""
+        if value is None:
+            return "None"
+        if value is True:
+            return "True"
+        if value is False:
+            return "False"
+        if isinstance(value, str):
+            return json.dumps(value)
+        if isinstance(value, (int, float)):
+            return str(value)
+        return json.dumps(value)
+
+    def render_inputfilter(
+        self, template_path: str, context: Dict[str, Any]
+    ) -> str:
+        """Render an InputFilter class from template."""
+        template = self.env.get_template(Path(template_path).name)
+        return template.render(**context)
+
+    def render_test_file(self, context: Dict[str, Any]) -> str:
+        """Render a test file for the generated InputFilter."""
+        template = self.env.get_template("test.py.j2")
+        return template.render(**context)
+
+    def render_config_file(self, context: Dict[str, Any]) -> str:
+        """Render a configuration file template."""
+        template = self.env.get_template("config.yaml.j2")
+        return template.render(**context)

flask_inputfilter/cli/codegen/renderer.py

@@ -0,0 +1,3 @@
+from . import generate_inputfilter, help
+
+__all__ = ["generate_inputfilter", "help"]