danielutils 1.1.28__py3-none-any.whl

danielutils/abstractions/db/database_initializer.py

@@ -0,0 +1,261 @@
+import logging
+from abc import ABC, abstractmethod
+from typing import Dict, Optional, Type, Any, Sequence
+from ...logging_.utils import get_logger
+
+try:
+    from sqlalchemy import inspect, Column
+    from sqlalchemy.orm import DeclarativeBase
+except ImportError:
+    from ...mock_ import MockImportObject
+
+    inspect = MockImportObject("'sqlalchemy' is not installed")  # type:ignore
+    Column = MockImportObject("'sqlalchemy' is not installed")  # type:ignore
+    DeclarativeBase = type("DeclarativeBase", (object,), {})  # type:ignore
+
+from .database import Database
+from .database_definitions import ColumnType, TableSchema, TableColumn as ColumnSchema, TableIndex as IndexSchema
+logger = get_logger(__name__)
+
+TYPE_MAPPING = {
+    'INTEGER': ColumnType.INTEGER,
+    'BIGINT': ColumnType.INTEGER,
+    'FLOAT': ColumnType.FLOAT,
+    'NUMERIC': ColumnType.FLOAT,
+    'DECIMAL': ColumnType.FLOAT,
+    'BOOLEAN': ColumnType.BOOLEAN,
+    'TEXT': ColumnType.TEXT,
+    'VARCHAR': ColumnType.TEXT,
+    'CHAR': ColumnType.TEXT,
+    'UUID': ColumnType.TEXT,
+    'DATETIME': ColumnType.DATETIME,
+    'DATE': ColumnType.DATE,
+    'TIME': ColumnType.TIME,
+    'JSON': ColumnType.JSON,
+    'BLOB': ColumnType.BLOB,
+}
+
+
+async def validate_schema(db: Database, table_name: str, expected_schema: TableSchema) -> bool:
+    """
+    Validate that the existing table schema matches the expected schema.
+
+    Args:
+        db: Database instance
+        table_name: Name of the table to validate
+        expected_schema: Expected table schema
+
+    Returns:
+        bool: True if schema matches, False otherwise
+    """
+    try:
+        # Get existing schema
+        existing_schemas = await db.get_schemas()
+        if table_name not in existing_schemas:
+            logger.warning("Table '%s' does not exist", table_name)
+            return False
+
+        existing_schema = existing_schemas[table_name]
+
+        # Compare columns
+        if len(existing_schema.columns) != len(expected_schema.columns):
+            logger.warning(
+                "Column count mismatch in '%s': "
+                "expected %d, "
+                "got %d",
+                table_name,
+                len(expected_schema.columns),
+                len(existing_schema.columns)
+            )
+            return False
+
+        # Compare each column
+        for expected_col, existing_col in zip(sorted(expected_schema.columns, key=lambda c: c.name),
+                                              sorted(existing_schema.columns, key=lambda c: c.name)):
+            if (
+                    expected_col.name != existing_col.name or
+                    expected_col.type != existing_col.type or
+                    expected_col.primary_key != existing_col.primary_key or
+                    expected_col.nullable != existing_col.nullable or
+                    expected_col.unique != existing_col.unique or
+                    expected_col.foreign_key != existing_col.foreign_key
+            ):
+                logger.warning("Column mismatch in '%s': expected %s, got %s", table_name, expected_col, existing_col)
+                return False
+
+        # Compare indexes
+        if len(existing_schema.indexes) != len(expected_schema.indexes):
+            logger.warning(
+                "Index count mismatch in '%s': "
+                "expected %d, "
+                "got %d",
+                table_name,
+                len(expected_schema.indexes),
+                len(existing_schema.indexes)
+            )
+            return False
+
+        # Compare each index
+        for expected_idx, existing_idx in zip(sorted(expected_schema.indexes, key=lambda idx: idx.name),
+                                              sorted(existing_schema.indexes, key=lambda idx: idx.name)):
+            if (
+                    expected_idx.name != existing_idx.name or
+                    expected_idx.columns != existing_idx.columns or
+                    expected_idx.unique != existing_idx.unique
+            ):
+                logger.warning("Index mismatch in '%s': expected %s, got %s", table_name, expected_idx, existing_idx)
+                return False
+
+        return True
+
+    except Exception as e:
+        logger.error("Error validating schema for '%s': %s", table_name, str(e))
+        return False
+
+
+def get_column_type(column: Column) -> ColumnType:
+    """Convert SQLAlchemy column type to our ColumnType enum"""
+    # Ensure autoincrement for integer primary key named 'id'
+    if (
+            column.name == 'id'
+            and getattr(column, 'primary_key', False)
+            and ('INTEGER' in str(column.type).upper() or 'BIGINT' in str(column.type).upper())
+    ):
+        return ColumnType.AUTOINCREMENT
+    # Check for autoincrement attribute
+    if getattr(column, 'autoincrement', False) == True:
+        return ColumnType.AUTOINCREMENT
+    # Then check the column type
+    type_name = str(column.type).upper()
+    for sql_type, our_type in TYPE_MAPPING.items():
+        if sql_type in type_name:
+            return our_type
+    return ColumnType.TEXT  # Default to TEXT if type not found
+
+
+def get_foreign_key(column: Column) -> Optional[Dict[str, str]]:
+    """Extract foreign key information from a column"""
+    for fk in column.foreign_keys:
+        return {
+            "table": fk.column.table.name,
+            "column": fk.column.name
+        }
+    return None
+
+
+def get_default_value(column: Column) -> Optional[Any]:
+    """Extract default value from a column"""
+    if column.default is not None:
+        if hasattr(column.default, 'arg'):
+            return column.default.arg
+        return column.default
+    return None
+
+
+def model_to_schema(model_class: Type[DeclarativeBase]) -> TableSchema:
+    """Convert a SQLAlchemy model to our TableSchema"""
+    mapper = inspect(model_class)
+    table_name = mapper.local_table.name  # type: ignore
+
+    # Convert columns
+    columns = []
+    for column in mapper.columns:
+        # Get unique constraint from column
+        is_unique = False
+        if column.unique:
+            is_unique = True
+        elif column.index and column.index.unique:  # type: ignore
+            is_unique = True
+
+        col_schema = ColumnSchema(
+            name=column.name,
+            type=get_column_type(column),
+            primary_key=column.primary_key,
+            nullable=column.nullable,  # type: ignore
+            unique=is_unique,
+            foreign_key=get_foreign_key(column),
+            default=get_default_value(column)
+        )
+        columns.append(col_schema)
+
+    # Convert indexes
+    indexes = []
+    for index in mapper.local_table.indexes:  # type: ignore
+        # Skip indexes that are already handled by unique constraints
+        if len(index.columns) == 1 and index.columns[0].unique:
+            continue
+
+        idx_schema = IndexSchema(
+            name=index.name,
+            columns=[col.name for col in index.columns],
+            unique=index.unique
+        )
+        indexes.append(idx_schema)
+
+    return TableSchema(
+        name=table_name,
+        columns=columns,
+        indexes=indexes
+    )
+
+
+class DatabaseInitializer(ABC):
+    # Map SQLAlchemy types to our ColumnType enum
+
+    @classmethod
+    @abstractmethod
+    def _get_models(cls) -> Sequence[Type[DeclarativeBase]]:
+        """Get all pydantic models from our models"""
+
+    @classmethod
+    def _get_table_schemas(cls) -> Dict[str, TableSchema]:
+        """Get all table schemas from our models"""
+        models = cls._get_models()
+        res = {}
+        for model in models:
+            try:
+                res[model.__tablename__] = model_to_schema(model)
+            except Exception as e:
+                raise Exception(f"Failed parsing '{model.__tablename__}'") from e
+        return res
+
+    @classmethod
+    async def init_db(cls, db: Database) -> None:
+        """
+        Initialize the database by creating or validating all required tables.
+
+        Args:
+            db: Database instance to initialize
+        """
+        try:
+            await db.connect()
+
+            # Get existing schemas
+            existing_schemas = await db.get_schemas()
+
+            # Get table schemas from models
+            table_schemas = cls._get_table_schemas()
+
+            # Create or validate each table
+            for table_name, expected_schema in table_schemas.items():
+                if table_name not in existing_schemas:
+                    logger.info("Creating table '%s'", table_name)
+                    await db.create_table(expected_schema)
+                else:
+                    logger.info("Validating table '%s'", table_name)
+                    if not await validate_schema(db, table_name, expected_schema):
+                        raise ValueError(
+                            f"Schema validation failed for table '{table_name}'. "
+                            "Please check the logs for details."
+                        )
+
+            logger.info("Database initialization completed successfully")
+
+        except Exception as e:
+            logger.error("Error initializing database: %s", str(e))
+            raise
+
+
+__all__ = [
+    "DatabaseInitializer"
+]

danielutils/abstractions/db/database_models.py

@@ -0,0 +1,213 @@
+from typing import Dict, Any, List, Optional, Literal, Union
+from enum import Enum
+from pydantic import BaseModel, Field, ConfigDict
+import json
+
+
+class ColumnType(str, Enum):
+    """SQL column types"""
+    INTEGER = "INTEGER"
+    AUTOINCREMENT = "AUTOINCREMENT"
+    SMALLINT = "SMALLINT"
+    MEDIUMINT = "MEDIUMINT"
+    TINYINT = "TINYINT"
+    BIGINT = "BIGINT"
+    FLOAT = "FLOAT"
+    DOUBLE = "DOUBLE"
+    DECIMAL = "DECIMAL"
+    BOOLEAN = "BOOLEAN"
+    TEXT = "TEXT"
+    VARCHAR = "VARCHAR"
+    CHAR = "CHAR"
+    DATE = "DATE"
+    TIME = "TIME"
+    DATETIME = "DATETIME"
+    TIMESTAMP = "TIMESTAMP"
+    BLOB = "BLOB"
+    JSON = "JSON"
+    UUID = "UUID"
+
+
+class BaseDBModel(BaseModel):
+    """Base model with JSON serialization support"""
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True
+    )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert model to dictionary"""
+        return self.model_dump(mode="json")
+
+    def to_json(self) -> str:
+        """Convert model to JSON string"""
+        return self.model_dump_json()
+
+    @classmethod
+    def from_json(cls, json_str: str) -> 'BaseDBModel':
+        """Create model instance from JSON string"""
+        data = json.loads(json_str)
+        return cls.model_validate(data)
+
+
+class TableColumn(BaseDBModel):
+    """Represents a database column definition"""
+    name: str
+    type: ColumnType
+    nullable: bool = True
+    primary_key: bool = False
+    unique: bool = False
+    default: Any = None
+    foreign_key: Optional[Dict[str, str]] = None
+
+
+class TableIndex(BaseDBModel):
+    """Represents a database index definition"""
+    name: str
+    columns: List[str]
+    unique: bool = False
+
+
+class TableForeignKey(BaseDBModel):
+    """Represents a foreign key constraint"""
+    name: str
+    columns: List[str]
+    reference_table: str
+    reference_columns: List[str]
+    on_delete: Optional[str] = None
+    on_update: Optional[str] = None
+
+
+class TableSchema(BaseDBModel):
+    """Represents a complete table schema"""
+    name: str
+    columns: List[TableColumn]
+    indexes: List[TableIndex] = Field(default_factory=list)
+    foreign_keys: List[TableForeignKey] = Field(default_factory=list)
+
+
+class Operator(str, Enum):
+    """SQL comparison operators"""
+    EQ = "="
+    NEQ = "!="
+    GT = ">"
+    GTE = ">="
+    LT = "<"
+    LTE = "<="
+    LIKE = "LIKE"  # Not supported in InMemoryDatabase
+    ILIKE = "ILIKE"  # Not supported in InMemoryDatabase
+    CONTAINS = "CONTAINS"  # Case-insensitive contains
+    CONTAINS_CS = "CONTAINS_CS"  # Case-sensitive contains
+    IN = "IN"
+    NOT_IN = "NOT IN"
+    IS_NULL = "IS NULL"
+    IS_NOT_NULL = "IS NOT NULL"
+    AND = "AND"
+    OR = "OR"
+
+
+class JoinType(str, Enum):
+    """SQL join types"""
+    INNER = "INNER JOIN"
+    LEFT = "LEFT JOIN"
+    RIGHT = "RIGHT JOIN"
+    FULL = "FULL JOIN"
+
+
+class OrderDirection(str, Enum):
+    """SQL order directions"""
+    ASC = "ASC"
+    DESC = "DESC"
+
+
+class Condition(BaseDBModel):
+    """A single SQL condition"""
+    column: str
+    operator: Operator
+    value: Optional[Any] = None
+    values: Optional[List[Any]] = None  # For IN/NOT IN operators
+
+
+class Join(BaseDBModel):
+    """SQL join definition"""
+    type: JoinType
+    table: str
+    conditions: List[Condition]
+
+
+class OrderBy(BaseDBModel):
+    """SQL ORDER BY clause"""
+    column: str
+    direction: OrderDirection = OrderDirection.ASC
+
+
+class WhereClause(BaseDBModel):
+    """SQL WHERE clause with conditions"""
+    conditions: List[Condition]
+    operator: Literal["AND", "OR"] = "AND"
+
+
+class SelectQuery(BaseDBModel):
+    """Complete SELECT query definition"""
+    table: str
+    columns: Optional[List[str]] = None
+    where: Optional[WhereClause] = None
+    joins: Optional[List[Join]] = None
+    order_by: Optional[List[OrderBy]] = None
+    group_by: Optional[List[str]] = None
+    having: Optional[WhereClause] = None
+    limit: Optional[int] = None
+    offset: Optional[int] = None
+
+
+class UpdateQuery(BaseDBModel):
+    """Complete UPDATE query definition"""
+    table: str
+    data: Dict[str, Any]
+    where: Optional[WhereClause] = None
+
+
+class DeleteQuery(BaseDBModel):
+    """Complete DELETE query definition"""
+    table: str
+    where: Optional[WhereClause] = None
+
+
+# Helper functions for JSON serialization
+def serialize_to_json(obj: Union[BaseDBModel, List[BaseDBModel], Dict[str, Any]]) -> str:
+    """Serialize any supported object to JSON string"""
+    if isinstance(obj, BaseDBModel):
+        return obj.to_json()
+    elif isinstance(obj, list):
+        return json.dumps([item.to_dict() if isinstance(item, BaseDBModel) else item for item in obj])
+    elif isinstance(obj, dict):
+        return json.dumps({k: v.to_dict() if isinstance(v, BaseDBModel) else v for k, v in obj.items()})
+    return json.dumps(obj)
+
+
+def deserialize_from_json(json_str: str, model_class: type[BaseDBModel]) -> Union[BaseDBModel, List[BaseDBModel]]:
+    """Deserialize JSON string to model instance(s)"""
+    data = json.loads(json_str)
+    if isinstance(data, list):
+        return [model_class.model_validate(item) for item in data]
+    return model_class.model_validate(data)
+
+
+__all__ = [
+    "ColumnType",
+    "TableColumn",
+    "TableIndex",
+    "TableForeignKey",
+    "TableSchema",
+    "Operator",
+    "JoinType",
+    "OrderDirection",
+    "Condition",
+    "Join",
+    "OrderBy",
+    "WhereClause",
+    "SelectQuery",
+    "UpdateQuery",
+    "DeleteQuery",
+    "serialize_to_json",
+    "deserialize_from_json"
+]

danielutils/abstractions/db/dependencies.py

@@ -0,0 +1,6 @@
+from .database import Database
+from .database_factory import DatabaseFactory
+
+
+def get_db() -> Database:
+    return DatabaseFactory.get_database_from_settings()

danielutils/abstractions/db/implementations/__init__.py

@@ -0,0 +1,4 @@
+from .in_memory_database import *
+from .persistent_in_memory_database import *
+from .redis_database import *
+from .sqlite_database import *