fix: added name for primary key constraint

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.github/workflows/ci.yml

@@ -38,7 +38,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
         with:
-          python-version: '3.12'
+          python-version: '3.13'
       - run: python -m pip install --upgrade pip
       - run: |
           python -m pip install -r requirements.txt
@@ -93,7 +93,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.12'
+          python-version: '3.13'
 
       - name: Install dependencies
         run: |

.gitignore

@@ -158,3 +158,5 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+.DS_*

creyPY/const/__init__.py

@@ -1,3 +1,4 @@
+from .fields import *  # noqa
 from .groups import *  # noqa
 from .i18n import *  # noqa
 from .stripe import *  # noqa

creyPY/const/fields.py

@@ -0,0 +1,17 @@
+from sqlalchemy import types
+
+
+class LowerCaseString(types.TypeDecorator):
+    """Converts strings to lower case on the way in."""
+
+    impl = types.String
+    cache_ok = True
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+        return value.lower()
+
+    @property
+    def python_type(self):
+        return str

creyPY/fastapi/crud.py

@@ -1,12 +1,13 @@
-from typing import Type, TypeVar, overload
+import asyncio
+from typing import List, Type, TypeVar, overload
 from uuid import UUID
 
 from fastapi import HTTPException
 from pydantic import BaseModel
-from sqlalchemy.orm import Session
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
-import asyncio
+from sqlalchemy.orm import Session
+
 from .models.base import Base
 
 T = TypeVar("T", bound=Base)
@@ -19,13 +20,19 @@ async def get_object_or_404(
     db: AsyncSession,
     expunge: bool = False,
     lookup_column: str = "id",
+    response_fields: List[str] = [],
 ) -> T:
     pass
 
 
 @overload
 def get_object_or_404(
-    db_class: Type[T], id: UUID | str, db: Session, expunge: bool = False, lookup_column: str = "id"
+    db_class: Type[T],
+    id: UUID | str,
+    db: Session,
+    expunge: bool = False,
+    lookup_column: str = "id",
+    response_fields: List[str] = [],
 ) -> T:
     pass
 
@@ -36,20 +43,44 @@ def get_object_or_404(
     db: Session | AsyncSession,
     expunge: bool = False,
     lookup_column: str = "id",
+    response_fields: List[str] = [],
 ) -> T:
 
     async def _get_async_object() -> T:
-        query = select(db_class).filter(getattr(db_class, lookup_column) == id)
-        result = await db.execute(query)
-        obj = result.scalar_one_or_none()
-        if obj is None:
-            raise HTTPException(status_code=404, detail="The object does not exist.")  # type: ignore
+        if response_fields:
+            selected_columns = [
+                getattr(db_class, field) for field in response_fields if hasattr(db_class, field)
+            ]
+            query = select(*selected_columns).where(getattr(db_class, lookup_column) == id)
+            result = await db.execute(query)
+            row = result.first()
+
+            if row is None:
+                raise HTTPException(status_code=404, detail="The object does not exist.")
+            if hasattr(row, "_mapping"):
+                obj_dict = dict(row._mapping)
+            else:
+                obj_dict = {column.key: getattr(row, column.key) for column in selected_columns}
+        else:
+            query = select(db_class).where(getattr(db_class, lookup_column) == id)
+            result = await db.execute(query)
+            row = result.scalar_one_or_none()
+            if row is None:
+                raise HTTPException(status_code=404, detail="The object does not exist.")
+            obj_dict = row
         if expunge:
-            await db.expunge(obj)
-        return obj
+            await db.expunge(obj_dict)
+        return obj_dict
 
     def _get_sync_object() -> T:
-        obj = db.query(db_class).filter(getattr(db_class, lookup_column) == id).one_or_none()
+        if response_fields:
+            selected_columns = [
+                getattr(db_class, field) for field in response_fields if hasattr(db_class, field)
+            ]
+            query = db.query(*selected_columns).filter(getattr(db_class, lookup_column) == id)
+        else:
+            query = db.query(db_class).filter(getattr(db_class, lookup_column) == id)
+        obj = query.one_or_none()
         if obj is None:
             raise HTTPException(status_code=404, detail="The object does not exist.")  # type: ignore
         if expunge:

creyPY/fastapi/db/__init__.py

@@ -1,3 +1,8 @@
-from .async_session import *  # noqa
-from .helpers import *  # noqa
-from .session import *  # noqa
+try:
+    import sqlalchemy
+
+    from .async_session import *
+    from .helpers import *
+    from .session import *
+except ImportError:
+    print("SQLAlchemy not installed. Database functionality will be disabled.")

creyPY/fastapi/db/async_session.py

@@ -1,15 +1,14 @@
 from typing import AsyncGenerator
 
-from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 
-from .common import SQLALCHEMY_DATABASE_URL, name
+from .common import SQLALCHEMY_DATABASE_URL, name, ssl_mode
 
 async_engine = create_async_engine(
-    SQLALCHEMY_DATABASE_URL + name, pool_pre_ping=True, connect_args={"sslmode": "require"}
+    SQLALCHEMY_DATABASE_URL + name, pool_pre_ping=True, connect_args={"sslmode": ssl_mode}
 )
 
-AsyncSessionLocal = sessionmaker(
+AsyncSessionLocal = async_sessionmaker(
     bind=async_engine,
     class_=AsyncSession,
     expire_on_commit=False,

creyPY/fastapi/db/common.py

@@ -10,4 +10,6 @@ password = os.getenv("POSTGRES_PASSWORD", "root")
 port = os.getenv("POSTGRES_PORT", "5432")
 name = os.getenv("POSTGRES_DB", "fastapi")
 
+ssl_mode = os.getenv("SSL_MODE", "require")
+
 SQLALCHEMY_DATABASE_URL = f"postgresql+psycopg://{user}:{password}@{host}:{port}/"

creyPY/fastapi/db/session.py

@@ -4,10 +4,10 @@ from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy.orm.session import Session
 
-from .common import SQLALCHEMY_DATABASE_URL, name
+from .common import SQLALCHEMY_DATABASE_URL, name, ssl_mode
 
 engine = create_engine(
-    SQLALCHEMY_DATABASE_URL + name, pool_pre_ping=True, connect_args={"sslmode": "require"}
+    SQLALCHEMY_DATABASE_URL + name, pool_pre_ping=True, connect_args={"sslmode": ssl_mode}
 )
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 

creyPY/fastapi/models/__init__.py

@@ -1 +1,2 @@
 from .base import *  # noqa
+from .mixins import *  # noqa

creyPY/fastapi/models/base.py

@@ -1,15 +1,17 @@
 import uuid
 from datetime import datetime
 
-from sqlalchemy import Column, DateTime, String
+from sqlalchemy import Column, DateTime, PrimaryKeyConstraint, String
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.orm import as_declarative
 from sqlalchemy.sql import func
 
+from .mixins import AutoAnnotateMixin, AutoInitMixin
+
 
 @as_declarative()
-class Base:
+class Base(AutoAnnotateMixin, AutoInitMixin):
     __abstract__ = True
     # Primary key as uuid
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
@@ -21,6 +23,11 @@ class Base:
 
     # TODO: Add automated foreign key resolution
 
+    # Add name to primary key constraint to ensure alembic can pick it up later
+    @declared_attr
+    def __table_args__(cls):
+        return (PrimaryKeyConstraint("id", name=f"pk_{cls.__tablename__}"),)
+
     # Generate __tablename__ automatically
     @declared_attr
     def __tablename__(cls) -> str:

creyPY/fastapi/models/mixins.py

@@ -0,0 +1,36 @@
+from sqlalchemy import Column
+from sqlalchemy.orm import Mapped
+
+
+class AutoAnnotateMixin:
+    @classmethod
+    def __init_subclass__(cls) -> None:
+        super().__init_subclass__()
+        annotations = {}
+        for key, value in cls.__dict__.items():
+            if isinstance(value, Column):
+                annotations[key] = Mapped[value.type.python_type]
+        cls.__annotations__ = annotations
+
+
+class AutoInitMixin:
+    @classmethod
+    def __init_subclass__(cls) -> None:
+        super().__init_subclass__()
+        init_params = []
+        for key, value in cls.__dict__.items():
+            if isinstance(value, Column):
+                if not value.nullable and not value.default and not value.server_default:
+                    init_params.append((key, value.type.python_type))
+
+        def __init__(self, **kwargs):
+            super(cls, self).__init__()
+            for key, _ in init_params:
+                if key not in kwargs:
+                    raise TypeError(f"Missing required argument: {key}")
+                setattr(self, key, kwargs[key])
+            for key, value in kwargs.items():
+                if key not in init_params and hasattr(self.__class__, key):
+                    setattr(self, key, value)
+
+        cls.__init__ = __init__

creyPY/fastapi/pagination.py

@@ -1,27 +1,26 @@
+from contextlib import suppress
 from math import ceil
 from typing import Any, Generic, Optional, Self, Sequence, TypeVar, Union, overload
-from contextlib import suppress
-from pydantic import BaseModel
-from fastapi_pagination import Params
-from fastapi_pagination.bases import AbstractPage, AbstractParams
+
+from fastapi import Query
+from fastapi_pagination.api import apply_items_transformer, create_page
+from fastapi_pagination.bases import AbstractPage, AbstractParams, RawParams
+from fastapi_pagination.ext.sqlalchemy import create_paginate_query
 from fastapi_pagination.types import (
+    AdditionalData,
+    AsyncItemsTransformer,
     GreaterEqualOne,
     GreaterEqualZero,
-    AdditionalData,
-    SyncItemsTransformer,
-    AsyncItemsTransformer,
     ItemsTransformer,
+    SyncItemsTransformer,
 )
-from fastapi_pagination.api import create_page, apply_items_transformer
 from fastapi_pagination.utils import verify_params
-from fastapi_pagination.ext.sqlalchemy import create_paginate_query
-from fastapi_pagination.bases import AbstractParams, RawParams
+from pydantic import BaseModel
 from pydantic.json_schema import SkipJsonSchema
-from sqlalchemy.sql.selectable import Select
-from sqlalchemy.orm.session import Session
-from sqlalchemy import select, func
+from sqlalchemy import func, select
 from sqlalchemy.ext.asyncio import AsyncSession, async_scoped_session
-from fastapi import Query
+from sqlalchemy.orm.session import Session
+from sqlalchemy.sql.selectable import Select
 from sqlalchemy.util import await_only, greenlet_spawn
 
 T = TypeVar("T")
@@ -29,7 +28,7 @@ T = TypeVar("T")
 
 class PaginationParams(BaseModel, AbstractParams):
     page: int = Query(1, ge=1, description="Page number")
-    size: int = Query(50, ge=1, le=100, description="Page size")
+    size: int = Query(50, ge=1, description="Page size")
     pagination: bool = Query(True, description="Toggle pagination")
 
     def to_raw_params(self) -> RawParams:
@@ -62,7 +61,7 @@ class Page(AbstractPage[T], Generic[T]):
         total: Optional[int] = None,
         **kwargs: Any,
     ) -> Self:
-        if not isinstance(params, Params):
+        if not isinstance(params, PaginationParams):
             raise TypeError("Page should be used with Params")
 
         size = params.size or total or len(items)
@@ -170,9 +169,9 @@ def _paginate(
     total = connection.scalar(count_query)
 
     if params.pagination is False and total > 0:
-        params = Params(page=1, size=total)
+        params = PaginationParams(page=1, size=total)
     else:
-        params = Params(page=params.page, size=params.size)
+        params = PaginationParams(page=params.page, size=params.size)
 
     query = create_paginate_query(query, params)
     items = connection.execute(query).all()

creyPY/fastapi/schemas/__init__.py

@@ -1 +1,2 @@
 from .base import *  # noqa
+from .schema_optional import * #noqa

creyPY/fastapi/schemas/schema_optional.py

@@ -0,0 +1,19 @@
+from typing import Optional, Type, Union, get_args, get_origin, get_type_hints
+
+from pydantic import BaseModel, create_model
+
+
+def optional_fields(cls: Type[BaseModel]) -> Type[BaseModel]:
+    fields = {}
+    for name, hint in get_type_hints(cls).items():
+        if name.startswith("_"):
+            continue
+
+        if get_origin(hint) is not Union or type(None) not in get_args(hint):
+            hint = Optional[hint]
+
+        fields[name] = (hint, None)
+
+    new_model = create_model(cls.__name__, __base__=cls, **fields)
+
+    return new_model

creyPY/fastapi/testing_unit.py

@@ -3,7 +3,7 @@ import unittest
 from typing import Type
 
 from httpx import ASGITransport, AsyncClient, Response
-from sqlalchemy import create_engine
+from sqlalchemy import create_engine, text
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlalchemy_utils import create_database, database_exists, drop_database
 
@@ -20,20 +20,30 @@ class AbstractTestAPI(unittest.IsolatedAsyncioTestCase):
             transport=ASGITransport(app=app), base_url="http://testserver", follow_redirects=True
         )
         cls.default_headers = headers
-        print("setting up abstract")
 
     @classmethod
-    def setup_database(cls, sync_db_url: str, async_db_url: str, base: Type[Base]):
+    def setup_database(
+        cls,
+        sync_db_url: str,
+        async_db_url: str,
+        base: Type[Base],
+        btree_gist: bool = False,
+        ssl_mode: str = "require",
+    ):
         cls.engine_s = create_engine(
             sync_db_url,
             echo=False,
             pool_pre_ping=True,
-            connect_args={"sslmode": "require"},
+            connect_args={"sslmode": ssl_mode},
         )
         if database_exists(cls.engine_s.url):
             drop_database(cls.engine_s.url)
         create_database(cls.engine_s.url)
 
+        if btree_gist:
+            with cls.engine_s.begin() as conn:
+                conn.execute(text("CREATE EXTENSION IF NOT EXISTS btree_gist"))
+
         # Migrate
         base.metadata.create_all(cls.engine_s)
 
@@ -41,7 +51,7 @@ class AbstractTestAPI(unittest.IsolatedAsyncioTestCase):
             async_db_url,
             echo=False,
             pool_pre_ping=True,
-            connect_args={"sslmode": "require"},
+            connect_args={"sslmode": ssl_mode},
         )
 
     async def get(self, url: str, r_code: int = 200, parse_json=True) -> dict | bytes:
@@ -130,6 +140,7 @@ class AbstractTestAPI(unittest.IsolatedAsyncioTestCase):
         pagination: bool = True,
         id_field: str = "id",
         created_at_check: bool = True,
+        patch: dict | None = None,
     ):
         # GET LIST
         re = await self.get(url)
@@ -154,6 +165,14 @@ class AbstractTestAPI(unittest.IsolatedAsyncioTestCase):
         re = await self.get(f"{url}{obj_id}/")
         self.assertEqual(re[id_field], obj_id)
 
+        # PATCH
+        if patch:
+            for key, value in patch.items():
+                input_obj[key] = value
+            re = await self.patch(f"{url}{obj_id}/", obj=input_obj)
+            for key, value in patch.items():
+                self.assertEqual(re[key], value)
+
         # GET LIST
         re = await self.get(url)
         if pagination:

creyPY/helpers.py

@@ -1,5 +1,7 @@
 import secrets
 import string
+import csv
+from pathlib import Path
 
 
 def create_random_password(length: int = 12) -> str:
@@ -14,3 +16,11 @@ def create_random_password(length: int = 12) -> str:
     password += [secrets.choice(all_characters) for _ in range(length - 4)]
     secrets.SystemRandom().shuffle(password)
     return "".join(password)
+
+
+def data_to_csv(file: Path, data: list) -> None:
+
+    with file.open(mode="w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=data[0].keys(), delimiter=";")
+        writer.writeheader()
+        writer.writerows(data)

creyPY/services/__init__.py

@@ -1,2 +1,3 @@
 from .auth0 import *  # noqa
 from .stripe import *  # noqa
+from .aws import *  # noqa

creyPY/services/auth0/utils.py

@@ -101,7 +101,7 @@ def request_verification_mail(sub: str) -> None:
     return re.json()
 
 
-def create_user_invite(email: str) -> dict:
+def create_user_invite(email: str, company_id: str) -> dict:
     re = requests.post(
         f"https://{AUTH0_DOMAIN}/api/v2/users",
         headers={"Authorization": f"Bearer {get_management_token()}"},
@@ -111,6 +111,7 @@ def create_user_invite(email: str) -> dict:
             "password": create_random_password(),
             "verify_email": False,
             "app_metadata": {"invitedToMyApp": True},
+            "user_metadata": {"company_ids": [company_id]},
         },
         timeout=5,
     )
@@ -119,6 +120,16 @@ def create_user_invite(email: str) -> dict:
     return re.json()
 
 
+def delete_user_invite(user_id: str) -> None:
+    re = requests.delete(
+        f"https://{AUTH0_DOMAIN}/api/v2/users/{user_id}",
+        headers={"Authorization": f"Bearer {get_management_token()}"},
+        timeout=5,
+    )
+    if re.status_code != 204:
+        raise HTTPException(re.status_code, re.json())
+
+
 def password_change_mail(email: str) -> bool:
     re = requests.post(
         f"https://{AUTH0_DOMAIN}/dbconnections/change_password",
@@ -134,3 +145,21 @@ def password_change_mail(email: str) -> bool:
     if re.status_code != 200:
         raise HTTPException(re.status_code, re.json())
     return True
+
+
+def user_password_change_ticket(user_id: str) -> str:
+    re = requests.post(
+        f"https://{AUTH0_DOMAIN}/api/v2/tickets/password-change",
+        headers={"Authorization": f"Bearer {get_management_token()}"},
+        json={
+            "user_id": user_id,
+            "client_id": AUTH0_CLIENT_ID,
+            "ttl_sec": 0,
+            "mark_email_as_verified": False,
+            "includeEmailInRedirect": False,
+        },
+        timeout=5,
+    )
+    if re.status_code != 201:
+        raise HTTPException(re.status_code, re.json())
+    return re.json()["ticket"]

creyPY/services/aws/__init__.py

@@ -0,0 +1 @@
+from .email import *  # noqa

creyPY/services/aws/email.py

@@ -0,0 +1,32 @@
+import os
+
+import boto3
+from botocore.exceptions import ClientError
+
+AWS_CLIENT_ID = os.getenv("AWS_CLIENT_ID")
+AWS_CLIENT_SECRET = os.getenv("AWS_CLIENT_SECRET")
+AWS_SENDER_EMAIL = os.getenv("AWS_SENDER_EMAIL")
+AWS_REGION = os.getenv("AWS_REGION", "eu-central-1")
+
+
+async def send_email_ses(recipient_email, subject, html_body):
+    ses_client = boto3.client(
+        "ses",
+        aws_access_key_id=AWS_CLIENT_ID,
+        aws_secret_access_key=AWS_CLIENT_SECRET,
+        region_name=AWS_REGION,
+    )
+    email_message = {
+        "Source": AWS_SENDER_EMAIL,
+        "Destination": {"ToAddresses": [recipient_email]},
+        "Message": {
+            "Subject": {"Data": subject, "Charset": "UTF-8"},
+            "Body": {"Html": {"Data": html_body, "Charset": "UTF-8"}},
+        },
+    }
+
+    try:
+        response = ses_client.send_email(**email_message)
+        return response["MessageId"]
+    except ClientError as e:
+        return None

requirements.stripe.txt

@@ -1 +1 @@
-stripe==10.12.0 # Stripe
+stripe==12.3.0 # Stripe

test.py

@@ -7,9 +7,7 @@ from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 
 from creyPY.fastapi.app import generate_unique_id
-from creyPY.fastapi.crud import (
-    get_object_or_404,
-)
+from creyPY.fastapi.crud import get_object_or_404
 from creyPY.fastapi.models.base import Base
 
 
@@ -65,7 +63,7 @@ class TestMyFunction(unittest.TestCase):
     def test_get_object_or_404_existing_object(self):
         # Arrange
         obj_id = UUID("123e4567-e89b-12d3-a456-426614174000")
-        obj = MockDBClass(obj_id)
+        obj = MockDBClass(id=obj_id)
         self.db.add(obj)
         self.db.commit()