core-framework 0.12.8__tar.gz → 0.12.10__tar.gz

{core_framework-0.12.8 → core_framework-0.12.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-framework
-Version: 0.12.8
+Version: 0.12.10
 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.8 → core_framework-0.12.10}/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.8"
+__version__ = "0.12.10"
 __all__ = [
     # Models
     "Model",

{core_framework-0.12.8 → core_framework-0.12.10}/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_framework-0.12.8 → core_framework-0.12.10}/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,61 @@ 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 _create_tokens(self, user) -> dict:
         """
         Bug #6 Fix: Create access and refresh tokens using current API.

{core_framework-0.12.8 → core_framework-0.12.10}/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
     # =========================================================================