Merge pull request #6 from bali-framework/feature/v0.0.2

v0.0.2

Author: JoshYuJump

.gitignore

@@ -160,3 +160,6 @@ cython_debug/
 .idea/
 
 .vscode
+
+# examples' testing database
+database.db

balify/__init__.py

@@ -1,24 +1,48 @@
 import logging
+import humps  # noqa
+import uuid
 
+from collections.abc import AsyncGenerator
 from datetime import date, datetime  # Entity field type
 
-import humps  # noqa
-from fastapi import FastAPI
-from fastapi_pagination import add_pagination
+from importlib.metadata import version as _version, PackageNotFoundError
+from fastapi import FastAPI, Depends, Response, status
+from fastapi_pagination import add_pagination, Params
+from fastapi_pagination.ext.sqlalchemy import paginate as sa_paginate
+from fastapi_users import FastAPIUsers
+from fastapi_users.db import SQLAlchemyBaseUserTableUUID, SQLAlchemyUserDatabase
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlmodel import Field, SQLModel, Session, create_engine, select
 
+from .decorators import action
 from .resource import RouterGenerator
-from .utils import pluralize
+from .utils import pluralize, make_optional_model
 
-from .decorators import action
 
-from sqlmodel import Field, SQLModel, Session, create_engine, select
+try:
+    __version__ = _version("balify")
+except PackageNotFoundError:
+    # fallback for local editable installs or when package metadata not available
+    __version__ = "0.0.0"
+
 
+# Constats flags
+auth = "auth"
 
-sqlite_file_name = "database.db"
-sqlite_url = f"sqlite:///{sqlite_file_name}"
 
+# Read database config from `.env` or envirenment
+class Settings(BaseSettings):  # type: ignore
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
 
-engine = create_engine(sqlite_url, echo=True)
+    database_url: str = "sqlite:///database.db"
+
+
+settings = Settings()
+
+print("--> Read database url: %s" % settings.database_url)
+engine = create_engine(settings.database_url, echo=True)
 
 
 def create_db_and_tables():
@@ -33,14 +57,23 @@ class _OMeta(type):
     TODO: Compare `Metaclass` and `__init_subclass__`, then choose one in for `_OMeta`
     """
 
+    # TODO: FastAPI-Users liftspan in `auth.py`, just like `add_pagination`
     _app = FastAPI()
 
     def __new__(cls, *args, **kwargs):
         meta = super().__new__(cls, *args, **kwargs)
 
-        meta._app = FastAPI()
+        print("--> _OMeta _app: %s" % id(cls._app))
+
         meta._app = add_pagination(cls._app)
 
+        print("--> add_pagination meta._app: %s" % id(meta._app))
+
+        # Register FastAPI-Users routers
+        from .auth import add_users
+
+        meta._app = add_users(meta._app)
+
         return meta
 
     @property
@@ -75,27 +108,31 @@ class O(metaclass=_OMeta):
     """
 
     schema = None  # the schema is SQLModel instance
+    dependencies = []  # router depends
 
     @classmethod
     def serve(cls, *entities) -> None:
-
-        from fastapi import APIRouter
-
-        router = APIRouter()
-
-        @router.get("/")
-        def hello():
-            return {"Hello": "World", "Powered by": "balify router"}
-
-        cls._app.include_router(router, prefix="/router1")
-
+        print("--> serve App(%s)" % id(cls._app))
         for entity in entities:
             print("--> Serve entity `%s` in App(%s)" % (str(entity), id(cls._app)))
-            cls._app.include_router(entity.as_router(), prefix="/users")
+            cls._app.include_router(
+                entity.as_router(), prefix=f"/{pluralize(entity.__name__.lower())}"
+            )
 
         # Generate all SQLModel schemas to database
         create_db_and_tables()
 
+    @classmethod
+    def depends(cls, *args, **kwargs):
+        """Depends build-in depends"""
+
+        from .auth import current_active_user
+
+        if auth in args:
+            cls.dependencies = [Depends(current_active_user)]
+
+        return cls
+
     @action()
     def list(self):
         """Generic `list` method
@@ -107,9 +144,8 @@ def list(self):
         """
         with Session(engine) as session:
             statement = select(self.schema)
-            targets = session.exec(statement).all()
-            print("--> Generic list method get targets: %s" % targets)
-            return targets
+            # targets = session.exec(statement).all()
+            return sa_paginate(session, statement, Params(page=1, size=10))
 
     @action()
     def get(self, pk=None):
@@ -137,7 +173,10 @@ def create(self, schema_in):
             # session.add(schema_in)
 
             # Option 2: Create New schema instance
-            target = self.schema(**schema_in.model_dump())  # type: ignore
+            # Why use model_validate?
+            # Because SQLModel not validate data when `table=True`
+            # ref: https://github.com/fastapi/sqlmodel/issues/453
+            target = self.schema.model_validate(schema_in.model_dump())  # type: ignore
             session.add(target)
             session.commit()
             session.refresh(target)
@@ -154,7 +193,9 @@ def update(self, schema_in=None, pk=None):
             statement = select(self.schema).where(self.schema.id == pk)  # type: ignore
             target = session.exec(statement).first()
 
-            for k, v in schema_in.model_dump().items():  # type: ignore
+            optional_model = make_optional_model(self.schema)  # type: ignore
+            optional_schema = optional_model.model_validate(schema_in.model_dump())  # type: ignore
+            for k, v in optional_schema.model_dump().items():  # type: ignore
                 if v is not None:
                     setattr(target, k, v)
 
@@ -169,10 +210,14 @@ def delete(self, pk=None):
         with Session(engine) as session:
             statement = select(self.schema).where(self.schema.id == pk)  # type: ignore
             target = session.exec(statement).first()
-            session.delete(target)
-            session.commit()
-
-        return {"result": True}
+            if target:
+                session.delete(target)
+                session.commit()
+
+        # In previou `bali-core`, it return {"result": True} to compatible with gRPC
+        # It can be simpler with 204 status response
+        # return {"result": True}
+        return Response(status_code=status.HTTP_204_NO_CONTENT)
 
 
 # I found that `O, o` in `from balify import O, o` look like an cute emontion.

balify/auth.py

@@ -0,0 +1,172 @@
+"""Auth with FastAPI-Users
+
+FastAPI-Users' db, schemas, user managers all in the file.
+"""
+
+import uuid
+from typing import Optional
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Depends, Request
+from fastapi_users import schemas, BaseUserManager, FastAPIUsers, UUIDIDMixin, models
+from fastapi_users.authentication import (
+    AuthenticationBackend,
+    BearerTransport,
+    JWTStrategy,
+)
+from fastapi_users.db import SQLAlchemyBaseUserTableUUID, SQLAlchemyUserDatabase
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase
+
+from . import settings
+
+
+# app
+
+
+# db
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class User(SQLAlchemyBaseUserTableUUID, Base):
+    pass
+
+
+database_schema_async_maps = [
+    ("sqlite://", "sqlite+aiosqlite://"),
+    ("mysql+pymysql://", "mysql+aiomysql://"),
+    ("postgres://", "postgresql+asyncpg://"),
+]
+uri = settings.database_url
+for sync_schema, async_schema in database_schema_async_maps:
+    uri = uri.replace(sync_schema, async_schema)
+
+print("--> FastAPI-Users connect to <%s>" % uri)
+engine = create_async_engine(uri, echo=True)
+async_session_maker = async_sessionmaker(engine, expire_on_commit=False)
+
+
+async def create_db_and_tables():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
+    async with async_session_maker() as session:
+        yield session
+
+
+async def get_user_db(session: AsyncSession = Depends(get_async_session)):
+    yield SQLAlchemyUserDatabase(session, User)
+
+
+# Schemas
+
+
+class UserRead(schemas.BaseUser[uuid.UUID]):
+    pass
+
+
+class UserCreate(schemas.BaseUserCreate):
+    pass
+
+
+class UserUpdate(schemas.BaseUserUpdate):
+    pass
+
+
+# User Manager
+
+SECRET = "SECRET"
+
+
+class UserManager(UUIDIDMixin, BaseUserManager[User, uuid.UUID]):
+    reset_password_token_secret = SECRET
+    verification_token_secret = SECRET
+
+    async def on_after_register(self, user: User, request: Optional[Request] = None):
+        print(f"User {user.id} has registered.")
+
+    async def on_after_forgot_password(
+        self, user: User, token: str, request: Optional[Request] = None
+    ):
+        print(f"User {user.id} has forgot their password. Reset token: {token}")
+
+    async def on_after_request_verify(
+        self, user: User, token: str, request: Optional[Request] = None
+    ):
+        print(f"Verification requested for user {user.id}. Verification token: {token}")
+
+
+async def get_user_manager(user_db: SQLAlchemyUserDatabase = Depends(get_user_db)):
+    yield UserManager(user_db)
+
+
+bearer_transport = BearerTransport(tokenUrl="auth/jwt/login")
+
+
+def get_jwt_strategy() -> JWTStrategy[models.UP, models.ID]:  # type: ignore
+    return JWTStrategy(secret=SECRET, lifetime_seconds=3600)
+
+
+auth_backend = AuthenticationBackend(
+    name="jwt",
+    transport=bearer_transport,
+    get_strategy=get_jwt_strategy,
+)
+
+fastapi_users = FastAPIUsers[User, uuid.UUID](get_user_manager, [auth_backend])  # type: ignore
+
+current_active_user = fastapi_users.current_user(active=True)
+
+
+# Register user routers
+def add_users(app):
+
+    router = app.router
+    _original_lifespan_context = router.lifespan_context
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        # Not needed if you setup a migration system like Alembic
+        await create_db_and_tables()
+
+        async with _original_lifespan_context(app) as maybe_state:
+            yield maybe_state
+
+    router.lifespan_context = lifespan
+
+    app.include_router(
+        fastapi_users.get_auth_router(auth_backend), prefix="/auth/jwt", tags=["auth"]  # type: ignore
+    )
+    app.include_router(
+        fastapi_users.get_register_router(UserRead, UserCreate),
+        prefix="/auth",
+        tags=["auth"],
+    )
+    app.include_router(
+        fastapi_users.get_reset_password_router(),
+        prefix="/auth",
+        tags=["auth"],
+    )
+    app.include_router(
+        fastapi_users.get_verify_router(UserRead),
+        prefix="/auth",
+        tags=["auth"],
+    )
+    app.include_router(
+        fastapi_users.get_users_router(UserRead, UserUpdate),
+        prefix="/users",
+        tags=["users"],
+    )
+
+    @app.get("/authenticated-route")
+    async def authenticated_route(user: User = Depends(current_active_user)):
+        return {"message": f"Hello {user.email}!"}
+
+    return app

balify/cli.py

@@ -1,7 +1,6 @@
 import os
 import sys
 
-import logging
 import importlib.util
 
 
@@ -41,9 +40,22 @@ def _load_app_from_main(path: Path):
     raise RuntimeError("main.py found but no 'app' variable inside")
 
 
-@app.callback()
-def callback():
+@app.callback(invoke_without_command=True)
+def callback(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        False, "--version", "-v", help="Show version and exit"
+    ),
+):
     """Start Balify App"""
+    if version:
+        from . import __version__
+
+        typer.echo(__version__)
+        raise typer.Exit()
+    # If invoked without subcommand, keep going (Typer will call subcommands)
+    if ctx.invoked_subcommand is None:
+        return
 
 
 @app.command()