core-framework 0.12.2__tar.gz → 0.12.3__tar.gz

{core_framework-0.12.2 → core_framework-0.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-framework
-Version: 0.12.2
+Version: 0.12.3
 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.2 → core_framework-0.12.3}/core/__init__.py

@@ -278,7 +278,7 @@ from core.exceptions import (
     MissingDependency,
 )
 
-__version__ = "0.12.2"
+__version__ = "0.12.3"
 __all__ = [
     # Models
     "Model",

{core_framework-0.12.2 → core_framework-0.12.3}/core/auth/middleware.py

@@ -182,26 +182,65 @@ class AuthenticationMiddleware(BaseHTTPMiddleware):
         if User is None:
             return None
         
-        # Get database session
-        from core.database import get_read_session
+        # Bug #3 & #4 Fix: Get database session correctly
+        # The middleware runs outside FastAPI DI context, so we need to
+        # handle database session creation carefully
+        db = await self._get_db_session()
+        if db is None:
+            return None
         
-        async for db in get_read_session():
-            try:
-                # Convert user_id to correct type
-                user_id_converted = self._convert_user_id(user_id, User)
-                
-                user = await User.objects.using(db).filter(id=user_id_converted).first()
-                
-                if user is None:
-                    return None
-                
-                # Check if user is active
-                if hasattr(user, "is_active") and not user.is_active:
-                    return None
-                
-                return user
-            except Exception:
+        try:
+            # Convert user_id to correct type
+            user_id_converted = self._convert_user_id(user_id, User)
+            
+            user = await User.objects.using(db).filter(id=user_id_converted).first()
+            
+            if user is None:
                 return None
+            
+            # Check if user is active
+            if hasattr(user, "is_active") and not user.is_active:
+                return None
+            
+            return user
+        except Exception:
+            return None
+        finally:
+            await db.close()
+    
+    async def _get_db_session(self) -> Any | None:
+        """
+        Get a database session for authentication.
+        
+        Bug #3 & #4 Fix: Handles both initialized and uninitialized database states.
+        Creates session directly from engine if normal path fails.
+        
+        Returns:
+            AsyncSession or None if database not available
+        """
+        # Try 1: Use the standard get_read_session (if database is initialized)
+        try:
+            from core.database import get_read_session, _read_session_factory
+            
+            if _read_session_factory is not None:
+                return _read_session_factory()
+        except (RuntimeError, ImportError):
+            pass
+        
+        # Try 2: Create session from settings (lazy initialization)
+        try:
+            from core.config import get_settings
+            from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
+            
+            settings = get_settings()
+            db_url = getattr(settings, 'database_read_url', None) or getattr(settings, 'database_url', None)
+            
+            if db_url:
+                engine = create_async_engine(db_url, echo=False)
+                session_factory = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+                return session_factory()
+        except Exception:
+            pass
         
         return None
     

{core_framework-0.12.2 → core_framework-0.12.3}/core/auth/models.py

@@ -27,12 +27,14 @@ Uso:
 from __future__ import annotations
 
 from typing import Any, ClassVar, TYPE_CHECKING
+from uuid import UUID
 
 from sqlalchemy import Table, Column, Integer, ForeignKey, inspect
 from sqlalchemy.orm import Mapped, relationship, declared_attr
 from sqlalchemy.dialects.postgresql import UUID as PG_UUID
 
 from core.models import Model, Field
+from core.fields import AdvancedField
 from core.auth.base import get_password_hasher, get_auth_config
 from core.datetime import timezone, DateTime
 
@@ -69,7 +71,6 @@ def _get_pk_column_type(model_class: type) -> type:
     from sqlalchemy import Integer, BigInteger, String
     from sqlalchemy.dialects.postgresql import UUID as PG_UUID
     from sqlalchemy import Uuid
-    import uuid
     
     # Verifica cache primeiro
     cache_key = f"{model_class.__module__}.{model_class.__name__}"
@@ -790,12 +791,9 @@ class AbstractUUIDUser(AbstractUser):
     
     __abstract__ = True
     
-    # Importa aqui para evitar circular import
-    from core.fields import AdvancedField
-    from uuid import UUID as UUIDType
-    
     # Override: usa UUID como PK
-    id: Mapped[UUIDType] = AdvancedField.uuid_pk()
+    # UUID importado no topo do módulo para resolução correta de tipos
+    id: Mapped[UUID] = AdvancedField.uuid_pk()
 
 
 # =============================================================================

{core_framework-0.12.2 → core_framework-0.12.3}/core/middleware.py

@@ -736,11 +736,16 @@ class SecurityHeadersMiddleware(BaseMiddleware):
 # =============================================================================
 
 _builtin_middlewares.update({
+    # Pre-built middlewares from this module
     "timing": "core.middleware.TimingMiddleware",
     "request_id": "core.middleware.RequestIDMiddleware",
     "logging": "core.middleware.LoggingMiddleware",
     "maintenance": "core.middleware.MaintenanceModeMiddleware",
     "security_headers": "core.middleware.SecurityHeadersMiddleware",
+    # Auth middlewares (ensure they're registered even if initial dict failed)
+    "auth": "core.auth.middleware.AuthenticationMiddleware",
+    "authentication": "core.auth.middleware.AuthenticationMiddleware",
+    "optional_auth": "core.auth.middleware.OptionalAuthenticationMiddleware",
 })
 
 

{core_framework-0.12.2 → core_framework-0.12.3}/core/migrations/engine.py

@@ -255,6 +255,71 @@ class MigrationEngine:
             index=col.index,
         )
     
+    def _topological_sort_tables(self, tables: list[TableState]) -> list[TableState]:
+        """
+        Bug #5 Fix: Ordena tabelas em ordem topológica baseada em FKs.
+        
+        Tabelas referenciadas por FKs são criadas ANTES das que as referenciam.
+        
+        Args:
+            tables: Lista de TableState a ordenar
+            
+        Returns:
+            Lista ordenada topologicamente
+        """
+        if not tables:
+            return []
+        
+        # Mapeia nome -> tabela
+        table_map = {t.name: t for t in tables}
+        
+        # Constrói grafo de dependências
+        # dependencias[A] = {B, C} significa A depende de B e C (A tem FK para B e C)
+        dependencies: dict[str, set[str]] = {t.name: set() for t in tables}
+        
+        for table in tables:
+            for fk in table.foreign_keys:
+                ref_table = fk.references_table
+                # Só adiciona dependência se a tabela referenciada também está sendo criada
+                # (tabelas já existentes não precisam ser consideradas)
+                if ref_table in table_map:
+                    dependencies[table.name].add(ref_table)
+        
+        # Algoritmo de Kahn para ordenação topológica
+        result = []
+        
+        # Encontra tabelas sem dependências (grau de entrada 0)
+        no_deps = [name for name, deps in dependencies.items() if not deps]
+        
+        while no_deps:
+            # Remove uma tabela sem dependências
+            name = no_deps.pop(0)
+            result.append(table_map[name])
+            
+            # Remove esta tabela das dependências de outras
+            for other_name, deps in dependencies.items():
+                if name in deps:
+                    deps.remove(name)
+                    # Se não tem mais dependências, adiciona à fila
+                    if not deps and other_name not in [t.name for t in result]:
+                        no_deps.append(other_name)
+        
+        # Verifica ciclo (se sobrou alguma tabela com dependências)
+        remaining = [t for t in tables if t not in result]
+        if remaining:
+            # Há um ciclo - adiciona as tabelas restantes no final
+            # (o banco vai falhar, mas pelo menos o erro será claro)
+            import warnings
+            cycle_tables = [t.name for t in remaining]
+            warnings.warn(
+                f"Circular FK dependency detected involving tables: {cycle_tables}. "
+                "Migration may fail. Consider breaking the cycle with nullable FKs.",
+                RuntimeWarning,
+            )
+            result.extend(remaining)
+        
+        return result
+    
     def _diff_to_operations(self, diff: SchemaDiff) -> list[Operation]:
         """Converte SchemaDiff em lista de operações."""
         from core.migrations.operations import CreateEnum, DropEnum, AlterEnum
@@ -284,8 +349,9 @@ class MigrationEngine:
                 new_values=new_enum.values,
             ))
         
-        # 3. Criar tabelas
-        for table in diff.tables_to_create:
+        # 3. Criar tabelas (BUG #5 FIX: em ordem topológica)
+        sorted_tables = self._topological_sort_tables(diff.tables_to_create)
+        for table in sorted_tables:
             columns = [self._column_state_to_def(col) for col in table.columns.values()]
             foreign_keys = [
                 ForeignKeyDef(

core_framework-0.12.3/docs/33-changelog-0.12.3.md

@@ -0,0 +1,181 @@
+# Changelog v0.12.3
+
+**Data de Release:** 03/02/2026
+
+Esta versão corrige 5 bugs críticos encontrados na v0.12.2 que impediam o funcionamento do `AuthenticationMiddleware` e causavam erros em models com UUID.
+
+---
+
+## Bugs Corrigidos
+
+### Bug #1: `AbstractUUIDUser` usa tipo não resolvível
+**Arquivo:** `core/auth/models.py`
+
+**Problema:** A classe `AbstractUUIDUser` definia o campo `id` com um tipo `UUIDType` que não era importado corretamente no escopo do módulo, causando erro de resolução de tipo pelo SQLAlchemy.
+
+**Antes:**
+```python
+class AbstractUUIDUser(AbstractUser):
+    # Import dentro da classe (problemático)
+    from uuid import UUID as UUIDType
+    id: Mapped[UUIDType] = AdvancedField.uuid_pk()
+```
+
+**Erro:**
+```
+MappedAnnotationError: Could not resolve all types within mapped annotation: "Mapped[UUIDType]"
+```
+
+**Depois:**
+```python
+# Imports no topo do módulo
+from uuid import UUID
+from core.fields import AdvancedField
+
+class AbstractUUIDUser(AbstractUser):
+    id: Mapped[UUID] = AdvancedField.uuid_pk()
+```
+
+---
+
+### Bug #2: Shortcut `"auth"` não registrado nos middleware shortcuts
+**Arquivo:** `core/middleware.py`
+
+**Problema:** O shortcut `"auth"` era definido no início do arquivo, mas podia falhar dependendo da ordem de carregamento dos módulos.
+
+**Correção:** Adicionados os shortcuts de auth também no `_builtin_middlewares.update()` para garantir registro mesmo em casos de edge.
+
+```python
+_builtin_middlewares.update({
+    # ... outros middlewares ...
+    "auth": "core.auth.middleware.AuthenticationMiddleware",
+    "authentication": "core.auth.middleware.AuthenticationMiddleware",
+    "optional_auth": "core.auth.middleware.OptionalAuthenticationMiddleware",
+})
+```
+
+---
+
+### Bug #3: `AuthenticationMiddleware` usa `async for` incorretamente
+**Arquivo:** `core/auth/middleware.py`
+
+**Problema:** O middleware usava `async for db in get_read_session()` mas `get_read_session()` é uma coroutine que retorna `AsyncSession` diretamente, não um async generator.
+
+**Antes:**
+```python
+async for db in get_read_session():  # ERRADO!
+    # ...
+```
+
+**Erro:**
+```
+RuntimeWarning: coroutine 'get_read_session' was never awaited
+```
+
+**Depois:**
+```python
+db = await self._get_db_session()
+try:
+    # ... usar db ...
+finally:
+    await db.close()
+```
+
+---
+
+### Bug #4: `get_read_session()` falha fora do contexto FastAPI
+**Arquivo:** `core/auth/middleware.py`
+
+**Problema:** O middleware executa antes do lifecycle de dependency injection do FastAPI, então `init_replicas()` pode não ter sido chamado, causando erro de "Database not initialized".
+
+**Erro:**
+```
+RuntimeError: Database not initialized. Call init_replicas() first.
+```
+
+**Correção:** Implementado método `_get_db_session()` no middleware que:
+1. Tenta usar o session factory padrão se já inicializado
+2. Como fallback, cria uma sessão diretamente a partir das settings
+
+```python
+async def _get_db_session(self) -> AsyncSession | None:
+    # Try 1: Use standard factory if initialized
+    try:
+        if _read_session_factory is not None:
+            return _read_session_factory()
+    except RuntimeError:
+        pass
+    
+    # Try 2: Create from settings (lazy init)
+    try:
+        settings = get_settings()
+        db_url = settings.database_url
+        engine = create_async_engine(db_url)
+        session_factory = async_sessionmaker(engine)
+        return session_factory()
+    except Exception:
+        pass
+    
+    return None
+```
+
+---
+
+### Bug #5: Ordenação topológica incorreta nas migrations
+**Arquivo:** `core/migrations/engine.py`
+
+**Problema:** Tabelas com foreign keys eram criadas antes das tabelas que elas referenciam, causando erro de "relation does not exist".
+
+**Erro:**
+```
+asyncpg.exceptions.UndefinedTableError: relation "workspaces" does not exist
+[SQL: CREATE TABLE "domains" (..., FOREIGN KEY ("workspace_id") REFERENCES "workspaces" ...)]
+```
+
+**Correção:** Implementado algoritmo de ordenação topológica (Kahn's algorithm) no método `_topological_sort_tables()` que:
+1. Constrói grafo de dependências baseado em FKs
+2. Ordena tabelas garantindo que referenciadas sejam criadas primeiro
+3. Detecta e alerta sobre dependências circulares
+
+```python
+def _topological_sort_tables(self, tables: list[TableState]) -> list[TableState]:
+    # Constrói grafo de dependências
+    dependencies = {t.name: set() for t in tables}
+    for table in tables:
+        for fk in table.foreign_keys:
+            if fk.references_table in table_map:
+                dependencies[table.name].add(fk.references_table)
+    
+    # Kahn's algorithm para ordenação topológica
+    # ... ordena tabelas por dependências ...
+    return sorted_tables
+```
+
+---
+
+## Resumo das Mudanças
+
+| Bug | Arquivo | Correção |
+|-----|---------|----------|
+| #1 | `core/auth/models.py` | Import de `UUID` movido para nível do módulo |
+| #2 | `core/middleware.py` | Shortcuts de auth adicionados no `.update()` |
+| #3 | `core/auth/middleware.py` | Removido `async for`, usa `await` corretamente |
+| #4 | `core/auth/middleware.py` | Novo método `_get_db_session()` com lazy init |
+| #5 | `core/migrations/engine.py` | Implementada ordenação topológica de tabelas |
+
+---
+
+## Como Atualizar
+
+```bash
+pip install --upgrade core-framework==0.12.3
+```
+
+## Impacto
+
+Com estas correções:
+- `AbstractUUIDUser` funciona corretamente para modelos com UUID PK
+- `AuthenticationMiddleware` funciona out-of-the-box
+- `request.state.user` é populado corretamente
+- Endpoint `/auth/me` funciona sem workarounds
+- Migrations criam tabelas na ordem correta de dependências

{core_framework-0.12.2 → core_framework-0.12.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "core-framework"
-version = "0.12.2"
+version = "0.12.3"
 description = "Core Framework - Django-inspired, FastAPI-powered. Alta performance, baixo acoplamento, produtividade extrema."
 requires-python = ">=3.10,<4.0"
 readme = "README.md"