maleo-database 0.0.1__py3-none-any.whl

maleo/database/managers/engines/sqlite.py

@@ -0,0 +1,55 @@
+from sqlalchemy.engine import create_engine, Engine
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncEngine
+from typing import Literal, Tuple, Union, overload
+from ...config import SQLiteDatabaseConfig
+from ...enums import Connection
+
+
+class SQLiteEngineManager:
+    def __init__(self, config: SQLiteDatabaseConfig) -> None:
+        self.config = config
+        self._async_engine: AsyncEngine = self._init(Connection.ASYNC)
+        self._sync_engine: Engine = self._init(Connection.SYNC)
+
+    @overload
+    def _init(self, connection: Literal[Connection.ASYNC]) -> AsyncEngine: ...
+    @overload
+    def _init(self, connection: Literal[Connection.SYNC]) -> Engine: ...
+    def _init(
+        self, connection: Connection = Connection.ASYNC
+    ) -> Union[AsyncEngine, Engine]:
+        url = self.config.connection.make_url(connection)
+
+        # SQLite pooling is limited, most params don't apply
+        pooling_kwargs = self.config.pooling.model_dump(
+            exclude={"wal_mode", "busy_timeout"},  # These go in URL options
+            exclude_none=True,
+        )
+
+        engine_kwargs = {"echo": self.config.connection.echo, **pooling_kwargs}
+
+        if connection is Connection.ASYNC:
+            self._async_engine = create_async_engine(url, **engine_kwargs)
+            return self._async_engine
+        elif connection is Connection.SYNC:
+            self._sync_engine = create_engine(url, **engine_kwargs)
+            return self._sync_engine
+
+    @overload
+    def get(self, connection: Literal[Connection.ASYNC]) -> AsyncEngine: ...
+    @overload
+    def get(self, connection: Literal[Connection.SYNC]) -> Engine: ...
+    def get(
+        self, connection: Connection = Connection.ASYNC
+    ) -> Union[AsyncEngine, Engine]:
+        if connection is Connection.ASYNC:
+            return self._async_engine
+        elif connection is Connection.SYNC:
+            return self._sync_engine
+
+    def get_all(self) -> Tuple[AsyncEngine, Engine]:
+        return (self._async_engine, self._sync_engine)
+
+    async def dispose(self):
+        await self._async_engine.dispose()
+        self._sync_engine.dispose()

maleo/database/managers/engines/sqlserver.py

@@ -0,0 +1,63 @@
+from sqlalchemy.engine import create_engine, Engine
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncEngine
+from typing import Literal, Tuple, Union, overload
+from ...config import SQLServerDatabaseConfig
+from ...enums import Connection
+
+
+class SQLServerEngineManager:
+    def __init__(self, config: SQLServerDatabaseConfig) -> None:
+        self.config = config
+        self._async_engine: AsyncEngine = self._init(Connection.ASYNC)
+        self._sync_engine: Engine = self._init(Connection.SYNC)
+
+    @overload
+    def _init(self, connection: Literal[Connection.ASYNC]) -> AsyncEngine: ...
+    @overload
+    def _init(self, connection: Literal[Connection.SYNC]) -> Engine: ...
+    def _init(
+        self, connection: Connection = Connection.ASYNC
+    ) -> Union[AsyncEngine, Engine]:
+        url = self.config.connection.make_url(connection)
+
+        pooling_kwargs = self.config.pooling.model_dump(
+            exclude={
+                "strategy",
+                "connection_timeout",  # Goes in URL
+                "command_timeout",  # Goes in URL
+                "packet_size",  # Goes in URL
+                "trust_server_certificate",  # Goes in URL
+            },
+            exclude_none=True,
+        )
+
+        engine_kwargs = {
+            "echo": self.config.connection.echo,
+            **pooling_kwargs,  # This includes encrypt, which is valid
+        }
+
+        if connection is Connection.ASYNC:
+            self._async_engine = create_async_engine(url, **engine_kwargs)
+            return self._async_engine
+        elif connection is Connection.SYNC:
+            self._sync_engine = create_engine(url, **engine_kwargs)
+            return self._sync_engine
+
+    @overload
+    def get(self, connection: Literal[Connection.ASYNC]) -> AsyncEngine: ...
+    @overload
+    def get(self, connection: Literal[Connection.SYNC]) -> Engine: ...
+    def get(
+        self, connection: Connection = Connection.ASYNC
+    ) -> Union[AsyncEngine, Engine]:
+        if connection is Connection.ASYNC:
+            return self._async_engine
+        elif connection is Connection.SYNC:
+            return self._sync_engine
+
+    def get_all(self) -> Tuple[AsyncEngine, Engine]:
+        return (self._async_engine, self._sync_engine)
+
+    async def dispose(self):
+        await self._async_engine.dispose()
+        self._sync_engine.dispose()

maleo/database/managers/session.py

@@ -0,0 +1,123 @@
+from contextlib import (
+    AbstractAsyncContextManager,
+    AbstractContextManager,
+    asynccontextmanager,
+    contextmanager,
+)
+from pydantic import ValidationError
+from sqlalchemy.engine import Engine
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, AsyncSession
+from sqlalchemy.orm import sessionmaker, Session
+from typing import AsyncGenerator, Generator, Literal, Tuple, Union, overload
+from ..enums import Connection
+
+
+class SessionManager:
+    def __init__(self, engines: Tuple[AsyncEngine, Engine]) -> None:
+        self._async_engine, self._sync_engine = engines
+        self._async_sessionmaker: async_sessionmaker[AsyncSession] = async_sessionmaker[
+            AsyncSession
+        ](bind=self._async_engine, expire_on_commit=True)
+        self._sync_sessionmaker: sessionmaker[Session] = sessionmaker[Session](
+            bind=self._sync_engine, expire_on_commit=True
+        )
+
+    async def _async_session_handler(self) -> AsyncGenerator[AsyncSession, None]:
+        """Async session handler with proper error handling."""
+        session = self._async_sessionmaker()
+        try:
+            yield session
+            await session.commit()
+        except (SQLAlchemyError, ValidationError, Exception):
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+
+    def _sync_session_handler(self) -> Generator[Session, None, None]:
+        """Sync session handler with proper error handling."""
+        session = self._sync_sessionmaker()
+        try:
+            yield session
+            session.commit()
+        except (SQLAlchemyError, ValidationError, Exception):
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    # Overloaded inject methods
+    @overload
+    def inject(
+        self, connection: Literal[Connection.ASYNC]
+    ) -> AsyncGenerator[AsyncSession, None]: ...
+
+    @overload
+    def inject(
+        self, connection: Literal[Connection.SYNC]
+    ) -> Generator[Session, None, None]: ...
+
+    def inject(
+        self, connection: Connection = Connection.ASYNC
+    ) -> Union[AsyncGenerator[AsyncSession, None], Generator[Session, None, None]]:
+        """Returns a generator for dependency injection."""
+        if connection is Connection.ASYNC:
+            return self._async_session_handler()
+        else:
+            return self._sync_session_handler()
+
+    # Overloaded context manager methods
+    @overload
+    def get(
+        self, connection: Literal[Connection.ASYNC]
+    ) -> AbstractAsyncContextManager[AsyncSession]: ...
+
+    @overload
+    def get(
+        self, connection: Literal[Connection.SYNC]
+    ) -> AbstractContextManager[Session]: ...
+
+    def get(
+        self, connection: Connection = Connection.ASYNC
+    ) -> Union[
+        AbstractAsyncContextManager[AsyncSession], AbstractContextManager[Session]
+    ]:
+        """Context manager for manual session handling."""
+        if connection is Connection.ASYNC:
+            return self._async_context_manager()
+        else:
+            return self._sync_context_manager()
+
+    @asynccontextmanager
+    async def _async_context_manager(self) -> AsyncGenerator[AsyncSession, None]:
+        """Async context manager implementation."""
+        async for session in self._async_session_handler():
+            yield session
+
+    @contextmanager
+    def _sync_context_manager(self) -> Generator[Session, None, None]:
+        """Sync context manager implementation."""
+        yield from self._sync_session_handler()
+
+    # Alternative: More explicit methods
+    @asynccontextmanager
+    async def get_async(self) -> AsyncGenerator[AsyncSession, None]:
+        """Explicit async context manager."""
+        async for session in self._async_session_handler():
+            yield session
+
+    @contextmanager
+    def get_sync(self) -> Generator[Session, None, None]:
+        """Explicit sync context manager."""
+        yield from self._sync_session_handler()
+        # with self._sync_session_handler() as session:
+        #     yield session
+
+    def inject_async(self) -> AsyncGenerator[AsyncSession, None]:
+        """Explicit async dependency injection."""
+        return self._async_session_handler()
+
+    def inject_sync(self) -> Generator[Session, None, None]:
+        """Explicit sync dependency injection."""
+        return self._sync_session_handler()

maleo/database/orm/base.py

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,17 @@
+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

maleo/database/orm/queries.py

@@ -0,0 +1,234 @@
+from sqlalchemy import Column, Table
+from sqlalchemy.ext.declarative import DeclarativeMeta
+from sqlalchemy.orm import Query, Session, aliased
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+from sqlalchemy.sql.expression import or_, asc, cast, desc
+from sqlalchemy.types import DATE, String, TEXT, TIMESTAMP
+from typing import Sequence, Type
+from maleo.enums.sort import Order
+from maleo.mixins.general import DateFilter, SortColumn
+from maleo.types.base.any import OptionalAny
+from maleo.types.base.boolean import OptionalBoolean
+from maleo.types.base.integer import OptionalListOfIntegers
+from maleo.types.base.string import OptionalListOfStrings, OptionalString
+from maleo.types.enums.status import OptionalListOfDataStatuses
+
+
+def filter_column(
+    query: Query,
+    table: Type[DeclarativeMeta],
+    column: str,
+    value: OptionalAny = None,
+    include_null: bool = False,
+) -> Query:
+    column_attr = getattr(table, column, None)
+    if column_attr is None or not isinstance(column_attr, InstrumentedAttribute):
+        return query
+
+    value_filters = []
+    if value is not None:
+        value_filters.extend([column_attr == val for val in value])
+
+    if value_filters:
+        if include_null:
+            value_filters.append(column_attr.is_(None))
+        query = query.filter(or_(*value_filters))
+
+    return query
+
+
+def filter_ids(
+    query: Query,
+    table: Type[DeclarativeMeta],
+    column: str,
+    ids: OptionalListOfIntegers = None,
+    include_null: bool = False,
+) -> Query:
+    column_attr = getattr(table, column, None)
+    if column_attr is None or not isinstance(column_attr, InstrumentedAttribute):
+        return query
+
+    id_filters = []
+    if ids is not None:
+        id_filters.extend([column_attr == id for id in ids])
+
+    if id_filters:
+        if include_null:
+            id_filters.append(column_attr.is_(None))
+        query = query.filter(or_(*id_filters))
+
+    return query
+
+
+def filter_timestamps(
+    query: Query,
+    table: Type[DeclarativeMeta],  # type: ignore
+    date_filters: Sequence[DateFilter],
+) -> Query:
+    if date_filters and len(date_filters) > 0:
+        for date_filter in date_filters:
+            try:
+                table: Table = table.__table__  # type: ignore
+                column: Column = 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(
+                            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)
+                    elif date_filter.to_date:
+                        query = query.filter(column_attr <= date_filter.to_date)
+            except KeyError:
+                continue
+    return query
+
+
+def filter_statuses(
+    query: Query,
+    table: Type[DeclarativeMeta],
+    statuses: OptionalListOfDataStatuses,
+) -> Query:
+    if statuses is not None:
+        status_filters = [table.status == status for status in statuses]  # type: ignore
+        query = query.filter(or_(*status_filters))
+    return query
+
+
+def filter_is_root(
+    query: Query,
+    table: Type[DeclarativeMeta],
+    parent_column: str = "parent_id",
+    is_root: OptionalBoolean = None,
+) -> Query:
+    parent_attr = getattr(table, parent_column, None)
+    if parent_attr is None or not isinstance(parent_attr, InstrumentedAttribute):
+        return query
+    if is_root is not None:
+        query = query.filter(
+            parent_attr.is_(None) if is_root else parent_attr.is_not(None)
+        )
+    return query
+
+
+def filter_is_parent(
+    session: Session,
+    query: Query,
+    table: Type[DeclarativeMeta],
+    id_column: str = "id",
+    parent_column: str = "parent_id",
+    is_parent: OptionalBoolean = None,
+) -> Query:
+    id_attr = getattr(table, id_column, None)
+    if id_attr is None or not isinstance(id_attr, InstrumentedAttribute):
+        return query
+    parent_attr = getattr(table, parent_column, None)
+    if parent_attr is None or not isinstance(parent_attr, InstrumentedAttribute):
+        return query
+    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
+
+
+def filter_is_child(
+    query: Query,
+    table: Type[DeclarativeMeta],
+    parent_column: str = "parent_id",
+    is_child: OptionalBoolean = None,
+) -> Query:
+    parent_attr = getattr(table, parent_column, None)
+    if parent_attr is None or not isinstance(parent_attr, InstrumentedAttribute):
+        return query
+    if is_child is not None:
+        query = query.filter(
+            parent_attr.is_not(None) if is_child else parent_attr.is_(None)
+        )
+    return query
+
+
+def filter_is_leaf(
+    session: Session,
+    query: Query,
+    table: Type[DeclarativeMeta],
+    id_column: str = "id",
+    parent_column: str = "parent_id",
+    is_leaf: OptionalBoolean = None,
+) -> Query:
+    id_attr = getattr(table, id_column, None)
+    if id_attr is None or not isinstance(id_attr, InstrumentedAttribute):
+        return query
+    parent_attr = getattr(table, parent_column, None)
+    if parent_attr is None or not isinstance(parent_attr, InstrumentedAttribute):
+        return query
+    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
+
+
+def search(
+    query: Query,
+    table: Type[DeclarativeMeta],
+    search: OptionalString = None,
+    columns: OptionalListOfStrings = None,
+) -> Query:
+    if search is None:
+        return query
+
+    search_term = f"%{search}%"
+    sqla_table: Table = table.__table__  # type: ignore
+    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]
+        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))
+
+    return query
+
+
+def sort(
+    query: Query,
+    table: Type[DeclarativeMeta],
+    sort_columns: Sequence[SortColumn],
+) -> Query:
+    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)
+        except AttributeError:
+            continue
+    return query
+
+
+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

maleo_database-0.0.1.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: maleo-database
+Version: 0.0.1
+Summary: Database package for MaleoSuite
+Author-email: Agra Bima Yuda <agra@nexmedis.com>
+License: Proprietary
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aioredis>=2.0.1
+Requires-Dist: annotated-types>=0.7.0
+Requires-Dist: anyio>=4.10.0
+Requires-Dist: async-timeout>=5.0.1
+Requires-Dist: black>=25.1.0
+Requires-Dist: cachetools>=5.5.2
+Requires-Dist: certifi>=2025.8.3
+Requires-Dist: cffi>=1.17.1
+Requires-Dist: cfgv>=3.4.0
+Requires-Dist: click>=8.2.1
+Requires-Dist: cryptography>=45.0.6
+Requires-Dist: distlib>=0.4.0
+Requires-Dist: dnspython>=2.7.0
+Requires-Dist: elastic-transport>=9.1.0
+Requires-Dist: elasticsearch>=9.1.0
+Requires-Dist: fastapi>=0.116.1
+Requires-Dist: filelock>=3.19.1
+Requires-Dist: google-auth>=2.40.3
+Requires-Dist: greenlet>=3.2.4
+Requires-Dist: identify>=2.6.13
+Requires-Dist: idna>=3.10
+Requires-Dist: maleo-constants>=0.0.2
+Requires-Dist: maleo-enums>=0.0.2
+Requires-Dist: maleo-mixins>=0.0.2
+Requires-Dist: maleo-types-base>=0.0.2
+Requires-Dist: maleo-types-enums>=0.0.2
+Requires-Dist: maleo-utils>=0.0.3
+Requires-Dist: motor>=3.7.1
+Requires-Dist: mypy_extensions>=1.1.0
+Requires-Dist: nodeenv>=1.9.1
+Requires-Dist: packaging>=25.0
+Requires-Dist: pathspec>=0.12.1
+Requires-Dist: platformdirs>=4.4.0
+Requires-Dist: pre_commit>=4.3.0
+Requires-Dist: pyasn1>=0.6.1
+Requires-Dist: pyasn1_modules>=0.4.2
+Requires-Dist: pycparser>=2.22
+Requires-Dist: pycryptodome>=3.23.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pydantic_core>=2.33.2
+Requires-Dist: pymongo>=4.14.1
+Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: redis>=6.4.0
+Requires-Dist: rsa>=4.9.1
+Requires-Dist: six>=1.17.0
+Requires-Dist: sniffio>=1.3.1
+Requires-Dist: SQLAlchemy>=2.0.43
+Requires-Dist: starlette>=0.47.3
+Requires-Dist: typing-inspection>=0.4.1
+Requires-Dist: typing_extensions>=4.15.0
+Requires-Dist: urllib3>=2.5.0
+Requires-Dist: virtualenv>=20.34.0
+Dynamic: license-file
+
+# README #
+
+This README would normally document whatever steps are necessary to get your application up and running.
+
+### What is this repository for? ###
+
+* Quick summary
+* Version
+* [Learn Markdown](https://bitbucket.org/tutorials/markdowndemo)
+
+### How do I get set up? ###
+
+* Summary of set up
+* Configuration
+* Dependencies
+* Database configuration
+* How to run tests
+* Deployment instructions
+
+### Contribution guidelines ###
+
+* Writing tests
+* Code review
+* Other guidelines
+
+### Who do I talk to? ###
+
+* Repo owner or admin
+* Other community or team contact