maleo-database 0.0.19__py3-none-any.whl → 0.0.21__py3-none-any.whl

maleo/database/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/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/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 Sequence, 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,19 @@ from maleo.types.base.string import OptionalListOfStrings, OptionalString
 from maleo.types.enums.status import OptionalListOfDataStatuses
 
 
+T = TypeVar("T", bound=DeclarativeBase)
+
+
 def filter_column(
-    query: Query,
-    table: Type[DeclarativeMeta],
+    stmt: Select,
+    table: Type[T],
     column: str,
     value: OptionalAny = None,
     include_null: bool = False,
-) -> Query:
+) -> Select:
     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 +34,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,
+    table: Type[T],
     column: str,
     ids: OptionalListOfIntegers = None,
     include_null: bool = False,
-) -> Query:
+) -> Select:
     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 +57,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,
+    table: Type[T],
     date_filters: Sequence[DateFilter],
-) -> Query:
-    if date_filters and len(date_filters) > 0:
+) -> Select:
+    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,
+    table: Type[T],
     statuses: OptionalListOfDataStatuses,
-) -> Query:
+) -> Select:
     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,
+    table: Type[T],
     parent_column: str = "parent_id",
     is_root: OptionalBoolean = None,
-) -> Query:
+) -> Select:
     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,
+    table: Type[T],
     id_column: str = "id",
     parent_column: str = "parent_id",
     is_parent: OptionalBoolean = None,
-) -> Query:
+) -> Select:
     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,
+    table: Type[T],
     parent_column: str = "parent_id",
     is_child: OptionalBoolean = None,
-) -> Query:
+) -> Select:
     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,
+    table: Type[T],
     id_column: str = "id",
     parent_column: str = "parent_id",
     is_leaf: OptionalBoolean = None,
-) -> Query:
+) -> Select:
     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,
+    table: Type[T],
     search: OptionalString = None,
     columns: OptionalListOfStrings = None,
-) -> Query:
+) -> Select:
     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,
+    table: Type[T],
     sort_columns: Sequence[SortColumn],
-) -> Query:
+) -> Select:
     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, page: int, limit: int) -> Select:
+    offset: int = int((page - 1) * limit)
+    stmt = stmt.limit(limit).offset(offset)
+    return stmt

{maleo_database-0.0.19.dist-info → maleo_database-0.0.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-database
-Version: 0.0.19
+Version: 0.0.21
 Summary: Database package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary
@@ -46,10 +46,10 @@ Requires-Dist: importlib_metadata>=8.7.0
 Requires-Dist: maleo-constants>=0.0.6
 Requires-Dist: maleo-dtos>=0.0.18
 Requires-Dist: maleo-enums>=0.0.6
-Requires-Dist: maleo-exceptions>=0.0.25
+Requires-Dist: maleo-exceptions>=0.0.26
 Requires-Dist: maleo-logging>=0.0.8
 Requires-Dist: maleo-mixins>=0.0.13
-Requires-Dist: maleo-schemas>=0.0.23
+Requires-Dist: maleo-schemas>=0.0.24
 Requires-Dist: maleo-types-base>=0.0.2
 Requires-Dist: maleo-types-controllers>=0.0.1
 Requires-Dist: maleo-types-enums>=0.0.4

{maleo_database-0.0.19.dist-info → maleo_database-0.0.21.dist-info}/RECORD

@@ -10,18 +10,12 @@ maleo/database/config/pooling.py,sha256=4Q0rkM4FAt6xAbBG1PItHmMSzS7aCZNBgFPeaEjK
 maleo/database/managers/__init__.py,sha256=45un_rhnAeSFQLxmEsEXNsYLfg6kpWWljsXpqDFWZQk,13073
 maleo/database/managers/client.py,sha256=hdfPn8Ae8G78yZYDxI1FylcM-rPMIL8Ty4XmsASDrt0,3065
 maleo/database/managers/engine.py,sha256=aF7JCjSYujodbn2QQrT_OeLX-WjUdIv5cBgWtvLgHI0,1725
-maleo/database/managers/session.py,sha256=QCyw1Um0xTmEGCHxX3kQ6z7Q_L2TT8Eq3_8NcpKIsxE,19000
+maleo/database/managers/session.py,sha256=aKyuiHiA171Vptr92AA5U-mRwzwbKXb9RAZ9Wq5Wo4s,19557
 maleo/database/orm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maleo/database/orm/base.py,sha256=qdRK_TQqDoZ1hANvm1mJDiblqFr77J1IhBnlENr7RK8,229
-maleo/database/orm/queries.py,sha256=NX9PYT6GZgwIhtRc7WSTS9EUzqTZCb-ib99ccYjmUkM,7643
-maleo/database/orm/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maleo/database/orm/models/table.py,sha256=UhEH7WN1lrNY3uTb4a5VWO4l9UaYhnRQK_0Z7R0lMNA,457
-maleo/database/orm/models/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maleo/database/orm/models/mixins/identifier.py,sha256=jICVsLUFw_f7TV_aX4KTTs_ycH35MRtRj5boTqctmZo,425
-maleo/database/orm/models/mixins/status.py,sha256=Jzithn-Hl2ct1AqboGZSXrA35aaQEDvqtaB8oL7KIyo,376
-maleo/database/orm/models/mixins/timestamp.py,sha256=TWqBTBvgSxcPsK0m7ggVrkHqzlqCM-2Zox7TAwCxd0I,1500
-maleo_database-0.0.19.dist-info/licenses/LICENSE,sha256=aftGsecnk7TWVX-7KW94FqK4Syy6YSZ8PZEF7EcIp3M,2621
-maleo_database-0.0.19.dist-info/METADATA,sha256=IK-_9iOgz-THwQ2XJcxF8yJU-U4XZ_NMlsJ5jSOCPgQ,3837
-maleo_database-0.0.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maleo_database-0.0.19.dist-info/top_level.txt,sha256=3Tpd1siVsfYoeI9FEOJNYnffx_shzZ3wsPpTvz5bljc,6
-maleo_database-0.0.19.dist-info/RECORD,,
+maleo/database/orm/mixins.py,sha256=rW-FVOrRm_R8yJyrcwGoVIPPV1oAOhSVFmANHR7bowU,2372
+maleo/database/orm/queries.py,sha256=o_6KHMfQeSp_3sJWusXll-NQBxPm8XUJepnWBahoyv4,7152
+maleo_database-0.0.21.dist-info/licenses/LICENSE,sha256=aftGsecnk7TWVX-7KW94FqK4Syy6YSZ8PZEF7EcIp3M,2621
+maleo_database-0.0.21.dist-info/METADATA,sha256=YPQk2kQ8dTfnfnnwwvgm7M23GLDgWEnJDpENItdGTt0,3837
+maleo_database-0.0.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maleo_database-0.0.21.dist-info/top_level.txt,sha256=3Tpd1siVsfYoeI9FEOJNYnffx_shzZ3wsPpTvz5bljc,6
+maleo_database-0.0.21.dist-info/RECORD,,

maleo/database/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/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/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/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/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