core-framework 0.12.1__py3-none-any.whl → 0.12.3__py3-none-any.whl

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/migrations/operations.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import Any, Callable, TYPE_CHECKING
+from typing import Any, Callable, ClassVar, TYPE_CHECKING
 from collections.abc import Awaitable
 
 from sqlalchemy import text
@@ -31,9 +31,90 @@ class ColumnDef:
     unique: bool = False
     index: bool = False
     
+    # Mapeamento de tipos genéricos para tipos específicos de cada dialeto
+    # Bug #1: DATETIME → TIMESTAMP para PostgreSQL
+    TYPE_MAPPING: ClassVar[dict[str, dict[str, str]]] = {
+        "postgresql": {
+            "DATETIME": "TIMESTAMP WITH TIME ZONE",
+            "TIMESTAMP": "TIMESTAMP WITH TIME ZONE",
+            "BOOLEAN": "BOOLEAN",
+            "TINYINT": "SMALLINT",
+            "LONGTEXT": "TEXT",
+            "DOUBLE": "DOUBLE PRECISION",
+        },
+        "mysql": {
+            "DATETIME": "DATETIME",
+            "TIMESTAMP": "TIMESTAMP",
+            "BOOLEAN": "TINYINT(1)",
+            "TEXT": "LONGTEXT",
+            "UUID": "CHAR(36)",
+        },
+        "sqlite": {
+            "DATETIME": "DATETIME",
+            "TIMESTAMP": "DATETIME",
+            "BOOLEAN": "BOOLEAN",
+            "UUID": "TEXT",
+        },
+    }
+    
+    def _get_dialect_type(self, dialect: str) -> str:
+        """
+        Converte tipo genérico para tipo específico do dialeto.
+        
+        Args:
+            dialect: Nome do dialeto (postgresql, mysql, sqlite)
+            
+        Returns:
+            Tipo SQL específico para o dialeto
+        """
+        # Extrai tipo base (sem parâmetros como VARCHAR(255))
+        base_type = self.type.split("(")[0].upper()
+        
+        # Verifica se há mapeamento específico
+        dialect_mapping = self.TYPE_MAPPING.get(dialect, {})
+        mapped_type = dialect_mapping.get(base_type)
+        
+        if mapped_type:
+            # Se o tipo original tinha parâmetros, tenta preservá-los
+            if "(" in self.type and "(" not in mapped_type:
+                # Tipo como VARCHAR(255) mantém os parâmetros
+                return self.type
+            return mapped_type
+        
+        return self.type
+    
+    def _get_default_sql(self, dialect: str) -> str | None:
+        """
+        Gera SQL para valor default considerando o dialeto.
+        
+        Bug #2: Boolean defaults usando TRUE/FALSE para PostgreSQL
+        
+        Args:
+            dialect: Nome do dialeto
+            
+        Returns:
+            String SQL para o default ou None
+        """
+        if self.default is None:
+            return None
+        
+        if isinstance(self.default, str):
+            return f"DEFAULT '{self.default}'"
+        
+        if isinstance(self.default, bool):
+            # PostgreSQL exige TRUE/FALSE em vez de 1/0
+            if dialect == "postgresql":
+                return f"DEFAULT {'TRUE' if self.default else 'FALSE'}"
+            else:
+                return f"DEFAULT {1 if self.default else 0}"
+        
+        return f"DEFAULT {self.default}"
+    
     def to_sql(self, dialect: str = "sqlite") -> str:
-        """Gera SQL para a coluna."""
-        parts = [f'"{self.name}"', self.type]
+        """Gera SQL para a coluna, adaptado ao dialeto do banco."""
+        # Obtém tipo adaptado ao dialeto
+        col_type = self._get_dialect_type(dialect)
+        parts = [f'"{self.name}"', col_type]
         
         if self.primary_key:
             parts.append("PRIMARY KEY")
@@ -49,13 +130,10 @@ class ColumnDef:
         if not self.nullable and not self.primary_key:
             parts.append("NOT NULL")
         
-        if self.default is not None:
-            if isinstance(self.default, str):
-                parts.append(f"DEFAULT '{self.default}'")
-            elif isinstance(self.default, bool):
-                parts.append(f"DEFAULT {1 if self.default else 0}")
-            else:
-                parts.append(f"DEFAULT {self.default}")
+        # Gera default adaptado ao dialeto
+        default_sql = self._get_default_sql(dialect)
+        if default_sql:
+            parts.append(default_sql)
         
         if self.unique and not self.primary_key:
             parts.append("UNIQUE")