zrb 1.0.0a1__py3-none-any.whl → 1.0.0a3__py3-none-any.whl

zrb/builtin/project/add/fastapp_template/common/usecase.py

@@ -0,0 +1,232 @@
+from enum import Enum
+from functools import partial, wraps
+from typing import Any, Callable, Sequence
+
+import httpx
+from fastapi import APIRouter, params
+from fastapi.routing import APIRoute
+from fastapi.types import IncEx
+from fastapi.utils import generate_unique_id
+from starlette.responses import JSONResponse, Response
+
+
+class RouteParam:
+    def __init__(
+        self,
+        path: str,
+        response_model: Any,
+        status_code: int | None = None,
+        tags: list[str | Enum] | None = None,
+        dependencies: Sequence[params.Depends] | None = None,
+        summary: str | None = None,
+        description: str = "",
+        response_description: str = "",
+        responses: dict[int | str, dict[str, Any]] | None = None,
+        deprecated: bool | None = None,
+        methods: set[str] | list[str] | None = None,
+        operation_id: str | None = None,
+        response_model_include: IncEx | None = None,
+        response_model_exclude: IncEx | None = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: type[Response] = Response,
+        name: str | None = None,
+        openapi_extra: dict[str, Any] | None = None,
+        generate_unique_id_function: Callable[[APIRoute], str] | None = None,
+        func: Callable | None = None,
+    ):
+        self.path = path
+        self.response_model = response_model
+        self.status_code = status_code
+        self.tags = tags
+        self.dependencies = dependencies
+        self.summary = summary
+        self.description = description
+        self.response_description = response_description
+        self.responses = responses
+        self.deprecated = deprecated
+        self.methods = methods
+        self.operation_id = operation_id
+        self.response_model_include = response_model_include
+        self.response_model_exclude = response_model_exclude
+        self.response_model_by_alias = response_model_by_alias
+        self.response_model_exclude_unset = response_model_exclude_unset
+        self.response_model_exclude_defaults = response_model_exclude_defaults
+        self.response_model_exclude_none = response_model_exclude_none
+        self.include_in_schema = include_in_schema
+        self.response_class = response_class
+        self.name = name
+        self.openapi_extra = openapi_extra
+        self.generate_unique_id_function = generate_unique_id_function
+        self.func = func
+
+
+class BaseUsecase:
+    _route_params: dict[str, RouteParam] = {}
+
+    @classmethod
+    def route(
+        cls,
+        path: str,
+        *,
+        response_model: Any = None,
+        status_code: int | None = None,
+        tags: list[str | Enum] | None = None,
+        dependencies: Sequence[params.Depends] | None = None,
+        summary: str | None = None,
+        description: str = None,
+        response_description: str = "Successful Response",
+        responses: dict[int | str, dict[str, Any]] | None = None,
+        deprecated: bool | None = None,
+        methods: set[str] | list[str] | None = None,
+        operation_id: str | None = None,
+        response_model_include: IncEx | None = None,
+        response_model_exclude: IncEx | None = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
+        response_class: type[Response] = JSONResponse,
+        name: str | None = None,
+        openapi_extra: dict[str, Any] | None = None,
+        generate_unique_id_function: Callable[[APIRoute], str] = generate_unique_id,
+    ):
+        """
+        Decorator to register a method with its HTTP details.
+        """
+
+        def decorator(func: Callable):
+            cls._route_params[func.__name__] = RouteParam(
+                path=path,
+                response_model=response_model,
+                status_code=status_code,
+                tags=tags,
+                dependencies=dependencies,
+                summary=summary,
+                description=description,
+                response_description=response_description,
+                responses=responses,
+                deprecated=deprecated,
+                methods=methods,
+                operation_id=operation_id,
+                response_model_include=response_model_include,
+                response_model_exclude=response_model_exclude,
+                response_model_by_alias=response_model_by_alias,
+                response_model_exclude_unset=response_model_exclude_unset,
+                response_model_exclude_defaults=response_model_exclude_defaults,
+                response_model_exclude_none=response_model_exclude_none,
+                include_in_schema=include_in_schema,
+                response_class=response_class,
+                name=name,
+                openapi_extra=openapi_extra,
+                generate_unique_id_function=generate_unique_id_function,
+                func=func,
+            )
+
+            @wraps(func)
+            async def wrapped(*args, **kwargs):
+                return await func(*args, **kwargs)
+
+            return wrapped
+
+        return decorator
+
+    def as_direct_client(self):
+        """
+        Dynamically create a direct client class.
+        """
+        _methods = self._route_params
+        DirectClient = create_client_class("DirectClient")
+        for name, details in _methods.items():
+            func = details.func
+            client_method = create_direct_client_method(func, self)
+            setattr(DirectClient, name, client_method.__get__(DirectClient))
+        return DirectClient
+
+    def as_api_client(self, base_url: str):
+        """
+        Dynamically create an API client class.
+        """
+        _methods = self._route_params
+        APIClient = create_client_class("APIClient")
+        # Dynamically generate methods
+        for name, param in _methods.items():
+            client_method = create_api_client_method(param, base_url)
+            setattr(APIClient, name, client_method.__get__(APIClient))
+        return APIClient
+
+    def serve_route(self, app: APIRouter):
+        """
+        Dynamically add routes to FastAPI.
+        """
+        for _, route_param in self._route_params.items():
+            bound_func = partial(route_param.func, self)
+            bound_func.__name__ = route_param.func.__name__
+            bound_func.__doc__ = route_param.func.__doc__
+            app.add_api_route(
+                path=route_param.path,
+                endpoint=bound_func,
+                response_model=route_param.response_model,
+                status_code=route_param.status_code,
+                tags=route_param.tags,
+                dependencies=route_param.dependencies,
+                summary=route_param.summary,
+                description=route_param.description,
+                response_description=route_param.response_description,
+                responses=route_param.responses,
+                deprecated=route_param.deprecated,
+                methods=route_param.methods,
+                operation_id=route_param.operation_id,
+                response_model_include=route_param.response_model_include,
+                response_model_exclude=route_param.response_model_exclude,
+                response_model_by_alias=route_param.response_model_by_alias,
+                response_model_exclude_unset=route_param.response_model_exclude_unset,
+                response_model_exclude_defaults=route_param.response_model_exclude_defaults,
+                response_model_exclude_none=route_param.response_model_exclude_none,
+                include_in_schema=route_param.include_in_schema,
+                response_class=route_param.response_class,
+                name=route_param.name,
+                openapi_extra=route_param.openapi_extra,
+                generate_unique_id_function=route_param.generate_unique_id_function,
+            )
+
+
+def create_client_class(name):
+    class Client:
+        pass
+
+    Client.__name__ = name
+    return Client
+
+
+def create_direct_client_method(func: Callable, usecase: BaseUsecase):
+    async def client_method(self, *args, **kwargs):
+        return await func(usecase, *args, **kwargs)
+
+    return client_method
+
+
+def create_api_client_method(param: RouteParam, base_url: str):
+    _url = param.path
+    _methods = [method.lower() for method in param.methods]
+
+    async def client_method(self, *args, **kwargs):
+        async with httpx.AsyncClient() as client:
+            url = base_url + _url.format(**kwargs)
+            if "post" in _methods:
+                response = await client.post(url, json=kwargs)
+            elif "put" in _methods:
+                response = await client.put(url, json=kwargs)
+            elif "delete" in _methods:
+                response = await client.delete(url, json=kwargs)
+            else:
+                response = await client.get(url, params=kwargs)
+            # Add more HTTP methods as needed
+            response.raise_for_status()
+            return response.json()
+
+    return client_method

zrb/builtin/project/add/fastapp_template/config.py

@@ -0,0 +1,29 @@
+import os
+
+APP_PATH = os.path.dirname(__file__)
+
+APP_MODE = os.getenv("APP_NAME_MODE", "monolith")
+APP_MODULES = [
+    module.strip()
+    for module in os.getenv("APP_NAME_MODULES", "").split(",")
+    if module.strip() != ""
+]
+APP_PORT = int(os.getenv("APP_NAME_PORT", "3000"))
+APP_COMMUNICATION = os.getenv(
+    "APP_NAME_COMMUNICATION", "direct" if APP_MODE == "monolith" else "api"
+)
+APP_REPOSITORY_TYPE = os.getenv("APP_REPOSITORY_TYPE", "db")
+APP_DB_URL = os.getenv(
+    "APP_DB_URL",
+    (
+        f"sqlite:///{APP_PATH}/monolith.db"
+        if APP_MODE == "monolith" or len(APP_MODULES) == 0
+        else f"sqlite:///{APP_PATH}/{APP_MODULES[0]}_microservices.db"
+    ),
+)
+APP_AUTH_SUPER_USER = os.getenv("APP_NAME_AUTH_SUPER_USER", "admin")
+APP_AUTH_SUPER_USER_PASSWORD = os.getenv(
+    "APP_NAME_AUTH_SUPER_USER_PASSWORD", "secure-password"
+)
+
+APP_AUTH_BASE_URL = os.getenv("APP_NAME_AUTH_BASE_URL", "http://localhost:3001")

zrb/builtin/project/add/fastapp_template/main.py

@@ -0,0 +1,7 @@
+from fastapp_template.common.app import app
+from fastapp_template.module.auth import route as auth_route
+from fastapp_template.module.gateway import route as gateway_route
+
+assert app
+assert gateway_route
+assert auth_route

zrb/builtin/project/add/fastapp_template/migrate.py

@@ -0,0 +1,3 @@
+from fastapp_template.module.auth import migration as auth_migration
+
+assert auth_migration

zrb/builtin/project/add/fastapp_template/module/auth/alembic.ini

@@ -0,0 +1,117 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+# Use forward slashes (/) also on windows to provide an os agnostic path
+script_location = migration
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = ../..
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python>=3.9 or backports.zoneinfo library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to migration/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:migration/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+# version_path_separator = newline
+version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = %(here)s/.venv/bin/ruff
+# ruff.options = --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARNING
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

zrb/builtin/project/add/fastapp_template/module/auth/client/api_client.py

@@ -0,0 +1,7 @@
+from fastapp_template.config import APP_AUTH_BASE_URL
+from fastapp_template.module.auth.client.base_client import BaseClient
+from fastapp_template.module.auth.service.user.usecase import user_usecase
+
+
+class APIClient(user_usecase.as_api_client(base_url=APP_AUTH_BASE_URL), BaseClient):
+    pass

zrb/builtin/project/add/fastapp_template/module/auth/client/base_client.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+
+from fastapp_template.schema.user import UserCreate, UserResponse, UserUpdate
+
+
+class BaseClient(ABC):
+    @abstractmethod
+    async def get_user_by_id(self, user_id: str) -> UserResponse:
+        pass
+
+    @abstractmethod
+    async def get_all_users(self) -> list[UserResponse]:
+        pass
+
+    @abstractmethod
+    async def create_user(
+        self, data: UserCreate | list[UserCreate]
+    ) -> UserResponse | list[UserResponse]:
+        pass
+
+    @abstractmethod
+    async def update_user(self, user_id: str, data: UserUpdate) -> UserResponse:
+        pass
+
+    @abstractmethod
+    async def delete_user(self, user_id: str) -> UserResponse:
+        pass

zrb/builtin/project/add/fastapp_template/module/auth/client/direct_client.py

@@ -0,0 +1,6 @@
+from fastapp_template.module.auth.client.base_client import BaseClient
+from fastapp_template.module.auth.service.user.usecase import user_usecase
+
+
+class DirectClient(user_usecase.as_direct_client(), BaseClient):
+    pass

zrb/builtin/project/add/fastapp_template/module/auth/client/factory.py

@@ -0,0 +1,9 @@
+from fastapp_template.config import APP_COMMUNICATION
+from fastapp_template.module.auth.client.api_client import APIClient
+from fastapp_template.module.auth.client.base_client import BaseClient
+from fastapp_template.module.auth.client.direct_client import DirectClient
+
+if APP_COMMUNICATION == "direct":
+    client: BaseClient = DirectClient()
+elif APP_COMMUNICATION == "api":
+    client: BaseClient = APIClient()

zrb/builtin/project/add/fastapp_template/module/auth/migration/README

@@ -0,0 +1 @@
+Generic single-database configuration.

zrb/builtin/project/add/fastapp_template/module/auth/migration/env.py

@@ -0,0 +1,108 @@
+from logging.config import fileConfig
+
+from alembic import context
+from fastapp_template.config import APP_DB_URL
+from fastapp_template.module.auth.migration_metadata import metadata
+from sqlalchemy import engine_from_config, pool
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# 🔥 FastApp Modification
+MIGRATION_TABLE = "_migration_auth"
+# 🔥 FastApp Modification
+config.set_section_option(config.config_ini_section, "sqlalchemy.url", APP_DB_URL)
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+# 🔥 FastApp Modification
+def include_object(object, name, type_, reflected, compare_to):
+    """
+    Filter which objects Alembic should include in migrations.
+    Args:
+        object: The SQLAlchemy object (table, column, etc.)
+        name: The name of the object
+        type_: The type of the object ("table", "column", etc.)
+        reflected: True if the object is reflected from the database
+        compare_to: The object being compared against
+    Returns:
+        bool: True to include, False to exclude
+    """
+    # Exclude tables not in metadata
+    if type_ == "table" and name not in target_metadata.tables:
+        return False  # Skip this table
+    return True
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        imports=["import sqlmodel"],  # 🔥 FastApp Modification
+        version_table=MIGRATION_TABLE,  # 🔥 FastApp Modification
+        include_object=include_object,  # 🔥 FastApp Modification
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            imports=["import sqlmodel"],  # 🔥 FastApp Modification
+            version_table=MIGRATION_TABLE,  # 🔥 FastApp Modification
+            include_object=include_object,  # 🔥 FastApp Modification
+        )
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

zrb/builtin/project/add/fastapp_template/module/auth/migration/script.py.mako

@@ -0,0 +1,26 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

zrb/builtin/project/add/fastapp_template/module/auth/migration/versions/3093c7336477_add_user_table.py

@@ -0,0 +1,37 @@
+"""Add user table
+
+Revision ID: 3093c7336477
+Revises:
+Create Date: 2024-11-20 05:57:01.684118
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "3093c7336477"
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "user",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("username", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("password", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table("user")
+    # ### end Alembic commands ###

zrb/builtin/project/add/fastapp_template/module/auth/migration_metadata.py

@@ -0,0 +1,6 @@
+from fastapp_template.schema.user import User
+from sqlalchemy import MetaData
+
+metadata = MetaData()
+User.metadata = metadata
+User.__table__.tometadata(metadata)

zrb/builtin/project/add/fastapp_template/module/auth/route.py

@@ -0,0 +1,22 @@
+from fastapp_template.common.app import app
+from fastapp_template.common.schema import BasicResponse
+from fastapp_template.config import APP_MODE, APP_MODULES
+from fastapp_template.module.auth.service.user.usecase import user_usecase
+
+if APP_MODE == "microservices" and "auth" in APP_MODULES:
+
+    if APP_MODE == "microservices" and (
+        len(APP_MODULES) > 0 and APP_MODULES[0] == "auth"
+    ):
+
+        @app.api_route("/health", methods=["GET", "HEAD"], response_model=BasicResponse)
+        async def health():
+            return BasicResponse(message="ok")
+
+        @app.api_route(
+            "/readiness", methods=["GET", "HEAD"], response_model=BasicResponse
+        )
+        async def readiness():
+            return BasicResponse(message="ok")
+
+    user_usecase.serve_route(app)