core-framework 0.12.9__py3-none-any.whl → 0.12.11__py3-none-any.whl

core/__init__.py

@@ -41,6 +41,15 @@ from core.dependencies import Depends, get_db, get_current_user
 from core.config import Settings, get_settings
 from core.app import CoreApp
 
+# Validation
+from core.validation import (
+    SchemaModelValidator,
+    SchemaModelMismatchError,
+    ValidationWarning,
+    validate_schema,
+    validate_all_viewsets,
+)
+
 # Advanced Fields (UUID7, JSON, etc.)
 from core.fields import (
     uuid7,
@@ -278,7 +287,7 @@ from core.exceptions import (
     MissingDependency,
 )
 
-__version__ = "0.12.9"
+__version__ = "0.12.11"
 __all__ = [
     # Models
     "Model",

core/app.py

@@ -158,6 +158,13 @@ class CoreApp:
     
     async def _startup(self) -> None:
         """Executa tarefas de startup."""
+        import logging
+        logger = logging.getLogger("core.app")
+        
+        # Schema/Model validation (before database init for fail-fast)
+        if getattr(self.settings, "strict_validation", self.settings.debug):
+            await self._validate_schemas()
+        
         # Verifica se deve usar replicas
         if self.settings.has_read_replica:
             # Inicializa com read/write replicas
@@ -195,6 +202,50 @@ class CoreApp:
             if hasattr(result, "__await__"):
                 await result
     
+    async def _validate_schemas(self) -> None:
+        """
+        Validate all ViewSet schemas against their models.
+        
+        Called during startup if strict_validation is enabled.
+        In DEBUG mode, raises SchemaModelMismatchError on critical issues.
+        In production, logs errors but continues.
+        """
+        import logging
+        logger = logging.getLogger("core.app")
+        
+        try:
+            from core.views import validate_pending_viewsets
+            from core.validation import SchemaModelMismatchError
+            
+            logger.info("Running schema/model validations...")
+            
+            # In debug mode, fail fast on critical issues
+            strict = self.settings.debug
+            
+            try:
+                issues = validate_pending_viewsets(strict=strict)
+                
+                if issues:
+                    logger.warning(
+                        f"Schema validation completed with {len(issues)} issues"
+                    )
+                else:
+                    logger.info("Schema validation passed")
+                    
+            except SchemaModelMismatchError as e:
+                if self.settings.debug:
+                    logger.error(f"Schema validation failed: {e}")
+                    raise RuntimeError(
+                        f"Schema validation errors (set DEBUG=False to skip):\n{e}"
+                    ) from e
+                else:
+                    logger.error(f"Schema validation errors (ignored): {e}")
+                    
+        except ImportError:
+            logger.debug("Validation module not available, skipping")
+        except Exception as e:
+            logger.warning(f"Could not validate schemas: {e}")
+    
     async def _shutdown(self) -> None:
         """Executa tarefas de shutdown."""
         # Executa callbacks customizados

core/auth/views.py

@@ -108,14 +108,22 @@ class AuthViewSet(ViewSet):
     
     def _get_register_schema(self) -> type:
         """
-        Bug #5 Fix: Get registration schema with extra fields support.
+        Get registration schema with STRICT extra fields support.
         
-        If extra_register_fields is set, creates a dynamic schema that
-        accepts those additional fields.
+        This method validates against the model to determine if fields are
+        required (NOT NULL) or optional (nullable).
+        
+        Rules:
+            - If model column is NOT NULL and has no default -> REQUIRED in schema
+            - If model column is nullable or has default -> OPTIONAL in schema
         
         Returns:
             Pydantic schema class for registration
         """
+        import logging
+        import warnings
+        logger = logging.getLogger("core.auth")
+        
         # If register_schema was explicitly overridden, use it
         if self.register_schema != BaseRegisterInput:
             return self.register_schema
@@ -124,32 +132,53 @@ class AuthViewSet(ViewSet):
         if not self.extra_register_fields:
             return BaseRegisterInput
         
-        # Create dynamic schema with extra fields
+        # Return cached schema if available
         if self._dynamic_register_schema is not None:
             return self._dynamic_register_schema
         
-        # Build extra fields - all as optional strings by default
-        # Users can provide type hints via annotations in User model
-        extra_fields = {}
         User = self._get_user_model()
-        user_annotations = getattr(User, "__annotations__", {})
+        
+        # Get model column info for nullable/required check
+        model_columns = {}
+        try:
+            from sqlalchemy import inspect
+            mapper = inspect(User)
+            model_columns = {col.name: col for col in mapper.columns}
+        except Exception as e:
+            logger.debug(f"Could not inspect User model: {e}")
+        
+        extra_fields = {}
         
         for field_name in self.extra_register_fields:
-            # Try to get type from User model
-            field_type = user_annotations.get(field_name, str)
-            # Extract actual type from Mapped[...] if needed
-            field_type_str = str(field_type)
-            if "Mapped[" in field_type_str:
-                # It's a Mapped type, try to extract inner type
-                if "str" in field_type_str:
-                    extra_fields[field_name] = (str | None, None)
-                elif "int" in field_type_str:
-                    extra_fields[field_name] = (int | None, None)
-                elif "bool" in field_type_str:
-                    extra_fields[field_name] = (bool | None, None)
+            col = model_columns.get(field_name)
+            
+            if col is not None:
+                # Determine type from model
+                python_type = self._get_python_type_from_column(col.type)
+                
+                # Check if field is required
+                is_nullable = col.nullable
+                has_default = col.default is not None or col.server_default is not None
+                
+                if not is_nullable and not has_default:
+                    # REQUIRED field - use ... (Ellipsis) as default
+                    extra_fields[field_name] = (python_type, ...)
+                    logger.info(
+                        f"Field '{field_name}' is NOT NULL in model, "
+                        f"adding as REQUIRED to register schema"
+                    )
                 else:
-                    extra_fields[field_name] = (str | None, None)
+                    # Optional field
+                    extra_fields[field_name] = (python_type | None, None)
             else:
+                # Field not in model columns, warn and make optional
+                warnings.warn(
+                    f"Field '{field_name}' in extra_register_fields "
+                    f"not found in {User.__name__} model columns. "
+                    f"Adding as optional str.",
+                    UserWarning,
+                    stacklevel=2,
+                )
                 extra_fields[field_name] = (str | None, None)
         
         # Create dynamic model
@@ -160,14 +189,98 @@ class AuthViewSet(ViewSet):
             **extra_fields,
         )
         
-        # Allow extra fields
+        # Allow extra fields (ignore unknown)
         self._dynamic_register_schema.model_config = {
             **BaseRegisterInput.model_config,
-            "extra": "ignore",  # Ignore unknown fields instead of forbidding
+            "extra": "ignore",
         }
         
         return self._dynamic_register_schema
     
+    def _get_python_type_from_column(self, sa_type) -> type:
+        """
+        Convert SQLAlchemy column type to Python type.
+        
+        Args:
+            sa_type: SQLAlchemy type instance
+        
+        Returns:
+            Corresponding Python type
+        """
+        from sqlalchemy import String, Integer, Boolean, Float, Text, DateTime, Date
+        
+        type_map = {
+            String: str,
+            Text: str,
+            Integer: int,
+            Boolean: bool,
+            Float: float,
+        }
+        
+        for sa_cls, py_type in type_map.items():
+            if isinstance(sa_type, sa_cls):
+                return py_type
+        
+        # Check type name for dialect-specific types
+        type_name = type(sa_type).__name__
+        if "String" in type_name or "Text" in type_name or "VARCHAR" in type_name:
+            return str
+        if "Integer" in type_name or "INT" in type_name:
+            return int
+        if "Boolean" in type_name or "BOOL" in type_name:
+            return bool
+        if "Float" in type_name or "Numeric" in type_name or "Decimal" in type_name:
+            return float
+        if "DateTime" in type_name or "Timestamp" in type_name:
+            from datetime import datetime
+            return datetime
+        if "Date" in type_name:
+            from datetime import date
+            return date
+        if "UUID" in type_name:
+            from uuid import UUID
+            return UUID
+        
+        # Default to str
+        return str
+    
+    def _get_extra_field_names(self) -> list[str]:
+        """
+        Auto-detect extra fields from register_schema.
+        
+        Compares register_schema fields with BaseRegisterInput to find
+        additional fields that need to be passed to create_user().
+        
+        This allows users to define a custom register_schema without
+        also having to define extra_register_fields (DRY principle).
+        
+        Returns:
+            List of field names that are in register_schema but not in BaseRegisterInput
+        
+        Example:
+            class CustomRegisterInput(BaseRegisterInput):
+                name: str
+                phone: str | None = None
+            
+            class MyAuthViewSet(AuthViewSet):
+                register_schema = CustomRegisterInput
+                # extra_register_fields not needed!
+            
+            # _get_extra_field_names() returns ["name", "phone"]
+        """
+        schema = self._get_register_schema()
+        
+        # Get base fields (email, password)
+        base_fields = set(BaseRegisterInput.model_fields.keys())
+        
+        # Get schema fields
+        schema_fields = set(schema.model_fields.keys())
+        
+        # Return extra fields (fields in schema but not in base)
+        extra = schema_fields - base_fields
+        
+        return list(extra)
+    
     def _create_tokens(self, user) -> dict:
         """
         Bug #6 Fix: Create access and refresh tokens using current API.
@@ -252,9 +365,12 @@ class AuthViewSet(ViewSet):
                 detail="User with this email already exists"
             )
         
-        # Bug #5 Fix: Extract extra fields for user creation
+        # Extract extra fields for user creation
+        # Auto-detect from schema if extra_register_fields not explicitly defined
+        extra_field_names = self.extra_register_fields or self._get_extra_field_names()
+        
         extra_fields = {}
-        for field_name in self.extra_register_fields:
+        for field_name in extra_field_names:
             value = getattr(validated, field_name, None)
             if value is not None:
                 extra_fields[field_name] = value

core/config.py

@@ -76,6 +76,26 @@ class Settings(BaseSettings):
         description="Chave secreta para criptografia e tokens",
     )
     
+    # =========================================================================
+    # Validation
+    # =========================================================================
+    
+    strict_validation: bool = PydanticField(
+        default=True,
+        description=(
+            "Habilita validação rigorosa de schemas contra models. "
+            "Em modo strict, erros críticos (campo NOT NULL opcional no schema) "
+            "causam falha no startup em DEBUG mode."
+        ),
+    )
+    validation_fail_fast: bool | None = PydanticField(
+        default=None,
+        description=(
+            "Se True, falha no primeiro erro de validação. "
+            "Se None, usa valor de DEBUG."
+        ),
+    )
+    
     # =========================================================================
     # Database
     # =========================================================================

core/validation.py

@@ -0,0 +1,768 @@
+"""
+Sistema de Validação Rigorosa para Core Framework.
+
+Este módulo implementa validação automática entre Pydantic schemas e
+SQLAlchemy models, garantindo consistência e prevenindo erros em runtime.
+
+Regras de Validação:
+    R1: Campo NOT NULL no model = REQUIRED no schema (Erro em strict)
+    R2: max_length do model >= max_length do schema (Warning)
+    R3: Tipo do schema deve ser compatível com model (Warning)
+    R4: Campo extra não existe no model (Warning)
+    R5: Validação executada no startup (Fail-fast em DEBUG)
+
+Usage:
+    from core.validation import SchemaModelValidator
+    
+    # Validar manualmente
+    issues = SchemaModelValidator.validate(
+        UserInput,
+        User,
+        strict=True,
+        context="UserViewSet"
+    )
+    
+    # Ou deixar o framework validar automaticamente no startup
+"""
+
+from __future__ import annotations
+
+import logging
+import warnings
+from typing import TYPE_CHECKING, Any, get_args, get_origin
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+    from pydantic.fields import FieldInfo
+
+logger = logging.getLogger("core.validation")
+
+
+# =============================================================================
+# Exceptions
+# =============================================================================
+
+class SchemaModelMismatchError(Exception):
+    """
+    Raised when schema and model have incompatible field definitions.
+    
+    This error indicates a critical mismatch that will likely cause
+    runtime errors (e.g., database integrity violations).
+    """
+    pass
+
+
+class ValidationWarning(UserWarning):
+    """Warning for non-critical schema/model mismatches."""
+    pass
+
+
+# =============================================================================
+# Type Mapping
+# =============================================================================
+
+# SQLAlchemy type to Python type mapping
+_SQLALCHEMY_TYPE_MAP: dict[str, type] = {
+    "String": str,
+    "Text": str,
+    "VARCHAR": str,
+    "CHAR": str,
+    "Integer": int,
+    "BigInteger": int,
+    "SmallInteger": int,
+    "BIGINT": int,
+    "SMALLINT": int,
+    "INT": int,
+    "INTEGER": int,
+    "Boolean": bool,
+    "BOOLEAN": bool,
+    "Float": float,
+    "FLOAT": float,
+    "Numeric": float,
+    "DECIMAL": float,
+    "DateTime": "datetime",
+    "DATETIME": "datetime",
+    "Date": "date",
+    "DATE": "date",
+    "Time": "time",
+    "TIME": "time",
+    "UUID": "uuid",
+    "JSON": dict,
+    "JSONB": dict,
+    "ARRAY": list,
+    "LargeBinary": bytes,
+    "BLOB": bytes,
+}
+
+
+# =============================================================================
+# Schema Model Validator
+# =============================================================================
+
+class SchemaModelValidator:
+    """
+    Validates that Pydantic schemas match SQLAlchemy models.
+    
+    This validator ensures consistency between your API contracts (schemas)
+    and your database structure (models), preventing common errors like:
+    
+    - Allowing None for NOT NULL columns
+    - Accepting strings longer than the column allows
+    - Type mismatches between schema and model
+    
+    Rules:
+        1. If model field is NOT NULL, schema field MUST be required
+        2. If model field has max_length, schema should validate it
+        3. If model field has constraints, schema should mirror them
+        4. Fields in schema but not in model generate warnings
+    
+    Example:
+        >>> from core.validation import SchemaModelValidator
+        >>> 
+        >>> class User(Model):
+        ...     name = Column(String(100), nullable=False)
+        ...     bio = Column(Text, nullable=True)
+        >>> 
+        >>> class UserInput(BaseModel):
+        ...     name: str | None = None  # BUG: Should be required!
+        ...     bio: str | None = None   # OK: nullable in model
+        >>> 
+        >>> SchemaModelValidator.validate(UserInput, User, strict=True)
+        # Raises SchemaModelMismatchError!
+    """
+    
+    # Cache for validated pairs to avoid re-validation
+    _validated_pairs: set[tuple[type, type]] = set()
+    
+    @classmethod
+    def validate(
+        cls,
+        schema: type["BaseModel"],
+        model: type,
+        *,
+        strict: bool = True,
+        context: str = "",
+        check_output: bool = False,
+    ) -> list[str]:
+        """
+        Validate schema against model.
+        
+        Args:
+            schema: Pydantic schema class (BaseModel subclass)
+            model: SQLAlchemy model class
+            strict: If True, raise error on critical mismatch.
+                   If False, just warn and continue.
+            context: Context for error messages (e.g., "UserViewSet.register")
+            check_output: If True, this is an output schema (less strict)
+        
+        Returns:
+            List of issues found (warnings and errors)
+        
+        Raises:
+            SchemaModelMismatchError: If strict=True and critical issues found
+        
+        Example:
+            >>> issues = SchemaModelValidator.validate(
+            ...     UserCreateInput,
+            ...     User,
+            ...     strict=True,
+            ...     context="UserViewSet.create"
+            ... )
+        """
+        # Check cache
+        cache_key = (schema, model)
+        if cache_key in cls._validated_pairs:
+            return []
+        
+        issues: list[str] = []
+        critical_issues: list[str] = []
+        
+        # Get schema fields
+        schema_fields = cls._get_schema_fields(schema)
+        if not schema_fields:
+            return []
+        
+        # Get model columns
+        model_columns = cls._get_model_columns(model)
+        if not model_columns:
+            logger.debug(f"Could not inspect model {model.__name__}, skipping validation")
+            return []
+        
+        ctx = f"[{context}] " if context else ""
+        
+        for field_name, field_info in schema_fields.items():
+            # Skip fields not in model (could be computed fields)
+            if field_name not in model_columns:
+                continue
+            
+            col_info = model_columns[field_name]
+            
+            # Rule 1: NOT NULL check (critical for input schemas)
+            if not check_output:
+                r1_issue = cls._check_nullable_mismatch(
+                    field_name, field_info, col_info, ctx
+                )
+                if r1_issue:
+                    critical_issues.append(r1_issue)
+            
+            # Rule 2: max_length check
+            r2_issue = cls._check_max_length(
+                field_name, field_info, col_info, ctx
+            )
+            if r2_issue:
+                issues.append(r2_issue)
+            
+            # Rule 3: Type compatibility check
+            r3_issue = cls._check_type_compatibility(
+                field_name, field_info, col_info, ctx
+            )
+            if r3_issue:
+                issues.append(r3_issue)
+        
+        # Rule 4: Check for unknown fields (fields in schema not in model)
+        for field_name in schema_fields:
+            if field_name not in model_columns and field_name not in ("id", "created_at", "updated_at"):
+                issues.append(
+                    f"{ctx}Field '{field_name}' in schema but not in model "
+                    f"{model.__name__}. This may be intentional for computed fields."
+                )
+        
+        # Process issues
+        all_issues = critical_issues + issues
+        
+        for issue in issues:
+            logger.warning(issue)
+            if not strict:
+                warnings.warn(issue, ValidationWarning, stacklevel=3)
+        
+        for issue in critical_issues:
+            logger.error(issue)
+        
+        # Raise if strict mode and critical issues found
+        if strict and critical_issues:
+            cls._validated_pairs.discard(cache_key)
+            raise SchemaModelMismatchError(
+                f"Schema/Model validation failed:\n" + "\n".join(critical_issues)
+            )
+        
+        # Cache successful validation
+        cls._validated_pairs.add(cache_key)
+        
+        return all_issues
+    
+    @classmethod
+    def validate_viewset(
+        cls,
+        viewset_class: type,
+        *,
+        strict: bool = True,
+    ) -> list[str]:
+        """
+        Validate all schemas in a ViewSet against its model.
+        
+        Args:
+            viewset_class: ViewSet class to validate
+            strict: If True, raise on critical issues
+        
+        Returns:
+            List of all issues found
+        """
+        issues: list[str] = []
+        context = viewset_class.__name__
+        
+        model = getattr(viewset_class, "model", None)
+        if not model:
+            return []
+        
+        # Validate input schema (strict for required fields)
+        input_schema = getattr(viewset_class, "input_schema", None)
+        if input_schema:
+            issues.extend(cls.validate(
+                input_schema,
+                model,
+                strict=strict,
+                context=f"{context}.input_schema",
+                check_output=False,
+            ))
+        
+        # Validate output schema (less strict)
+        output_schema = getattr(viewset_class, "output_schema", None)
+        if output_schema:
+            issues.extend(cls.validate(
+                output_schema,
+                model,
+                strict=False,  # Output can have fewer/different fields
+                context=f"{context}.output_schema",
+                check_output=True,
+            ))
+        
+        # Validate create schema
+        create_schema = getattr(viewset_class, "create_schema", None)
+        if create_schema and create_schema != input_schema:
+            issues.extend(cls.validate(
+                create_schema,
+                model,
+                strict=strict,
+                context=f"{context}.create_schema",
+                check_output=False,
+            ))
+        
+        # Validate update schema (optional fields OK)
+        update_schema = getattr(viewset_class, "update_schema", None)
+        if update_schema and update_schema != input_schema:
+            issues.extend(cls.validate(
+                update_schema,
+                model,
+                strict=False,  # Update schemas can have optional fields
+                context=f"{context}.update_schema",
+                check_output=False,
+            ))
+        
+        return issues
+    
+    @classmethod
+    def clear_cache(cls) -> None:
+        """Clear the validation cache."""
+        cls._validated_pairs.clear()
+    
+    # =========================================================================
+    # Private Methods
+    # =========================================================================
+    
+    @classmethod
+    def _get_schema_fields(cls, schema: type["BaseModel"]) -> dict[str, "FieldInfo"]:
+        """Extract field info from Pydantic schema."""
+        try:
+            return schema.model_fields
+        except AttributeError:
+            # Pydantic v1 fallback
+            try:
+                return schema.__fields__
+            except AttributeError:
+                return {}
+    
+    @classmethod
+    def _get_model_columns(cls, model: type) -> dict[str, "ColumnInfo"]:
+        """
+        Extract column info from SQLAlchemy model.
+        
+        Returns dict with column name -> ColumnInfo containing:
+        - nullable: bool
+        - max_length: int | None
+        - python_type: type
+        - sa_type: SQLAlchemy type instance
+        """
+        try:
+            from sqlalchemy import inspect
+            from sqlalchemy.orm import Mapper
+            
+            mapper: Mapper = inspect(model)
+            columns = {}
+            
+            for col in mapper.columns:
+                columns[col.name] = ColumnInfo(
+                    name=col.name,
+                    nullable=col.nullable,
+                    max_length=getattr(col.type, "length", None),
+                    python_type=cls._get_python_type(col.type),
+                    sa_type=col.type,
+                    has_default=col.default is not None or col.server_default is not None,
+                    is_primary_key=col.primary_key,
+                    is_autoincrement=getattr(col, "autoincrement", False),
+                )
+            
+            return columns
+        except Exception as e:
+            logger.debug(f"Could not inspect model: {e}")
+            return {}
+    
+    @classmethod
+    def _get_python_type(cls, sa_type: Any) -> type:
+        """Convert SQLAlchemy type to Python type."""
+        type_name = type(sa_type).__name__
+        
+        # Check direct mapping
+        if type_name in _SQLALCHEMY_TYPE_MAP:
+            mapped = _SQLALCHEMY_TYPE_MAP[type_name]
+            if isinstance(mapped, str):
+                # Handle special types
+                if mapped == "datetime":
+                    from datetime import datetime
+                    return datetime
+                elif mapped == "date":
+                    from datetime import date
+                    return date
+                elif mapped == "time":
+                    from datetime import time
+                    return time
+                elif mapped == "uuid":
+                    from uuid import UUID
+                    return UUID
+            return mapped
+        
+        # Try to get impl type
+        try:
+            impl = getattr(sa_type, "impl", None)
+            if impl:
+                return cls._get_python_type(impl)
+        except Exception:
+            pass
+        
+        # Default to Any
+        return Any
+    
+    @classmethod
+    def _check_nullable_mismatch(
+        cls,
+        field_name: str,
+        field_info: "FieldInfo",
+        col_info: "ColumnInfo",
+        ctx: str,
+    ) -> str | None:
+        """
+        Rule 1: Check if NOT NULL column has optional schema field.
+        
+        This is a CRITICAL issue - will cause IntegrityError at runtime.
+        """
+        # Skip primary keys and auto-generated fields
+        if col_info.is_primary_key or col_info.is_autoincrement:
+            return None
+        
+        # Skip fields with defaults
+        if col_info.has_default:
+            return None
+        
+        # Check if model requires the field (NOT NULL, no default)
+        model_requires = not col_info.nullable and not col_info.has_default
+        
+        # Check if schema makes field optional
+        schema_optional = not cls._is_field_required(field_info)
+        
+        if model_requires and schema_optional:
+            return (
+                f"{ctx}CRITICAL: Field '{field_name}' is NOT NULL in model "
+                f"but OPTIONAL in schema. This WILL cause IntegrityError! "
+                f"Make the field required in the schema."
+            )
+        
+        return None
+    
+    @classmethod
+    def _check_max_length(
+        cls,
+        field_name: str,
+        field_info: "FieldInfo",
+        col_info: "ColumnInfo",
+        ctx: str,
+    ) -> str | None:
+        """
+        Rule 2: Check if schema allows values longer than model accepts.
+        """
+        if not col_info.max_length:
+            return None
+        
+        schema_max = cls._get_schema_max_length(field_info)
+        
+        if schema_max is None:
+            return (
+                f"{ctx}Field '{field_name}' has max_length={col_info.max_length} "
+                f"in model but no length validation in schema. "
+                f"Add max_length constraint to prevent truncation."
+            )
+        
+        if schema_max > col_info.max_length:
+            return (
+                f"{ctx}Field '{field_name}' allows {schema_max} chars in schema "
+                f"but model only accepts {col_info.max_length}. "
+                f"Values may be truncated or cause errors."
+            )
+        
+        return None
+    
+    @classmethod
+    def _check_type_compatibility(
+        cls,
+        field_name: str,
+        field_info: "FieldInfo",
+        col_info: "ColumnInfo",
+        ctx: str,
+    ) -> str | None:
+        """
+        Rule 3: Check if schema type is compatible with model type.
+        """
+        schema_type = cls._get_schema_type(field_info)
+        model_type = col_info.python_type
+        
+        if schema_type is None or model_type is Any:
+            return None
+        
+        # Handle Optional types
+        if get_origin(schema_type) is type(None):
+            return None
+        
+        # Unwrap Optional/Union
+        schema_type = cls._unwrap_optional(schema_type)
+        
+        if schema_type is Any:
+            return None
+        
+        # Check compatibility
+        if not cls._types_compatible(schema_type, model_type):
+            return (
+                f"{ctx}Field '{field_name}' has type {model_type.__name__} in model "
+                f"but {schema_type} in schema. Types may be incompatible."
+            )
+        
+        return None
+    
+    @classmethod
+    def _is_field_required(cls, field_info: "FieldInfo") -> bool:
+        """Check if Pydantic field is required."""
+        try:
+            # Pydantic v2
+            return field_info.is_required()
+        except (AttributeError, TypeError):
+            pass
+        
+        try:
+            # Check default
+            if field_info.default is not None:
+                return False
+            if field_info.default_factory is not None:
+                return False
+            # Check if explicitly required
+            from pydantic_core import PydanticUndefined
+            return field_info.default is PydanticUndefined
+        except Exception:
+            pass
+        
+        # Fallback: assume required if no default
+        return getattr(field_info, "default", ...) is ...
+    
+    @classmethod
+    def _get_schema_max_length(cls, field_info: "FieldInfo") -> int | None:
+        """Extract max_length from Pydantic field metadata."""
+        # Check metadata
+        metadata = getattr(field_info, "metadata", []) or []
+        for meta in metadata:
+            if hasattr(meta, "max_length"):
+                return meta.max_length
+        
+        # Check json_schema_extra
+        json_extra = getattr(field_info, "json_schema_extra", None)
+        if json_extra and isinstance(json_extra, dict):
+            return json_extra.get("maxLength")
+        
+        return None
+    
+    @classmethod
+    def _get_schema_type(cls, field_info: "FieldInfo") -> type | None:
+        """Extract type from Pydantic field."""
+        try:
+            return field_info.annotation
+        except AttributeError:
+            return getattr(field_info, "outer_type_", None)
+    
+    @classmethod
+    def _unwrap_optional(cls, t: type) -> type:
+        """Unwrap Optional[X] or X | None to X."""
+        from types import UnionType
+        
+        origin = get_origin(t)
+        
+        # Handle Union types (including X | None)
+        if origin is UnionType or (hasattr(t, "__class__") and t.__class__ is UnionType):
+            args = get_args(t)
+            non_none = [a for a in args if a is not type(None)]
+            if len(non_none) == 1:
+                return non_none[0]
+            return t
+        
+        # Handle typing.Union
+        try:
+            from typing import Union
+            if origin is Union:
+                args = get_args(t)
+                non_none = [a for a in args if a is not type(None)]
+                if len(non_none) == 1:
+                    return non_none[0]
+        except Exception:
+            pass
+        
+        return t
+    
+    @classmethod
+    def _types_compatible(cls, schema_type: type, model_type: type) -> bool:
+        """Check if schema type is compatible with model type."""
+        # Same type
+        if schema_type is model_type:
+            return True
+        
+        # Both are string-like
+        if schema_type is str and model_type is str:
+            return True
+        
+        # Both are numeric
+        numeric = (int, float)
+        if schema_type in numeric and model_type in numeric:
+            return True
+        
+        # Check subclass
+        try:
+            if isinstance(schema_type, type) and isinstance(model_type, type):
+                return issubclass(schema_type, model_type) or issubclass(model_type, schema_type)
+        except TypeError:
+            pass
+        
+        return True  # Be permissive for unknown types
+
+
+# =============================================================================
+# Column Info Data Class
+# =============================================================================
+
+class ColumnInfo:
+    """Information about a SQLAlchemy column."""
+    
+    __slots__ = (
+        "name",
+        "nullable",
+        "max_length",
+        "python_type",
+        "sa_type",
+        "has_default",
+        "is_primary_key",
+        "is_autoincrement",
+    )
+    
+    def __init__(
+        self,
+        name: str,
+        nullable: bool,
+        max_length: int | None,
+        python_type: type,
+        sa_type: Any,
+        has_default: bool = False,
+        is_primary_key: bool = False,
+        is_autoincrement: bool = False,
+    ):
+        self.name = name
+        self.nullable = nullable
+        self.max_length = max_length
+        self.python_type = python_type
+        self.sa_type = sa_type
+        self.has_default = has_default
+        self.is_primary_key = is_primary_key
+        self.is_autoincrement = is_autoincrement
+
+
+# =============================================================================
+# Validation Decorator
+# =============================================================================
+
+def validate_schema(
+    schema: type["BaseModel"],
+    model: type,
+    *,
+    strict: bool = True,
+    context: str = "",
+):
+    """
+    Decorator to validate schema against model.
+    
+    Usage:
+        @validate_schema(UserInput, User, context="create_user")
+        async def create_user(data: UserInput) -> User:
+            ...
+    """
+    def decorator(func):
+        # Validate on decoration (import time)
+        SchemaModelValidator.validate(
+            schema,
+            model,
+            strict=strict,
+            context=context or func.__name__,
+        )
+        return func
+    return decorator
+
+
+# =============================================================================
+# Startup Validation
+# =============================================================================
+
+def validate_all_viewsets(
+    viewsets: list[type],
+    *,
+    strict: bool | None = None,
+    fail_fast: bool | None = None,
+) -> list[str]:
+    """
+    Validate all registered viewsets.
+    
+    Called automatically during application startup.
+    
+    Args:
+        viewsets: List of ViewSet classes to validate
+        strict: Override strict mode (default: based on DEBUG setting)
+        fail_fast: If True, raise on first error (default: DEBUG mode)
+    
+    Returns:
+        List of all issues found
+    
+    Raises:
+        SchemaModelMismatchError: If fail_fast and critical issues found
+    """
+    from core.config import get_settings
+    
+    settings = get_settings()
+    
+    if strict is None:
+        strict = getattr(settings, "strict_validation", getattr(settings, "debug", True))
+    
+    if fail_fast is None:
+        fail_fast = getattr(settings, "debug", True)
+    
+    logger.info(f"Validating {len(viewsets)} viewsets (strict={strict}, fail_fast={fail_fast})")
+    
+    all_issues: list[str] = []
+    critical_errors: list[str] = []
+    
+    for viewset in viewsets:
+        try:
+            issues = SchemaModelValidator.validate_viewset(
+                viewset,
+                strict=strict,
+            )
+            all_issues.extend(issues)
+        except SchemaModelMismatchError as e:
+            critical_errors.append(str(e))
+            if fail_fast:
+                raise
+    
+    if critical_errors and not fail_fast:
+        logger.error(
+            f"Schema validation found {len(critical_errors)} critical errors:\n" +
+            "\n".join(critical_errors)
+        )
+    
+    if all_issues:
+        logger.warning(f"Schema validation found {len(all_issues)} total issues")
+    else:
+        logger.info("Schema validation passed")
+    
+    return all_issues
+
+
+# =============================================================================
+# Exports
+# =============================================================================
+
+__all__ = [
+    "SchemaModelValidator",
+    "SchemaModelMismatchError",
+    "ValidationWarning",
+    "ColumnInfo",
+    "validate_schema",
+    "validate_all_viewsets",
+]

core/views.py

@@ -44,6 +44,58 @@ ModelT = TypeVar("ModelT")
 InputT = TypeVar("InputT", bound=InputSchema)
 OutputT = TypeVar("OutputT", bound=OutputSchema)
 
+# Registry for viewsets pending validation
+_pending_viewsets: set[type] = set()
+
+
+def validate_pending_viewsets(*, strict: bool | None = None) -> list[str]:
+    """
+    Validate all pending viewsets.
+    
+    Called automatically during application startup.
+    
+    Args:
+        strict: Override strict mode. If None, uses each viewset's setting.
+    
+    Returns:
+        List of all validation issues found
+    """
+    import logging
+    logger = logging.getLogger("core.views")
+    
+    if not _pending_viewsets:
+        return []
+    
+    logger.debug(f"Validating {len(_pending_viewsets)} viewsets...")
+    
+    all_issues: list[str] = []
+    
+    for viewset_cls in list(_pending_viewsets):
+        try:
+            vs_strict = strict if strict is not None else viewset_cls.strict_validation
+            
+            # Temporarily set strict mode
+            original_strict = viewset_cls.strict_validation
+            viewset_cls.strict_validation = vs_strict
+            
+            issues = viewset_cls._validate_schemas()
+            all_issues.extend(issues)
+            
+            # Restore
+            viewset_cls.strict_validation = original_strict
+            
+        except Exception as e:
+            all_issues.append(f"{viewset_cls.__name__}: {e}")
+    
+    _pending_viewsets.clear()
+    
+    if all_issues:
+        logger.warning(f"ViewSet validation found {len(all_issues)} issues")
+    else:
+        logger.debug("ViewSet validation passed")
+    
+    return all_issues
+
 
 # =============================================================================
 # Decorator para actions customizadas
@@ -242,6 +294,62 @@ class ViewSet(Generic[ModelT, InputT, OutputT]):
     # Formato: {"field_name": [validator1, validator2]}
     field_validators: ClassVar[dict[str, list[AsyncValidator]]] = {}
     
+    # Schema/Model Validation
+    # Se True, valida schemas contra model no startup (falha em DEBUG)
+    strict_validation: ClassVar[bool] = True
+    # Cache de validação
+    _schema_validated: ClassVar[bool] = False
+    
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        """
+        Called when a ViewSet subclass is created.
+        
+        Registers the viewset for startup validation.
+        """
+        super().__init_subclass__(**kwargs)
+        cls._schema_validated = False
+        # Register for lazy validation
+        _pending_viewsets.add(cls)
+    
+    @classmethod
+    def _validate_schemas(cls) -> list[str]:
+        """
+        Validate schemas against model.
+        
+        Called automatically on application startup or first request.
+        
+        Returns:
+            List of validation issues found
+        
+        Raises:
+            SchemaModelMismatchError: If strict_validation=True and critical issues
+        """
+        if cls._schema_validated:
+            return []
+        
+        model = getattr(cls, "model", None)
+        if not model:
+            cls._schema_validated = True
+            return []
+        
+        try:
+            from core.validation import SchemaModelValidator
+            
+            issues = SchemaModelValidator.validate_viewset(
+                cls,
+                strict=cls.strict_validation,
+            )
+            
+            cls._schema_validated = True
+            return issues
+        except Exception as e:
+            import logging
+            logging.getLogger("core.views").warning(
+                f"Could not validate {cls.__name__}: {e}"
+            )
+            cls._schema_validated = True
+            return []
+    
     def __init__(self) -> None:
         self.action: str | None = None
         self.request: Request | None = None

{core_framework-0.12.9.dist-info → core_framework-0.12.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-framework
-Version: 0.12.9
+Version: 0.12.11
 Summary: Core Framework - Django-inspired, FastAPI-powered. Alta performance, baixo acoplamento, produtividade extrema.
 Project-URL: Homepage, https://github.com/SorPuti/core-framework
 Project-URL: Documentation, https://github.com/SorPuti/core-framework#readme

{core_framework-0.12.9.dist-info → core_framework-0.12.11.dist-info}/RECORD

@@ -1,7 +1,7 @@
-core/__init__.py,sha256=-TnrJlKDPs8jlRHE0RQMWJ1Tw4LZpC9zc9IYMG4X_38,12058
-core/app.py,sha256=sCA3mJI696i7MIjrPxfOr5zEYt0njarQfHHy3EAajk4,21071
+core/__init__.py,sha256=tvZLlVpXoyS3BPdF0hivmXeVRomd2awBRg-ZeAxvyMg,12232
+core/app.py,sha256=SsMC5Vlj6PNgACXlfeccOm6CQEKfgh3q3X2p9ubRDlQ,23092
 core/choices.py,sha256=rhcL3p2dB7RK99zIilpmoTFVcibQEIaRpz0CY0kImCE,10502
-core/config.py,sha256=2-MVF9nLoYmxpYYH_Gzn4-Sa3MU87YZskRPtlNyhg6Q,14049
+core/config.py,sha256=dq4O7QBdrdwj-fZRe2yhX1fKyi_Uetb6sx9-RovJ-9c,14771
 core/database.py,sha256=XqB5tZnb9UYDbVGIh96YbmbGJZMqln6-diPBHCr3VWk,11564
 core/datetime.py,sha256=bzqlAj3foA-lzbhXjlEiDNR2D-nwXu9mpxpdcUb-Pmw,32730
 core/dependencies.py,sha256=p207A8qwj-QVAb7nNSe3HxkefClwSQNQQylSFFa-meU,11627
@@ -15,8 +15,9 @@ core/relations.py,sha256=UbdRgj0XQGI4lv2FQV1ImSAwu4Pn8yxTkSsdzR3m8cM,21372
 core/routing.py,sha256=vIiJN8bQ2836WW2zUKTJVBTC8RpjtDYgEGdz7mldnGc,15422
 core/serializers.py,sha256=gR5Y7wTACm1pECkUEpAKBUbPmONGLMDDwej4fyIiOdo,9438
 core/tenancy.py,sha256=R4tNrLcAgRRDSqOvJS2IRXcD2J-zoCE4ng01ip9xWKI,9169
+core/validation.py,sha256=F6sq6g2hzhgQ10nVMc9cdXqK4Og00nCjgdkAi5TlpJw,24533
 core/validators.py,sha256=LCDyvqwIKnMaUEdaVx5kWveZt3XsydknZ_bxBL4ic5U,27895
-core/views.py,sha256=Vm2FREET0IJ2JZbClNJ0vvZ6RN5aQKC1sDXsrOb4-SY,43319
+core/views.py,sha256=jP2HypxplVP5nHJfmhQ2d4pegnVYhl8KXVydc25l7V4,46541
 core/auth/__init__.py,sha256=_yr4rMMvDt_uKujzkKfqlQZ6x9UiQ6jmRppw14hTQNc,4645
 core/auth/backends.py,sha256=PkLk2RQN2rQdtYSiN0mn7cqSp95hnLjO9xTFZqSsPF8,10486
 core/auth/base.py,sha256=Q7vXgwTmgdmyW7G8eJmDket2bKB_8YFnraZ_kK9_gTs,21425
@@ -28,7 +29,7 @@ core/auth/models.py,sha256=aEE7deQKPS1aH0Btzzh3Z1Bwuqy8zvLZwu4JFEmiUNk,34058
 core/auth/permissions.py,sha256=v3ykAgNpq5wJ0NkuC_FuveMctOkDfM9Xp11XEnUAuBg,12461
 core/auth/schemas.py,sha256=L0W96dOD348rJDGeu1K5Rz3aJj-GdwMr2vbwwsYfo2g,3469
 core/auth/tokens.py,sha256=jOF40D5O8WRG8klRwMBuSG-jOhdsp1irXn2aZ2puNSg,9149
-core/auth/views.py,sha256=3gMaq8pzWoWr29ExJk21JgGay2fE3Fq3Tz99Wb_ftvE,14203
+core/auth/views.py,sha256=psL4g2Fe1saXn1eCnm6b18E2JCbALixVJahr2OIaLvI,18211
 core/cli/__init__.py,sha256=EOYSATzRugHD2oJ1SPfTIMUygUoNJnO_dRt2yJrkQcU,542
 core/cli/main.py,sha256=0WAO1deegd2Yja19ggDbX4j6p5S_p2KrmyAmale9HZs,124490
 core/deployment/__init__.py,sha256=RNcBRO9oB3WRnhtTTwM6wzVEcUKpKF4XfRkGSbbykIc,794
@@ -86,7 +87,7 @@ example/auth.py,sha256=zBpLutb8lVKnGfQqQ2wnyygsSutHYZzeJBuhnFhxBaQ,4971
 example/models.py,sha256=xKdx0kJ9n0tZ7sCce3KhV3BTvKvsh6m7G69eFm3ukf0,4549
 example/schemas.py,sha256=wJ9QofnuHp4PjtM_IuMMBLVFVDJ4YlwcF6uQm1ooKiY,6139
 example/views.py,sha256=GQwgQcW6yoeUIDbF7-lsaZV7cs8G1S1vGVtiwVpZIQE,14338
-core_framework-0.12.9.dist-info/METADATA,sha256=LSnpglEoRk6NuOGA5lR2GffKmAS5Dgs7aOGj58GYTBk,13020
-core_framework-0.12.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-core_framework-0.12.9.dist-info/entry_points.txt,sha256=MJytamxHbn0CyH3HbxiP-PqOWekjYUo2CA6EWiKWuSI,78
-core_framework-0.12.9.dist-info/RECORD,,
+core_framework-0.12.11.dist-info/METADATA,sha256=VpC4knI1g1olWe8cq5H-A1M8W84N6ONhq9pLIp4wrrg,13021
+core_framework-0.12.11.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+core_framework-0.12.11.dist-info/entry_points.txt,sha256=MJytamxHbn0CyH3HbxiP-PqOWekjYUo2CA6EWiKWuSI,78
+core_framework-0.12.11.dist-info/RECORD,,