py-auth-sqlalchemy 0.0.1__tar.gz → 0.0.2__tar.gz

py_auth_sqlalchemy-0.0.2/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: py-auth-sqlalchemy
+Version: 0.0.2
+Summary: High-performance, async SQLAlchemy adapter for py-auth-core.
+Author-email: Olatunji Jamaldeen Omotoyosi <jamaldeen.o@yahoo.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jamaldeen09/py-auth
+Project-URL: Repository, https://github.com/jamaldeen09/py-auth
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: greenlet>=3.0.0
+Requires-Dist: py-auth-core>=0.0.3
+Dynamic: license-file

{py_auth_sqlalchemy-0.0.1 → py_auth_sqlalchemy-0.0.2}/pyproject.toml

@@ -4,16 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "py-auth-sqlalchemy"
-version = "0.0.1"
+version = "0.0.2"
 authors = [
   { name = "Olatunji Jamaldeen Omotoyosi", email = "jamaldeen.o@yahoo.com" },
 ]
 description = "High-performance, async SQLAlchemy adapter for py-auth-core."
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -27,7 +26,7 @@ license-files = ["LICENSE"]
 dependencies = [
     "sqlalchemy>=2.0.0",
     "greenlet>=3.0.0",
-    "py-auth-core>=0.0.1",
+    "py-auth-core>=0.0.3"  
 ]
 
 [project.urls]

py_auth_sqlalchemy-0.0.2/src/py_auth_sqlalchemy/__init__.py

@@ -0,0 +1,8 @@
+"""SQLAlchemy adapter for py-auth database persistence with async support."""
+
+
+from .core import SqlAlchemyAdapter
+from .utc_datetime import UTCDateTime
+
+__all__ = ["SqlAlchemyAdapter", "UTCDateTime"]
+__version__ = "0.0.2"

py_auth_sqlalchemy-0.0.1/src/py_auth_sqlalchemy/utils.py → py_auth_sqlalchemy-0.0.2/src/py_auth_sqlalchemy/_utils.py

@@ -1,3 +1,5 @@
+"""Utility functions for engine validation, model validation, and database error handling."""
+
 from contextlib import asynccontextmanager
 from typing import Any
 
@@ -12,7 +14,6 @@ from sqlalchemy import inspect
 from sqlalchemy.exc import IntegrityError, NoResultFound
 from sqlalchemy.ext.asyncio import AsyncEngine
 
-
 def validate_async_engine(engine: object) -> AsyncEngine:
     """Validate that the engine is an asynchronous SQLAlchemy AsyncEngine
     and uses a supported asynchronous database driver.
@@ -23,7 +24,6 @@ def validate_async_engine(engine: object) -> AsyncEngine:
             "'AsyncEngine' (created via create_async_engine)."
         )
 
-    # Inspect the driver prefix from the engine's URL object
     supported_drivers = ("asyncpg", "aiomysql", "aiosqlite")
     driver = engine.url.get_driver_name()
 
@@ -37,7 +37,7 @@ def validate_async_engine(engine: object) -> AsyncEngine:
 
 def validate_sqlalchemy_model(
     model: type[Any],
-    required_cols: set[str],
+    required_columns: set[str],
     model_name: str | None = None,
 ) -> type[Any]:
     """Validate that the provided class is a valid SQLAlchemy declarative model
@@ -51,20 +51,19 @@ def validate_sqlalchemy_model(
 
     try:
         mapper = inspect(model)
-        col_names = {c.key for c in mapper.columns}
+        column_names = {c.key for c in mapper.columns}
     except Exception as e:
         raise AdapterError(
             f"Provided '{display_name}' must be a valid SQLAlchemy model class: {e}"
         )
 
-    if not required_cols.issubset(col_names):
-        missing = sorted(required_cols - col_names)
+    if not required_columns.issubset(column_names):
+        missing = sorted(required_columns - column_names)
         raise AdapterError(
             f"Custom {display_name} model is missing required py-auth columns: {missing}. "
             "Extra custom columns are allowed, but these base columns are mandatory."
         )
-    return model
-
+    return model    
 
 @asynccontextmanager
 async def handle_db_errors(operation: str):
@@ -84,7 +83,7 @@ async def handle_db_errors(operation: str):
                 f"Failed to complete operation '{operation}': a record with this unique value already exists."
             ) from e
         raise PyAuthError(
-            f"Database integrity error occurred in operation '{operation}': {e}"
+            f"Database integrity error occurred in operation '{operation}'"
         ) from e
 
     except NoResultFound as e:
@@ -96,5 +95,5 @@ async def handle_db_errors(operation: str):
         raise
     except Exception as e:
         raise PyAuthError(
-            f"An unexpected database error occurred in operation '{operation}': {e}"
+            f"An unexpected database error occurred in operation '{operation}'"
         ) from e

py_auth_sqlalchemy-0.0.2/src/py_auth_sqlalchemy/core.py

@@ -0,0 +1,350 @@
+"""SQLAlchemy adapter implementation for py-auth database operations."""
+
+from ._utils import handle_db_errors, validate_async_engine, validate_sqlalchemy_model
+
+from typing import Any, Dict, Type, List
+from sqlalchemy import delete, select, and_
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker
+from py_auth.exceptions import AdapterError, DuplicateEntryError
+
+class SqlAlchemyAdapter:
+    """SQLAlchemy adapter implementation for py-auth database operations with async support."""
+
+    def __init__(
+        self,
+        engine: AsyncEngine,
+        session_model: Type[Any],
+        user_model: Type[Any] | None = None,
+        account_model: Type[Any] | None = None,
+    ):
+        self.session_model = validate_sqlalchemy_model(
+            model=session_model,
+            model_name="Session",
+            required_columns={
+                "id",
+                "session_token_hash",
+                "user_id",
+                "expires",
+            },
+        )
+
+        if user_model:
+            self.user_model = validate_sqlalchemy_model(
+                model=user_model,
+                model_name="User",
+                required_columns={
+                   "id",
+                   "email",
+                   "name",
+                   "image",
+                   "password_hash"
+                }
+            )
+
+        if account_model:
+            self.account_model = validate_sqlalchemy_model(
+                model=account_model,
+                model_name="Account",
+                required_columns={
+                    "id",
+                    "user_id",
+                    "type",
+                    "provider",
+                    "provider_account_id",
+                    "access_token",
+                    "refresh_token",
+                    "expires_at",
+                    "token_type",
+                    "scope",
+                    "id_token",
+                    "session_state"
+                }
+            )
+
+
+        self.engine = validate_async_engine(engine=engine)
+        self.session_maker = async_sessionmaker(
+            bind=self.engine, class_=AsyncSession, expire_on_commit=False
+        )
+
+    def _row_to_dict(self, instance: Any) -> Dict[str, Any] | None:
+        """Convert ORM instance to a dictionary using its table column names."""
+        if instance is None:
+            return None
+        cols = [c.name for c in instance.__table__.columns]
+        return {name: getattr(instance, name) for name in cols}
+
+
+
+
+    async def create_user(self, user_data: dict) -> Dict[str, Any] | None:
+        if not self.user_model:
+            raise AdapterError(
+                "Attempted to call 'create_user', "
+                "but 'user_model' is not configured."
+            )
+        
+        async with handle_db_errors(operation="create_user"):
+            async with self.session_maker() as session:
+                async with session.begin():
+                    user = self.user_model(**user_data)
+                    session.add(user)
+                return self._row_to_dict(user)
+            
+    async def get_user(self, user_id: str) -> Dict[str, Any] | None:
+        if not self.user_model:
+            raise AdapterError(
+                "Attempted to call 'get_user', "
+                "but 'user_model' is not configured."
+            )
+        
+        async with handle_db_errors(operation="get_user"):
+            async with self.session_maker() as session:
+                stmt = select(self.user_model).where(self.user_model.id == user_id)
+                result = await session.execute(stmt)
+                user = result.scalars().first()
+                return self._row_to_dict(user)
+            
+    async def get_user_by_email(self, email: str) -> Dict[str, Any] | None:
+        if not self.user_model:
+            raise AdapterError(
+                "Attempted to call 'get_user_by_email', "
+                "but 'user_model' is not configured."
+            )
+          
+        async with handle_db_errors(operation="get_user_by_email"):
+            async with self.session_maker() as session:
+                stmt = select(self.user_model).where(self.user_model.email == email)
+                result = await session.execute(stmt)
+                user = result.scalars().first()
+                return self._row_to_dict(user)
+    
+    async def update_user(self, user_id: str, updates: Dict[str, Any]) -> Dict[str, Any] | None:
+        if not self.user_model:
+            raise AdapterError(
+                "Attempted to call 'update_user', "
+                "but 'user_model' is not configured."
+            )
+        
+        async with handle_db_errors(operation="update_user"):
+            async with self.session_maker() as session:
+                async with session.begin():
+                    result = await session.execute(
+                        select(self.user_model)
+                        .where(self.user_model.id == user_id)
+                        .with_for_update()
+                    )
+                    user = result.scalars().first()
+
+                    if user is None:
+                        return None
+                    
+                    for key, value in updates.items():
+                        if hasattr(user, key) and key != "id":
+                            setattr(user, key, value)
+
+                await session.refresh(user)
+                return self._row_to_dict(user)
+            
+    async def delete_user(self, user_id: str) -> None:
+        if not self.user_model:
+            raise AdapterError(
+                "Attempted to call 'delete_user', "
+                "but 'user_model' is not configured."
+            )
+
+        async with handle_db_errors(operation="delete_user"): 
+            async with self.session_maker() as session:
+                async with session.begin():
+                    user = await session.get(self.user_model, user_id)
+                    if user is None:
+                        return
+                    await session.delete(user)
+
+
+        # 
+    
+
+
+
+    async def list_accounts_for_user(self, user_id: str) -> List[(Dict[str, Any] | None)]:
+        if not self.account_model:
+            raise AdapterError(
+                "Attempted to call 'list_accounts_for_user', "
+                "but 'account_model' is not configured."
+            )
+        async with handle_db_errors(operation="list_accounts_for_user"):
+            async with self.session_maker() as session:
+                stmt = select(self.account_model).where(self.account_model.user_id == user_id)
+                result = await session.execute(stmt)
+                return [self._row_to_dict(a) for a in result.scalars().all()]
+            
+    async def link_account(self, account_data: Dict[str, Any]) -> Dict[str, Any] | None:
+        if not self.account_model:
+            raise AdapterError(
+                "Attempted to call 'link_account', "
+                "but 'account_model' is not configured."
+            )
+        
+        async with handle_db_errors(operation="link_account"):
+            async with self.session_maker() as session:
+                async with session.begin():
+                    account = self.account_model(**account_data)
+                    session.add(account)
+                    await session.flush()
+                return self._row_to_dict(account)
+            
+    async def unlink_account(self, provider: str, provider_account_id: str) -> None:
+        if not self.account_model:
+            raise AdapterError(
+                "Attempted to call 'unlink_account', "
+                "but 'account_model' is not configured."
+            )
+         
+        async with self.session_maker() as session:
+            async with session.begin():
+                stmt = (
+                    delete(self.account_model)
+                    .where(
+                        and_(
+                            self.account_model.provider == provider,
+                            self.account_model.provider_account_id == provider_account_id,
+                        )
+                    )
+                )
+                await session.execute(stmt)
+
+
+
+
+    async def create_session(self, session_data: Dict[str, Any]) -> Dict[str, Any] | None:
+        """Create and persist a new session record."""
+        async with handle_db_errors(operation="create_session"):
+            async with self.session_maker() as session:
+                async with session.begin():
+                    s = self.session_model(**session_data)
+                    session.add(s)
+                    await session.flush()
+                return self._row_to_dict(s)
+            
+    async def list_sessions_for_user(self, user_id: str) -> List[(Dict[str, Any] | None)]:
+        async with handle_db_errors(operation="list_sessions_for_user"):
+            async with self.session_maker() as session:
+                stmt = select(self.session_model).where(self.session_model.user_id == user_id)
+                result = await session.execute(stmt)
+                return [self._row_to_dict(s) for s in result.scalars().all()]
+
+    async def update_session(
+        self, session_id: str, updates: Dict[str, Any]
+    ) -> Dict[str, Any] | None:
+        async with handle_db_errors(operation="update_session"):
+            async with self.session_maker() as session:
+                async with session.begin():
+                    result = await session.execute(
+                        select(self.session_model)
+                        .where(self.session_model.id == session_id)
+                        .with_for_update()
+                    )
+                    _session = result.scalars().first()
+
+                    if _session is None:
+                        return None
+                    
+                    for key, value in updates.items():
+                        if hasattr(_session, key) and key != "id":
+                            setattr(_session, key, value)
+
+                await session.refresh(_session)
+                return self._row_to_dict(_session)
+
+    async def get_session_by_session_token_hash(
+        self, session_token_hash: str
+    ) -> Dict[str, Any] | None:
+        """Retrieve a session record by its hashed session token."""
+        async with handle_db_errors(operation="get_session_by_session_token_hash"):
+            async with self.session_maker() as session:
+                stmt = select(self.session_model).where(
+                    self.session_model.session_token_hash == session_token_hash
+                )
+                result = await session.execute(stmt)
+                s = result.scalar_one_or_none()
+                if not s:
+                    return None
+                return self._row_to_dict(s)
+
+    async def delete_session_by_session_token_hash(
+        self, session_token_hash: str
+    ) -> None:
+        """Delete a session record by its hashed session token."""
+        async with handle_db_errors(operation="delete_session_by_session_token_hash"):
+            async with self.session_maker() as session:
+                async with session.begin():
+                    stmt = delete(self.session_model).where(
+                        self.session_model.session_token_hash == session_token_hash
+                    )
+                    await session.execute(stmt)
+
+    async def delete_session(self, session_id: Any) -> None:
+        """Delete a session record by its unique identifier."""
+        async with handle_db_errors(operation="delete_session_by_id"):
+            async with self.session_maker() as session:
+                async with session.begin():
+                    stmt = delete(self.session_model).where(
+                        self.session_model.id == session_id
+                    )
+                    await session.execute(stmt)
+
+
+
+
+    async def get_or_create_user_and_link_account(self, email: str, user_data: Dict[str, Any], account_data: Dict[str, Any]) -> Dict[str, Any] | None:
+        if not self.user_model:
+            raise AdapterError(
+                "Attempted to call 'get_or_create_user_and_link_account', "
+                "but 'user_model' is not configured."
+            )
+
+        if not self.account_model:
+            raise AdapterError(
+                "Attempted to call 'get_or_create_user_and_link_account', "
+                "but 'account_model' is not configured."
+            )
+        
+        lookup_email = (user_data.get("email") or email).lower()
+        user_data = {**user_data, "email": lookup_email}
+
+        async with handle_db_errors(operation="get_or_create_user_and_link_account"):
+            async with self.session_maker() as session:
+                async with session.begin():
+                    user_result = await session.execute(
+                        select(self.user_model).where(self.user_model.email == lookup_email)
+                    )
+                    user = user_result.scalar_one_or_none()
+
+                    if user is None:
+                        user = self.user_model(**user_data)
+                        session.add(user)
+                        await session.flush()
+
+                    provider = account_data["provider"]
+                    provider_account_id = account_data["provider_account_id"]
+                    account_result = await session.execute(select(self.account_model).where(
+                        self.account_model.provider == provider,
+                        self.account_model.provider_account_id == provider_account_id,
+                    ))
+                    account = account_result.scalar_one_or_none()
+
+                    if account is None:
+                        account = self.account_model(**account_data, user_id=user.id)
+                        session.add(account)
+                        await session.flush()
+
+                    elif account.user_id != user.id:
+                        raise DuplicateEntryError(
+                            "This social account is already linked to another user profile."
+                        )
+
+                    user_dict = self._row_to_dict(user)
+                    account_dict = self._row_to_dict(account)
+                    return {"user": user_dict, "account": account_dict}
+    

py_auth_sqlalchemy-0.0.2/src/py_auth_sqlalchemy/utc_datetime.py

@@ -0,0 +1,58 @@
+"""SQLAlchemy datetime type for consistent UTC-aware datetime handling across database backends."""
+
+from sqlalchemy import DateTime
+from datetime import datetime, timezone
+from sqlalchemy.dialects.mysql import DATETIME
+from sqlalchemy.types import TypeDecorator
+
+class UTCDateTime(TypeDecorator):
+    """SQLAlchemy datetime type that provides consistent UTC-aware datetimes across supported database backends."""
+
+    impl = DateTime
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect):
+        if dialect.name == "mysql":
+            return dialect.type_descriptor(
+                DATETIME(fsp=6)
+            )
+        
+        if dialect.name == "sqlite":
+            return dialect.type_descriptor(
+                DateTime()
+            )
+
+        return dialect.type_descriptor(
+            DateTime(timezone=True)
+        )
+
+    def process_bind_param(
+        self,
+        value: datetime | None,
+        dialect,
+    ):
+        if value is None:
+            return None
+
+        if value.tzinfo is None:
+            raise ValueError("UTCDateTime requires a timezone-aware datetime")
+
+        value = value.astimezone(timezone.utc)
+
+        if dialect.name in ("mysql", "sqlite"):
+            return value.replace(tzinfo=None)
+
+        return value
+
+    def process_result_value(
+        self,
+        value: datetime | None,
+        dialect,
+    ):
+        if value is None:
+            return None
+
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+
+        return value.astimezone(timezone.utc)

py_auth_sqlalchemy-0.0.2/src/py_auth_sqlalchemy.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: py-auth-sqlalchemy
+Version: 0.0.2
+Summary: High-performance, async SQLAlchemy adapter for py-auth-core.
+Author-email: Olatunji Jamaldeen Omotoyosi <jamaldeen.o@yahoo.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jamaldeen09/py-auth
+Project-URL: Repository, https://github.com/jamaldeen09/py-auth
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: greenlet>=3.0.0
+Requires-Dist: py-auth-core>=0.0.3
+Dynamic: license-file

{py_auth_sqlalchemy-0.0.1 → py_auth_sqlalchemy-0.0.2}/src/py_auth_sqlalchemy.egg-info/SOURCES.txt

@@ -2,9 +2,10 @@ LICENSE
 README.md
 pyproject.toml
 src/py_auth_sqlalchemy/__init__.py
+src/py_auth_sqlalchemy/_utils.py
 src/py_auth_sqlalchemy/core.py
 src/py_auth_sqlalchemy/py.typed
-src/py_auth_sqlalchemy/utils.py
+src/py_auth_sqlalchemy/utc_datetime.py
 src/py_auth_sqlalchemy.egg-info/PKG-INFO
 src/py_auth_sqlalchemy.egg-info/SOURCES.txt
 src/py_auth_sqlalchemy.egg-info/dependency_links.txt

{py_auth_sqlalchemy-0.0.1 → py_auth_sqlalchemy-0.0.2}/src/py_auth_sqlalchemy.egg-info/requires.txt

@@ -1,3 +1,3 @@
 sqlalchemy>=2.0.0
 greenlet>=3.0.0
-py-auth-core>=0.0.1
+py-auth-core>=0.0.3