belgie-alchemy 0.1.0__py3-none-any.whl

belgie_alchemy/__init__.py

@@ -0,0 +1,33 @@
+"""SQLAlchemy 2.0 building blocks for database models.
+
+This module provides opinionated defaults and utilities for SQLAlchemy:
+- Base: Declarative base with dataclass mapping and sensible defaults
+- Mixins: PrimaryKeyMixin (UUID), TimestampMixin (created/updated/deleted)
+- Types: DateTimeUTC (timezone-aware datetime storage)
+
+Usage:
+    from belgie_alchemy import Base, PrimaryKeyMixin, TimestampMixin, DateTimeUTC
+
+    class MyModel(Base, PrimaryKeyMixin, TimestampMixin):
+        __tablename__ = "my_models"
+
+        name: Mapped[str]
+        created_on: Mapped[datetime] = mapped_column(DateTimeUTC)
+
+For complete auth model examples, see examples/alchemy/auth_models.py
+"""
+
+from belgie_alchemy.adapter import AlchemyAdapter
+from belgie_alchemy.base import Base
+from belgie_alchemy.mixins import PrimaryKeyMixin, TimestampMixin
+from belgie_alchemy.settings import DatabaseSettings
+from belgie_alchemy.types import DateTimeUTC
+
+__all__ = [
+    "AlchemyAdapter",
+    "Base",
+    "DatabaseSettings",
+    "DateTimeUTC",
+    "PrimaryKeyMixin",
+    "TimestampMixin",
+]

belgie_alchemy/__tests__/adapter/test_adapter.py

@@ -0,0 +1,493 @@
+from datetime import UTC, datetime, timedelta
+from uuid import uuid4
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from belgie_alchemy import AlchemyAdapter
+from belgie_alchemy.__tests__.fixtures.models import Account, OAuthState, Session, User
+
+
+@pytest.fixture
+def adapter(alchemy_session: AsyncSession) -> AlchemyAdapter:  # noqa: ARG001
+    return AlchemyAdapter(
+        user=User,
+        account=Account,
+        session=Session,
+        oauth_state=OAuthState,
+    )
+
+
+@pytest.mark.asyncio
+async def test_create_user(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(
+        alchemy_session,
+        email="test@example.com",
+        name="Test User",
+        email_verified=True,
+    )
+
+    assert user.email == "test@example.com"
+    assert user.name == "Test User"
+    assert user.email_verified is True
+    assert user.id is not None
+    assert user.created_at is not None
+
+
+@pytest.mark.asyncio
+async def test_get_user_by_id(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    created_user = await adapter.create_user(
+        alchemy_session,
+        email="test@example.com",
+        name="Test User",
+    )
+
+    found_user = await adapter.get_user_by_id(alchemy_session, created_user.id)
+
+    assert found_user is not None
+    assert found_user.id == created_user.id
+    assert found_user.email == "test@example.com"
+
+
+@pytest.mark.asyncio
+async def test_get_user_by_id_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.get_user_by_id(alchemy_session, uuid4())
+    assert user is None
+
+
+@pytest.mark.asyncio
+async def test_get_user_by_email(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    await adapter.create_user(
+        alchemy_session,
+        email="test@example.com",
+        name="Test User",
+    )
+
+    user = await adapter.get_user_by_email(alchemy_session, "test@example.com")
+
+    assert user is not None
+    assert user.email == "test@example.com"
+
+
+@pytest.mark.asyncio
+async def test_get_user_by_email_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.get_user_by_email(alchemy_session, "nonexistent@example.com")
+    assert user is None
+
+
+@pytest.mark.asyncio
+async def test_update_user(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(
+        alchemy_session,
+        email="test@example.com",
+        name="Test User",
+    )
+
+    updated_user = await adapter.update_user(
+        alchemy_session,
+        user.id,
+        name="Updated Name",
+        email_verified=True,
+    )
+
+    assert updated_user is not None
+    assert updated_user.name == "Updated Name"
+    assert updated_user.email_verified is True
+
+
+@pytest.mark.asyncio
+async def test_update_user_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    updated_user = await adapter.update_user(
+        alchemy_session,
+        uuid4(),
+        name="Updated Name",
+    )
+    assert updated_user is None
+
+
+@pytest.mark.asyncio
+async def test_create_account(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(
+        alchemy_session,
+        email="test@example.com",
+    )
+
+    account = await adapter.create_account(
+        alchemy_session,
+        user_id=user.id,
+        provider="google",
+        provider_account_id="12345",
+        access_token="token",
+        refresh_token="refresh",
+        expires_at=datetime.now(UTC) + timedelta(hours=1),
+        token_type="Bearer",
+        scope="openid email",
+        id_token="id_token",
+    )
+
+    assert account.user_id == user.id
+    assert account.provider == "google"
+    assert account.provider_account_id == "12345"
+    assert account.access_token == "token"  # noqa: S105
+    assert account.refresh_token == "refresh"  # noqa: S105
+    assert account.token_type == "Bearer"  # noqa: S105
+
+
+@pytest.mark.asyncio
+async def test_get_account(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(
+        alchemy_session,
+        email="test@example.com",
+    )
+
+    await adapter.create_account(
+        alchemy_session,
+        user_id=user.id,
+        provider="google",
+        provider_account_id="12345",
+    )
+
+    account = await adapter.get_account(alchemy_session, "google", "12345")
+
+    assert account is not None
+    assert account.provider == "google"
+    assert account.provider_account_id == "12345"
+
+
+@pytest.mark.asyncio
+async def test_get_account_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    account = await adapter.get_account(alchemy_session, "google", "nonexistent")
+    assert account is None
+
+
+@pytest.mark.asyncio
+async def test_create_session(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(
+        alchemy_session,
+        email="test@example.com",
+    )
+
+    expires_at = datetime.now(UTC) + timedelta(days=7)
+    session = await adapter.create_session(
+        alchemy_session,
+        user_id=user.id,
+        expires_at=expires_at,
+        ip_address="127.0.0.1",
+        user_agent="Test Agent",
+    )
+
+    assert session.user_id == user.id
+    assert session.expires_at.replace(tzinfo=UTC) == expires_at
+    assert session.ip_address == "127.0.0.1"
+    assert session.user_agent == "Test Agent"
+
+
+@pytest.mark.asyncio
+async def test_get_session(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(
+        alchemy_session,
+        email="test@example.com",
+    )
+
+    created_session = await adapter.create_session(
+        alchemy_session,
+        user_id=user.id,
+        expires_at=datetime.now(UTC) + timedelta(days=7),
+    )
+
+    found_session = await adapter.get_session(alchemy_session, created_session.id)
+
+    assert found_session is not None
+    assert found_session.id == created_session.id
+
+
+@pytest.mark.asyncio
+async def test_get_session_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    session = await adapter.get_session(alchemy_session, uuid4())
+    assert session is None
+
+
+@pytest.mark.asyncio
+async def test_update_session(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(
+        alchemy_session,
+        email="test@example.com",
+    )
+
+    session = await adapter.create_session(
+        alchemy_session,
+        user_id=user.id,
+        expires_at=datetime.now(UTC) + timedelta(days=7),
+    )
+
+    new_expires = datetime.now(UTC) + timedelta(days=14)
+    updated_session = await adapter.update_session(
+        alchemy_session,
+        session.id,
+        expires_at=new_expires,
+        ip_address="192.168.1.1",
+    )
+
+    assert updated_session is not None
+    assert updated_session.expires_at.replace(tzinfo=UTC) == new_expires
+    assert updated_session.ip_address == "192.168.1.1"
+
+
+@pytest.mark.asyncio
+async def test_update_session_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    updated_session = await adapter.update_session(
+        alchemy_session,
+        uuid4(),
+        expires_at=datetime.now(UTC) + timedelta(days=7),
+    )
+    assert updated_session is None
+
+
+@pytest.mark.asyncio
+async def test_delete_session(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(
+        alchemy_session,
+        email="test@example.com",
+    )
+
+    session = await adapter.create_session(
+        alchemy_session,
+        user_id=user.id,
+        expires_at=datetime.now(UTC) + timedelta(days=7),
+    )
+
+    deleted = await adapter.delete_session(alchemy_session, session.id)
+    assert deleted is True
+
+    found = await adapter.get_session(alchemy_session, session.id)
+    assert found is None
+
+
+@pytest.mark.asyncio
+async def test_delete_session_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    deleted = await adapter.delete_session(alchemy_session, uuid4())
+    assert deleted is False
+
+
+@pytest.mark.asyncio
+async def test_delete_expired_sessions(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(
+        alchemy_session,
+        email="test@example.com",
+    )
+
+    await adapter.create_session(
+        alchemy_session,
+        user_id=user.id,
+        expires_at=datetime.now(UTC) - timedelta(days=1),
+    )
+
+    await adapter.create_session(
+        alchemy_session,
+        user_id=user.id,
+        expires_at=datetime.now(UTC) + timedelta(days=7),
+    )
+
+    count = await adapter.delete_expired_sessions(alchemy_session)
+    assert count == 1
+
+
+@pytest.mark.asyncio
+async def test_create_oauth_state(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    expires_at = datetime.now(UTC) + timedelta(minutes=10)
+    oauth_state = await adapter.create_oauth_state(
+        alchemy_session,
+        state="random_state_123",
+        expires_at=expires_at,
+        code_verifier="verifier_abc",
+        redirect_url="/dashboard",
+    )
+
+    assert oauth_state.state == "random_state_123"
+    assert oauth_state.code_verifier == "verifier_abc"
+    assert oauth_state.redirect_url == "/dashboard"
+    assert oauth_state.expires_at.replace(tzinfo=UTC) == expires_at
+
+
+@pytest.mark.asyncio
+async def test_get_oauth_state(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    await adapter.create_oauth_state(
+        alchemy_session,
+        state="random_state_123",
+        expires_at=datetime.now(UTC) + timedelta(minutes=10),
+    )
+
+    oauth_state = await adapter.get_oauth_state(alchemy_session, "random_state_123")
+
+    assert oauth_state is not None
+    assert oauth_state.state == "random_state_123"
+
+
+@pytest.mark.asyncio
+async def test_get_oauth_state_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    oauth_state = await adapter.get_oauth_state(alchemy_session, "nonexistent")
+    assert oauth_state is None
+
+
+@pytest.mark.asyncio
+async def test_delete_oauth_state(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    await adapter.create_oauth_state(
+        alchemy_session,
+        state="random_state_123",
+        expires_at=datetime.now(UTC) + timedelta(minutes=10),
+    )
+
+    deleted = await adapter.delete_oauth_state(alchemy_session, "random_state_123")
+    assert deleted is True
+
+    found = await adapter.get_oauth_state(alchemy_session, "random_state_123")
+    assert found is None
+
+
+@pytest.mark.asyncio
+async def test_delete_oauth_state_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    deleted = await adapter.delete_oauth_state(alchemy_session, "nonexistent")
+    assert deleted is False
+
+
+@pytest.mark.asyncio
+async def test_user_with_custom_fields(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user_data = User(
+        email="custom@example.com",
+        email_verified=True,
+        name="Custom User",
+        image=None,
+        custom_field="custom value",
+    )
+    alchemy_session.add(user_data)
+    await alchemy_session.commit()
+
+    found = await adapter.get_user_by_email(alchemy_session, "custom@example.com")
+    assert found is not None
+    assert found.custom_field == "custom value"
+
+
+@pytest.mark.asyncio
+async def test_delete_user_deletes_user(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(alchemy_session, email="delete@example.com", name="Delete User")
+
+    deleted = await adapter.delete_user(alchemy_session, user.id)
+
+    assert deleted is True
+    assert await adapter.get_user_by_id(alchemy_session, user.id) is None
+
+
+@pytest.mark.asyncio
+async def test_delete_user_deletes_sessions(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(alchemy_session, email="delete@example.com", name="Delete User")
+
+    expires_at = datetime.now(UTC) + timedelta(days=1)
+    session1 = await adapter.create_session(alchemy_session, user.id, expires_at.replace(tzinfo=None))
+    session2 = await adapter.create_session(alchemy_session, user.id, expires_at.replace(tzinfo=None))
+
+    await adapter.delete_user(alchemy_session, user.id)
+
+    assert await adapter.get_session(alchemy_session, session1.id) is None
+    assert await adapter.get_session(alchemy_session, session2.id) is None
+
+
+@pytest.mark.asyncio
+async def test_delete_user_deletes_accounts(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
+    user = await adapter.create_user(alchemy_session, email="delete@example.com", name="Delete User")
+
+    await adapter.create_account(
+        alchemy_session,
+        user.id,
+        "google",
+        "google-123",
+        access_token="token123",
+    )
+
+    await adapter.delete_user(alchemy_session, user.id)
+
+    assert await adapter.get_account(alchemy_session, "google", "google-123") is None
+
+
+@pytest.mark.asyncio
+async def test_delete_user_deletes_all_related_data(
+    adapter: AlchemyAdapter,
+    alchemy_session: AsyncSession,
+) -> None:
+    user = await adapter.create_user(alchemy_session, email="delete@example.com", name="Delete User")
+
+    expires_at = datetime.now(UTC) + timedelta(days=1)
+    session1 = await adapter.create_session(alchemy_session, user.id, expires_at.replace(tzinfo=None))
+    session2 = await adapter.create_session(alchemy_session, user.id, expires_at.replace(tzinfo=None))
+
+    await adapter.create_account(
+        alchemy_session,
+        user.id,
+        "google",
+        "google-123",
+        access_token="token123",
+    )
+    await adapter.create_account(
+        alchemy_session,
+        user.id,
+        "github",
+        "github-456",
+        access_token="token456",
+    )
+
+    deleted = await adapter.delete_user(alchemy_session, user.id)
+
+    assert deleted is True
+    assert await adapter.get_user_by_id(alchemy_session, user.id) is None
+    assert await adapter.get_session(alchemy_session, session1.id) is None
+    assert await adapter.get_session(alchemy_session, session2.id) is None
+    assert await adapter.get_account(alchemy_session, "google", "google-123") is None
+    assert await adapter.get_account(alchemy_session, "github", "github-456") is None
+
+
+@pytest.mark.asyncio
+async def test_delete_user_returns_false_if_user_not_found(
+    adapter: AlchemyAdapter,
+    alchemy_session: AsyncSession,
+) -> None:
+    fake_user_id = uuid4()
+    deleted = await adapter.delete_user(alchemy_session, fake_user_id)
+
+    assert deleted is False
+
+
+@pytest.mark.asyncio
+async def test_delete_user_only_deletes_target_users_data(
+    adapter: AlchemyAdapter,
+    alchemy_session: AsyncSession,
+) -> None:
+    user1 = await adapter.create_user(alchemy_session, email="user1@example.com", name="User 1")
+    user2 = await adapter.create_user(alchemy_session, email="user2@example.com", name="User 2")
+
+    expires_at = datetime.now(UTC) + timedelta(days=1)
+    session1 = await adapter.create_session(alchemy_session, user1.id, expires_at.replace(tzinfo=None))
+    session2 = await adapter.create_session(alchemy_session, user2.id, expires_at.replace(tzinfo=None))
+
+    await adapter.create_account(
+        alchemy_session,
+        user1.id,
+        "google",
+        "google-user1",
+        access_token="token1",
+    )
+    await adapter.create_account(
+        alchemy_session,
+        user2.id,
+        "google",
+        "google-user2",
+        access_token="token2",
+    )
+
+    await adapter.delete_user(alchemy_session, user1.id)
+
+    assert await adapter.get_user_by_id(alchemy_session, user1.id) is None
+    assert await adapter.get_session(alchemy_session, session1.id) is None
+    assert await adapter.get_account(alchemy_session, "google", "google-user1") is None
+
+    assert await adapter.get_user_by_id(alchemy_session, user2.id) is not None
+    assert await adapter.get_session(alchemy_session, session2.id) is not None
+    assert await adapter.get_account(alchemy_session, "google", "google-user2") is not None

belgie_alchemy/__tests__/auth_models/test_auth_models.py

@@ -0,0 +1,91 @@
+from datetime import UTC, datetime, timedelta
+
+import pytest
+from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from belgie_alchemy.__tests__.fixtures.models import Account, OAuthState, Session, User
+
+
+def test_user_model_structure() -> None:
+    """Verify User model demonstrates proper structure."""
+    assert User.__tablename__ == "users"
+    assert not getattr(User, "__abstract__", False)
+    assert hasattr(User, "email")
+    assert hasattr(User, "scopes")
+
+
+def test_user_has_scopes_field() -> None:
+    """Verify User has scopes field that accepts list of strings."""
+    user = User(email="test@example.com")
+    user.scopes = ["read", "write"]
+    assert user.scopes == ["read", "write"]
+
+
+def test_user_relationships_defined() -> None:
+    """Verify User has bidirectional relationships defined."""
+    assert hasattr(User, "accounts")
+    assert hasattr(User, "sessions")
+    assert hasattr(User, "oauth_states")
+
+
+@pytest.mark.asyncio
+async def test_account_unique_constraint(alchemy_session: AsyncSession) -> None:
+    user = User(email="auth@example.com")
+    alchemy_session.add(user)
+    await alchemy_session.commit()
+
+    account = Account(
+        user_id=user.id,
+        provider="google",
+        provider_account_id="abc",
+    )
+    alchemy_session.add(account)
+    await alchemy_session.commit()
+
+    duplicate = Account(
+        user_id=user.id,
+        provider="google",
+        provider_account_id="abc",
+    )
+    alchemy_session.add(duplicate)
+    with pytest.raises(IntegrityError):
+        await alchemy_session.commit()
+    await alchemy_session.rollback()
+
+
+@pytest.mark.asyncio
+async def test_session_relationship(alchemy_session: AsyncSession) -> None:
+    user = User(email="session@example.com")
+    alchemy_session.add(user)
+    await alchemy_session.commit()
+
+    session = Session(
+        user_id=user.id,
+        expires_at=datetime.now(UTC) + timedelta(days=1),
+    )
+    alchemy_session.add(session)
+    await alchemy_session.commit()
+
+    refreshed = await alchemy_session.get(User, user.id)
+    assert refreshed is not None
+    await alchemy_session.refresh(refreshed, attribute_names=["sessions"])
+    assert len(refreshed.sessions) == 1
+
+
+@pytest.mark.asyncio
+async def test_oauth_state_optional_user(alchemy_session: AsyncSession) -> None:
+    state = OAuthState(
+        state="abc",
+        code_verifier=None,
+        redirect_url=None,
+        expires_at=datetime.now(UTC) + timedelta(minutes=5),
+        user_id=None,
+    )
+    alchemy_session.add(state)
+    await alchemy_session.commit()
+
+    rows = await alchemy_session.execute(select(OAuthState))
+    stored = rows.scalar_one()
+    assert stored.user is None