maleo-database 0.0.20__tar.gz → 0.0.22__tar.gz

{maleo_database-0.0.20 → maleo_database-0.0.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-database
-Version: 0.0.20
+Version: 0.0.22
 Summary: Database package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary

{maleo_database-0.0.20 → maleo_database-0.0.22}/maleo_database.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-database
-Version: 0.0.20
+Version: 0.0.22
 Summary: Database package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary

{maleo_database-0.0.20 → maleo_database-0.0.22}/maleo_database.egg-info/SOURCES.txt

@@ -20,11 +20,5 @@ src/managers/client.py
 src/managers/engine.py
 src/managers/session.py
 src/orm/__init__.py
-src/orm/base.py
-src/orm/queries.py
-src/orm/models/__init__.py
-src/orm/models/table.py
-src/orm/models/mixins/__init__.py
-src/orm/models/mixins/identifier.py
-src/orm/models/mixins/status.py
-src/orm/models/mixins/timestamp.py
+src/orm/mixins.py
+src/orm/queries.py

{maleo_database-0.0.20 → maleo_database-0.0.22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maleo-database"
-version = "0.0.20"
+version = "0.0.22"
 description = "Database package for MaleoSuite"
 authors = [
     { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }
@@ -106,8 +106,6 @@ packages = [
     "maleo.database.config",
     "maleo.database.managers",
     "maleo.database.orm",
-    "maleo.database.orm.models",
-    "maleo.database.orm.models.mixins",
 ]
 
 [tool.setuptools.package-data]
@@ -115,13 +113,9 @@ packages = [
 "maleo.database.config" = ["*.json", "*.yaml"]
 "maleo.database.managers" = ["*.json", "*.yaml"]
 "maleo.database.orm" = ["*.json", "*.yaml"]
-"maleo.database.orm.models" = ["*.json", "*.yaml"]
-"maleo.database.orm.models.mixins" = ["*.json", "*.yaml"]
 
 [tool.setuptools.package-dir]
 "maleo.database" = "src"
 "maleo.database.config" = "src/config"
 "maleo.database.managers" = "src/managers"
 "maleo.database.orm" = "src/orm"
-"maleo.database.orm.models" = "src/orm/models"
-"maleo.database.orm.models.mixins" = "src/orm/models/mixins"

{maleo_database-0.0.20 → maleo_database-0.0.22}/src/handlers.py

@@ -1,8 +1,6 @@
 from pydantic import BaseModel, ConfigDict, Field
-from sqlalchemy import MetaData
+from sqlalchemy.orm import DeclarativeBase
 from typing import Generic, Optional, TypeVar
-from maleo.dtos.contexts.service import ServiceContext
-from maleo.logging.logger import Database
 from .config import (
     ElasticsearchConfig,
     MongoConfig,
@@ -42,17 +40,7 @@ HandlerT = TypeVar("HandlerT", bound=Handler)
 
 
 class ElasticsearchHandler(Handler[ElasticsearchConfig, ElasticsearchManager]):
-    @classmethod
-    def new(
-        cls,
-        config: ElasticsearchConfig,
-        logger: Database,
-        service_context: Optional[ServiceContext] = None,
-    ) -> "ElasticsearchHandler":
-        manager = ElasticsearchManager(
-            config=config, logger=logger, service_context=service_context
-        )
-        return cls(config=config, manager=manager)
+    pass
 
 
 class MongoHandler(Handler[MongoConfig, MongoManager]):
@@ -63,33 +51,22 @@ class RedisHandler(Handler[RedisConfig, RedisManager]):
     pass
 
 
-class MySQLHandler(Handler[MySQLConfig, MySQLManager]):
+T = TypeVar("T", bound=DeclarativeBase)
+
+
+class MySQLHandler(Handler[MySQLConfig, MySQLManager[T]], Generic[T]):
+    pass
+
+
+class PostgreSQLHandler(Handler[PostgreSQLConfig, PostgreSQLManager[T]], Generic[T]):
     pass
 
 
-class PostgreSQLHandler(Handler[PostgreSQLConfig, PostgreSQLManager]):
-    @classmethod
-    def new(
-        cls,
-        config: PostgreSQLConfig,
-        logger: Database,
-        metadata: MetaData,
-        service_context: Optional[ServiceContext] = None,
-    ) -> "PostgreSQLHandler":
-        manager = PostgreSQLManager(
-            config=config,
-            logger=logger,
-            metadata=metadata,
-            service_context=service_context,
-        )
-        return cls(config=config, manager=manager)
-
-
-class SQLiteHandler(Handler[SQLiteConfig, SQLiteManager]):
+class SQLiteHandler(Handler[SQLiteConfig, SQLiteManager[T]], Generic[T]):
     pass
 
 
-class SQLServerHandler(Handler[SQLServerConfig, SQLServerManager]):
+class SQLServerHandler(Handler[SQLServerConfig, SQLServerManager[T]], Generic[T]):
     pass
 
 

{maleo_database-0.0.20 → maleo_database-0.0.22}/src/managers/__init__.py

@@ -6,8 +6,9 @@ from motor.motor_asyncio import AsyncIOMotorClient
 from pymongo import MongoClient
 from redis.asyncio import Redis as AsyncRedis
 from redis import Redis as SyncRedis
-from sqlalchemy import MetaData, text
-from typing import Generic, Optional, TypeVar
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy import text
+from typing import Generic, Optional, Type, TypeVar
 from uuid import uuid4
 from maleo.dtos.authentication import GenericAuthentication
 from maleo.dtos.contexts.operation import generate_operation_context
@@ -96,16 +97,18 @@ class Manager(ABC, Generic[ConfigT]):
         pass
 
 
-class SQLManager(Manager[SQLConfigT], Generic[SQLConfigT]):
+T = TypeVar("T", bound=DeclarativeBase)
+
+
+class SQLManager(Manager[SQLConfigT], Generic[SQLConfigT, T]):
     def __init__(
         self,
+        Base: Type[T],
         config: SQLConfigT,
         logger: Database,
-        metadata: MetaData,
         service_context: Optional[ServiceContext] = None,
     ) -> None:
         super().__init__(config, logger, service_context)
-        self._metadata = metadata
         self._operation_context.target.details = self._config.model_dump()
         self._engine_manager = EngineManager[SQLConfigT](config)
         self._session_manager = SessionManager(
@@ -114,7 +117,8 @@ class SQLManager(Manager[SQLConfigT], Generic[SQLConfigT]):
             logger=self._logger,
             service_context=self._service_context,
         )
-        self._metadata.create_all(bind=self._engine_manager.get(Connection.SYNC))
+        self.Base = Base
+        self.Base.metadata.create_all(bind=self._engine_manager.get(Connection.SYNC))
 
     @property
     def engine(self) -> EngineManager[SQLConfigT]:
@@ -251,19 +255,19 @@ class SQLManager(Manager[SQLConfigT], Generic[SQLConfigT]):
         await self._engine_manager.dispose()
 
 
-class MySQLManager(SQLManager[MySQLConfig]):
+class MySQLManager(SQLManager[MySQLConfig, T], Generic[T]):
     pass
 
 
-class PostgreSQLManager(SQLManager[PostgreSQLConfig]):
+class PostgreSQLManager(SQLManager[PostgreSQLConfig, T], Generic[T]):
     pass
 
 
-class SQLiteManager(SQLManager[SQLiteConfig]):
+class SQLiteManager(SQLManager[SQLiteConfig, T], Generic[T]):
     pass
 
 
-class SQLServerManager(SQLManager[SQLServerConfig]):
+class SQLServerManager(SQLManager[SQLServerConfig, T], Generic[T]):
     pass
 
 

{maleo_database-0.0.20 → maleo_database-0.0.22}/src/managers/session.py

@@ -92,7 +92,7 @@ class SessionManager(Generic[SQLConfigT]):
         operation_action = SystemOperationAction(
             type=SystemOperationType.DATABASE_CONNECTION, details=None
         )
-        session = self._async_sessionmaker()
+        session: AsyncSession = self._async_sessionmaker()
         SuccessfulSystemOperation[
             Optional[GenericAuthentication], NoDataResponse[None]
         ](
@@ -111,8 +111,9 @@ class SessionManager(Generic[SQLConfigT]):
 
         executed_at = datetime.now(tz=timezone.utc)
         try:
-            yield session  # Provide session
-            await session.commit()  # Auto-commit on success
+            # explicit transaction context — will commit on success, rollback on exception
+            async with session.begin():
+                yield session
             SuccessfulSystemOperation[
                 Optional[GenericAuthentication], NoDataResponse[None]
             ](
@@ -129,7 +130,11 @@ class SessionManager(Generic[SQLConfigT]):
                 self._logger, level=Level.INFO
             )
         except SQLAlchemyError as se:
-            await session.rollback()  # Rollback on error
+            # session.begin() will rollback, but keep explicit rollback to be safe
+            try:
+                await session.rollback()
+            except Exception:
+                pass
             error = DatabaseError[Optional[GenericAuthentication]](
                 OperationType.SYSTEM,
                 service_context=self._service_context,
@@ -152,7 +157,10 @@ class SessionManager(Generic[SQLConfigT]):
             operation.log(self._logger, level=Level.ERROR)
             raise error from se
         except ValidationError as ve:
-            await session.rollback()  # Rollback on error
+            try:
+                await session.rollback()
+            except Exception:
+                pass
             error = UnprocessableEntity[Optional[GenericAuthentication]](
                 OperationType.SYSTEM,
                 service_context=self._service_context,
@@ -169,9 +177,16 @@ class SessionManager(Generic[SQLConfigT]):
             operation.log(self._logger, level=Level.ERROR)
             raise error from ve
         except MaleoException:
+            try:
+                await session.rollback()
+            except Exception:
+                pass
             raise
         except Exception as e:
-            await session.rollback()  # Rollback on error
+            try:
+                await session.rollback()
+            except Exception:
+                pass
             error = InternalServerError[Optional[GenericAuthentication]](
                 OperationType.SYSTEM,
                 service_context=self._service_context,
@@ -194,7 +209,11 @@ class SessionManager(Generic[SQLConfigT]):
             operation.log(self._logger, level=Level.ERROR)
             raise error from e
         finally:
-            await session.close()  # Ensure session closes
+            # close session
+            try:
+                await session.close()
+            except Exception:
+                pass
             SuccessfulSystemOperation[
                 Optional[GenericAuthentication], NoDataResponse[None]
             ](
@@ -222,7 +241,7 @@ class SessionManager(Generic[SQLConfigT]):
         operation_action = SystemOperationAction(
             type=SystemOperationType.DATABASE_CONNECTION, details=None
         )
-        session = self._sync_sessionmaker()
+        session: Session = self._sync_sessionmaker()
         SuccessfulSystemOperation[
             Optional[GenericAuthentication], NoDataResponse[None]
         ](
@@ -241,8 +260,9 @@ class SessionManager(Generic[SQLConfigT]):
 
         executed_at = datetime.now(tz=timezone.utc)
         try:
-            yield session  # Provide session
-            session.commit()  # Auto-commit on success
+            # explicit transaction context — will commit on success, rollback on exception
+            with session.begin():
+                yield session
             SuccessfulSystemOperation[
                 Optional[GenericAuthentication], NoDataResponse[None]
             ](

maleo_database-0.0.22/src/orm/mixins.py

@@ -0,0 +1,91 @@
+from datetime import datetime
+from sqlalchemy import func
+from sqlalchemy.dialects.postgresql import UUID as PostgresUUID
+from sqlalchemy.orm import Mapped, declared_attr, mapped_column
+from sqlalchemy.types import Integer, Enum, TIMESTAMP
+from maleo.enums.status import DataStatus as DataStatusEnum
+from uuid import UUID as PythonUUID, uuid4
+from maleo.types.base.datetime import OptionalDatetime
+from maleo.utils.formatters.case import to_snake
+
+
+class TableName:
+    @declared_attr.directive
+    def __tablename__(cls) -> str:
+        return to_snake(cls.__name__)  # type: ignore
+
+
+class DataIdentifier:
+    id: Mapped[int] = mapped_column("id", Integer, primary_key=True)
+    uuid: Mapped[PythonUUID] = mapped_column(
+        "uuid", PostgresUUID(as_uuid=True), default=uuid4, unique=True, nullable=False
+    )
+
+
+class DataStatus:
+    status: Mapped[DataStatusEnum] = mapped_column(
+        "status",
+        Enum(DataStatusEnum, name="statustype", create_constraints=True),
+        default=DataStatusEnum.ACTIVE,
+        nullable=False,
+    )
+
+
+class CreationTimestamp:
+    created_at: Mapped[datetime] = mapped_column(
+        "created_at",
+        TIMESTAMP(timezone=True),
+        server_default=func.now(),
+        nullable=False,
+    )
+
+
+class UpdateTimestamp:
+    updated_at: Mapped[datetime] = mapped_column(
+        "updated_at",
+        TIMESTAMP(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+
+class LifecyleTimestamp(UpdateTimestamp, CreationTimestamp):
+    pass
+
+
+class DeletionTimestamp:
+    deleted_at: Mapped[OptionalDatetime] = mapped_column(
+        "deleted_at", TIMESTAMP(timezone=True)
+    )
+
+
+class RestorationTimestamp:
+    restored_at: Mapped[OptionalDatetime] = mapped_column(
+        "restored_at", TIMESTAMP(timezone=True)
+    )
+
+
+class DeactivationTimestamp:
+    deactivated_at: Mapped[OptionalDatetime] = mapped_column(
+        "deactivated_at", TIMESTAMP(timezone=True)
+    )
+
+
+class ActivationTimestamp:
+    activated_at: Mapped[datetime] = mapped_column(
+        "activated_at",
+        TIMESTAMP(timezone=True),
+        server_default=func.now(),
+        nullable=False,
+    )
+
+
+class StatusTimestamp(
+    ActivationTimestamp, DeactivationTimestamp, RestorationTimestamp, DeletionTimestamp
+):
+    pass
+
+
+class DataTimestamp(StatusTimestamp, LifecyleTimestamp):
+    pass

{maleo_database-0.0.20 → maleo_database-0.0.22}/src/orm/queries.py

@@ -1,10 +1,9 @@
-from sqlalchemy import Column, Table
-from sqlalchemy.ext.declarative import DeclarativeMeta
-from sqlalchemy.orm import Query, Session, aliased
+from sqlalchemy import asc, cast, desc, or_, select
+from sqlalchemy.orm import DeclarativeBase, Session, aliased
 from sqlalchemy.orm.attributes import InstrumentedAttribute
-from sqlalchemy.sql.expression import or_, asc, cast, desc
+from sqlalchemy.sql import Select
 from sqlalchemy.types import DATE, String, TEXT, TIMESTAMP
-from typing import Sequence, Type
+from typing import Any, Sequence, Tuple, Type, TypeVar
 from maleo.enums.sort import Order
 from maleo.mixins.general import DateFilter, SortColumn
 from maleo.types.base.any import OptionalAny
@@ -14,16 +13,22 @@ from maleo.types.base.string import OptionalListOfStrings, OptionalString
 from maleo.types.enums.status import OptionalListOfDataStatuses
 
 
+T = TypeVar("T", bound=DeclarativeBase)
+R = TypeVar(
+    "R", bound=Tuple[Any, ...]
+)  # result shape inferred from Select (tuple[...])
+
+
 def filter_column(
-    query: Query,
-    table: Type[DeclarativeMeta],
+    stmt: Select[R],
+    table: Type[T],
     column: str,
     value: OptionalAny = None,
     include_null: bool = False,
-) -> Query:
+) -> Select[R]:
     column_attr = getattr(table, column, None)
     if column_attr is None or not isinstance(column_attr, InstrumentedAttribute):
-        return query
+        return stmt
 
     value_filters = []
     if value is not None:
@@ -32,21 +37,21 @@ def filter_column(
     if value_filters:
         if include_null:
             value_filters.append(column_attr.is_(None))
-        query = query.filter(or_(*value_filters))
+        stmt = stmt.filter(or_(*value_filters))
 
-    return query
+    return stmt
 
 
 def filter_ids(
-    query: Query,
-    table: Type[DeclarativeMeta],
+    stmt: Select[R],
+    table: Type[T],
     column: str,
     ids: OptionalListOfIntegers = None,
     include_null: bool = False,
-) -> Query:
+) -> Select[R]:
     column_attr = getattr(table, column, None)
     if column_attr is None or not isinstance(column_attr, InstrumentedAttribute):
-        return query
+        return stmt
 
     id_filters = []
     if ids is not None:
@@ -55,180 +60,177 @@ def filter_ids(
     if id_filters:
         if include_null:
             id_filters.append(column_attr.is_(None))
-        query = query.filter(or_(*id_filters))
+        stmt = stmt.filter(or_(*id_filters))
 
-    return query
+    return stmt
 
 
 def filter_timestamps(
-    query: Query,
-    table: Type[DeclarativeMeta],  # type: ignore
+    stmt: Select[R],
+    table: Type[T],
     date_filters: Sequence[DateFilter],
-) -> Query:
-    if date_filters and len(date_filters) > 0:
+) -> Select[R]:
+    if date_filters:
         for date_filter in date_filters:
             try:
-                table: Table = table.__table__  # type: ignore
-                column: Column = table.columns[date_filter.name]
+                sqla_table = table.__table__
+                column = sqla_table.columns[date_filter.name]
                 column_attr: InstrumentedAttribute = getattr(table, date_filter.name)
                 if isinstance(column.type, (TIMESTAMP, DATE)):
                     if date_filter.from_date and date_filter.to_date:
-                        query = query.filter(
+                        stmt = stmt.filter(
                             column_attr.between(
                                 date_filter.from_date, date_filter.to_date
                             )
                         )
                     elif date_filter.from_date:
-                        query = query.filter(column_attr >= date_filter.from_date)
+                        stmt = stmt.filter(column_attr >= date_filter.from_date)
                     elif date_filter.to_date:
-                        query = query.filter(column_attr <= date_filter.to_date)
+                        stmt = stmt.filter(column_attr <= date_filter.to_date)
             except KeyError:
                 continue
-    return query
+    return stmt
 
 
 def filter_statuses(
-    query: Query,
-    table: Type[DeclarativeMeta],
+    stmt: Select[R],
+    table: Type[T],
     statuses: OptionalListOfDataStatuses,
-) -> Query:
+) -> Select[R]:
     if statuses is not None:
         status_filters = [table.status == status for status in statuses]  # type: ignore
-        query = query.filter(or_(*status_filters))
-    return query
+        stmt = stmt.filter(or_(*status_filters))
+    return stmt
 
 
 def filter_is_root(
-    query: Query,
-    table: Type[DeclarativeMeta],
+    stmt: Select[R],
+    table: Type[T],
     parent_column: str = "parent_id",
     is_root: OptionalBoolean = None,
-) -> Query:
+) -> Select[R]:
     parent_attr = getattr(table, parent_column, None)
     if parent_attr is None or not isinstance(parent_attr, InstrumentedAttribute):
-        return query
+        return stmt
     if is_root is not None:
-        query = query.filter(
+        stmt = stmt.filter(
             parent_attr.is_(None) if is_root else parent_attr.is_not(None)
         )
-    return query
+    return stmt
 
 
 def filter_is_parent(
     session: Session,
-    query: Query,
-    table: Type[DeclarativeMeta],
+    stmt: Select[R],
+    table: Type[T],
     id_column: str = "id",
     parent_column: str = "parent_id",
     is_parent: OptionalBoolean = None,
-) -> Query:
+) -> Select[R]:
     id_attr = getattr(table, id_column, None)
     if id_attr is None or not isinstance(id_attr, InstrumentedAttribute):
-        return query
+        return stmt
     parent_attr = getattr(table, parent_column, None)
     if parent_attr is None or not isinstance(parent_attr, InstrumentedAttribute):
-        return query
+        return stmt
     if is_parent is not None:
         child_table = aliased(table)
         child_parent_attr = getattr(child_table, parent_column)
-        subq = session.query(child_table).filter(child_parent_attr == id_attr).exists()
-        query = query.filter(subq if is_parent else ~subq)
-    return query
+        subq = select(child_table).filter(child_parent_attr == id_attr).exists()
+        stmt = stmt.filter(subq if is_parent else ~subq)
+    return stmt
 
 
 def filter_is_child(
-    query: Query,
-    table: Type[DeclarativeMeta],
+    stmt: Select[R],
+    table: Type[T],
     parent_column: str = "parent_id",
     is_child: OptionalBoolean = None,
-) -> Query:
+) -> Select[R]:
     parent_attr = getattr(table, parent_column, None)
     if parent_attr is None or not isinstance(parent_attr, InstrumentedAttribute):
-        return query
+        return stmt
     if is_child is not None:
-        query = query.filter(
+        stmt = stmt.filter(
             parent_attr.is_not(None) if is_child else parent_attr.is_(None)
         )
-    return query
+    return stmt
 
 
 def filter_is_leaf(
     session: Session,
-    query: Query,
-    table: Type[DeclarativeMeta],
+    stmt: Select[R],
+    table: Type[T],
     id_column: str = "id",
     parent_column: str = "parent_id",
     is_leaf: OptionalBoolean = None,
-) -> Query:
+) -> Select[R]:
     id_attr = getattr(table, id_column, None)
     if id_attr is None or not isinstance(id_attr, InstrumentedAttribute):
-        return query
+        return stmt
     parent_attr = getattr(table, parent_column, None)
     if parent_attr is None or not isinstance(parent_attr, InstrumentedAttribute):
-        return query
+        return stmt
     if is_leaf is not None:
         child_table = aliased(table)
         child_parent_attr = getattr(child_table, parent_column)
-        subq = session.query(child_table).filter(child_parent_attr == id_attr).exists()
-        query = query.filter(~subq if is_leaf else subq)
-    return query
+        subq = select(child_table).filter(child_parent_attr == id_attr).exists()
+        stmt = stmt.filter(~subq if is_leaf else subq)
+    return stmt
 
 
 def search(
-    query: Query,
-    table: Type[DeclarativeMeta],
+    stmt: Select[R],
+    table: Type[T],
     search: OptionalString = None,
     columns: OptionalListOfStrings = None,
-) -> Query:
+) -> Select[R]:
     if search is None:
-        return query
+        return stmt
 
     search_term = f"%{search}%"
-    sqla_table: Table = table.__table__  # type: ignore
+    sqla_table = table.__table__
     search_filters = []
 
     for name, attr in vars(table).items():
-        # Only consider InstrumentedAttribute (mapped columns)
         if not isinstance(attr, InstrumentedAttribute):
             continue
 
         try:
-            column: Column = sqla_table.columns[name]
+            column = sqla_table.columns[name]
         except KeyError:
             continue
 
-        # Skip columns not in the user-provided list
         if columns is not None and name not in columns:
             continue
 
-        # Only allow string/TEXT columns
         if isinstance(column.type, (String, TEXT)):
             search_filters.append(cast(attr, TEXT).ilike(search_term))
 
     if search_filters:
-        query = query.filter(or_(*search_filters))
+        stmt = stmt.filter(or_(*search_filters))
 
-    return query
+    return stmt
 
 
 def sort(
-    query: Query,
-    table: Type[DeclarativeMeta],
+    stmt: Select[R],
+    table: Type[T],
     sort_columns: Sequence[SortColumn],
-) -> Query:
+) -> Select[R]:
     for sort_column in sort_columns:
         try:
             sort_col = getattr(table, sort_column.name)
             sort_col = (
                 asc(sort_col) if sort_column.order is Order.ASC else desc(sort_col)
             )
-            query = query.order_by(sort_col)
+            stmt = stmt.order_by(sort_col)
         except AttributeError:
             continue
-    return query
+    return stmt
 
 
-def paginate(query: Query, page: int, limit: int) -> Query:
-    offset: int = int((page - 1) * limit)  # Calculate offset based on page
-    query = query.limit(limit=limit).offset(offset=offset)
-    return query
+def paginate(stmt: Select[R], page: int, limit: int) -> Select[R]:
+    offset: int = int((page - 1) * limit)
+    stmt = stmt.limit(limit).offset(offset)
+    return stmt

maleo_database-0.0.20/src/orm/base.py

@@ -1,7 +0,0 @@
-from sqlalchemy.orm import DeclarativeMeta, declarative_base
-from typing import Any, Type
-from .models.table import BaseTable
-
-
-def create_base(cls: Type[Any] = BaseTable) -> DeclarativeMeta:
-    return declarative_base(cls=cls)

maleo_database-0.0.20/src/orm/models/mixins/identifier.py

@@ -1,11 +0,0 @@
-from sqlalchemy.dialects.postgresql import UUID as PostgresUUID
-from sqlalchemy.orm import Mapped, mapped_column
-from sqlalchemy.types import Integer
-from uuid import UUID as PythonUUID, uuid4
-
-
-class DataIdentifier:
-    id: Mapped[int] = mapped_column("id", Integer, primary_key=True)
-    uuid: Mapped[PythonUUID] = mapped_column(
-        "uuid", PostgresUUID(as_uuid=True), default=uuid4, unique=True, nullable=False
-    )

maleo_database-0.0.20/src/orm/models/mixins/status.py

@@ -1,12 +0,0 @@
-from sqlalchemy.orm import Mapped, mapped_column
-from sqlalchemy.types import Enum
-from maleo.enums.status import DataStatus as DataStatusEnum
-
-
-class DataStatus:
-    status: Mapped[DataStatusEnum] = mapped_column(
-        "status",
-        Enum(DataStatusEnum, name="statustype", create_constraints=True),
-        default=DataStatusEnum.ACTIVE,
-        nullable=False,
-    )

maleo_database-0.0.20/src/orm/models/mixins/timestamp.py

@@ -1,65 +0,0 @@
-from datetime import datetime
-from sqlalchemy import func
-from sqlalchemy.orm import Mapped, mapped_column
-from sqlalchemy.types import TIMESTAMP
-from maleo.types.base.datetime import OptionalDatetime
-
-
-class CreateTimestamp:
-    created_at: Mapped[datetime] = mapped_column(
-        "created_at",
-        TIMESTAMP(timezone=True),
-        server_default=func.now(),
-        nullable=False,
-    )
-
-
-class UpdateTimestamp:
-    updated_at: Mapped[datetime] = mapped_column(
-        "updated_at",
-        TIMESTAMP(timezone=True),
-        server_default=func.now(),
-        onupdate=func.now(),
-        nullable=False,
-    )
-
-
-class LifecyleTimestamp(UpdateTimestamp, CreateTimestamp):
-    pass
-
-
-class DeleteTimestamp:
-    deleted_at: Mapped[OptionalDatetime] = mapped_column(
-        "deleted_at", TIMESTAMP(timezone=True)
-    )
-
-
-class RestoreTimestamp:
-    restored_at: Mapped[OptionalDatetime] = mapped_column(
-        "restored_at", TIMESTAMP(timezone=True)
-    )
-
-
-class DeactivateTimestamp:
-    deactivated_at: Mapped[OptionalDatetime] = mapped_column(
-        "deactivated_at", TIMESTAMP(timezone=True)
-    )
-
-
-class ActivateTimestamp:
-    activated_at: Mapped[datetime] = mapped_column(
-        "activated_at",
-        TIMESTAMP(timezone=True),
-        server_default=func.now(),
-        nullable=False,
-    )
-
-
-class StatusTimestamp(
-    ActivateTimestamp, DeactivateTimestamp, RestoreTimestamp, DeleteTimestamp
-):
-    pass
-
-
-class DataTimestamp(StatusTimestamp, LifecyleTimestamp):
-    pass

maleo_database-0.0.20/src/orm/models/table.py

@@ -1,17 +0,0 @@
-from sqlalchemy.orm import declared_attr
-from maleo.utils.formatters.case import to_snake
-from .mixins.identifier import DataIdentifier
-from .mixins.status import DataStatus
-from .mixins.timestamp import DataTimestamp
-
-
-class BaseTable:
-    __abstract__ = True
-
-    @declared_attr  # type: ignore
-    def __tablename__(cls) -> str:
-        return to_snake(cls.__name__)  # type: ignore
-
-
-class DataTable(DataStatus, DataTimestamp, DataIdentifier):
-    pass