zrb 1.0.0a21__py3-none-any.whl → 1.0.0b5__py3-none-any.whl

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/util/parser.py

@@ -0,0 +1,105 @@
+import re
+from typing import Callable
+
+from sqlalchemy import asc, desc
+from sqlalchemy.sql import ClauseElement, ColumnElement
+from sqlmodel import SQLModel
+
+
+def create_default_sort_param_parser() -> (
+    Callable[[SQLModel, str], list[ColumnElement]]
+):
+    def parse_sort_param(model: SQLModel, query: str) -> list[ColumnElement]:
+        """
+        Parse the sort parameter and return a list of SQLAlchemy ColumnElement objects.
+
+        Args:
+            model (Type[SQLModel]): The SQLModel class to be queried.
+            query (str): A comma-separated string of fields to sort by.
+                        Prefix a field with '-' for descending order.
+
+        Returns:
+            list[ColumnElement]: A list of SQLAlchemy ColumnElement objects representing the sort order.
+
+        Example:
+            parse_sort_param(UserModel, "name,-age")
+            # Returns [asc(UserModel.name), desc(UserModel.age)]
+        """
+        sorts: list[ColumnElement] = []
+        sort_parts = query.split(",")
+        for part in sort_parts:
+            if part.startswith("-"):
+                key = part[1:]
+                order = desc
+            else:
+                key = part
+                order = asc
+            if hasattr(model, key):
+                sorts.append(order(getattr(model, key)))
+        return sorts
+
+    return parse_sort_param
+
+
+def create_default_filter_param_parser() -> (
+    Callable[[SQLModel, str], list[ClauseElement]]
+):
+    def parse_filter_param(model: SQLModel, query: str) -> list[ClauseElement]:
+        """
+        Parse the filter parameter and return a list of SQLAlchemy ClauseElement objects.
+
+        Args:
+            model (Type[SQLModel]): The SQLModel class to be queried.
+            query (str): A comma-separated string of filters.
+                        Each filter should be in the format "field:operator:value".
+                        Use '\,' to escape commas within values.
+
+        Returns:
+            list[ClauseElement]: A list of SQLAlchemy ClauseElement objects representing the filters.
+
+        Supported operators:
+            eq: Equal to
+            ne: Not equal to
+            gt: Greater than
+            gte: Greater than or equal to
+            lt: Less than
+            lte: Less than or equal to
+            like: SQL LIKE (use % for wildcards)
+            in: In a list of values (semicolon-separated)
+
+        Example:
+            parse_filter_param(UserModel, "age:gte:18,name:like:John%,role:in:admin;user,address:eq:123\, Main St.")
+            # Returns [UserModel.age >= 18, UserModel.name.like("John%"), UserModel.role.in_(["admin", "user"]), UserModel.address == "123, Main St."]
+        """
+        filters: list[ClauseElement] = []
+        filter_parts = split_by_comma(query)
+        for part in filter_parts:
+            match = re.match(r"(.+):(.+):(.+)", part)
+            if match:
+                key, op, value = match.groups()
+                value = value.replace(r"\,", ",")  # Unescape commas in the value
+                if hasattr(model, key):
+                    column = getattr(model, key)
+                    if op == "eq":
+                        filters.append(column == value)
+                    elif op == "ne":
+                        filters.append(column != value)
+                    elif op == "gt":
+                        filters.append(column > value)
+                    elif op == "gte":
+                        filters.append(column >= value)
+                    elif op == "lt":
+                        filters.append(column < value)
+                    elif op == "lte":
+                        filters.append(column <= value)
+                    elif op == "like":
+                        filters.append(column.like(value))
+                    elif op == "in":
+                        filters.append(column.in_(value.split(";")))
+        return filters
+
+    return parse_filter_param
+
+
+def split_by_comma(s: str, delimiter: str = ",") -> list[str]:
+    return re.split(r"(?<!\\)" + re.escape(delimiter), s)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/util/user_agent.py

@@ -0,0 +1,58 @@
+import re
+
+
+def get_os_from_user_agent(user_agent: str) -> str:
+    os_patterns = [
+        (r"Windows NT (\d+\.\d+)", "Windows"),
+        (r"Mac OS X (\d+[_\.]\d+)", "MacOS"),
+        (r"Android (\d+[\.\d]*)", "Android"),
+        (r"iPhone OS (\d+[_\.]\d+)", "iOS"),
+        (r"iPad.*OS (\d+[_\.]\d+)", "iPadOS"),
+        (r"Linux", "Linux"),
+    ]
+    os = "Unknown OS"
+    # Match OS
+    for pattern, name in os_patterns:
+        match = re.search(pattern, user_agent)
+        if match:
+            os = (
+                f"{name} {match.group(1).replace('_', '.')}" if match.groups() else name
+            )
+            break
+    return os
+
+
+def get_browser_from_user_agent(user_agent: str) -> str:
+    browser_patterns = [
+        (r"Chrome/([\d\.]+)", "Chrome"),
+        (r"Firefox/([\d\.]+)", "Firefox"),
+        (r"Edg/([\d\.]+)", "Edge"),
+        (r"Safari/([\d\.]+)", "Safari"),
+    ]
+    browser = "Unknown Browser"
+    # Match Browser
+    for pattern, name in browser_patterns:
+        match = re.search(pattern, user_agent)
+        if match:
+            browser = f"{name} {match.group(1)}"
+            break
+    return browser
+
+
+def get_device_from_user_agent(user_agent: str):
+    device_patterns = [
+        (r"iPhone", "iPhone"),
+        (r"iPad", "iPad"),
+        (r"Android.*Mobile", "Android Phone"),
+        (r"Android", "Android Tablet"),
+        (r"Macintosh", "Mac"),
+        (r"Windows NT", "Windows PC"),
+        (r"Linux", "Linux Device"),
+    ]
+    device = "Unknown Device"
+    # Match Device
+    for pattern, name in device_patterns:
+        if re.search(pattern, user_agent):
+            device = name
+            break
+    return device

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/util/view.py

@@ -0,0 +1,37 @@
+import os
+from typing import Any
+
+from fastapi.responses import HTMLResponse
+from jinja2 import Environment, FileSystemLoader
+
+
+def render_str(template_path: str, **data: Any) -> str:
+    """
+    Renders a Jinja2 template with the given data.
+
+    :param template_path: The absolute or relative file path of the template.
+    :param data: A dictionary of data to pass to the template (default is None).
+    :return: Rendered template as a string.
+    """
+    if data is None:
+        data = {}
+    # Get the directory and file name
+    directory, template_name = os.path.split(template_path)
+    # Set up Jinja2 environment with the specific directory
+    env = Environment(loader=FileSystemLoader(directory))
+    # Render the template
+    template = env.get_template(template_name)
+    return template.render(data)
+
+
+def render_page(
+    template_path: str,
+    status_code: int = 200,
+    headers: dict[str, str] = None,
+    media_type: str | None = None,
+    **data: Any
+) -> HTMLResponse:
+    content = render_str(template_path, **data)
+    return HTMLResponse(
+        content=content, status_code=status_code, headers=headers, media_type=media_type
+    )

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

@@ -1,6 +1,30 @@
 import os
 
 APP_PATH = os.path.dirname(__file__)
+APP_VERSION = "0.1.0"
+
+APP_GATEWAY_VIEW_PATH = os.path.join(APP_PATH, "module", "gateway", "view")
+APP_GATEWAY_VIEW_DEFAULT_TEMPLATE_PATH = os.getenv(
+    "MY_APP_GATEWAY_VIEW_DEFAULT_TEMPLATE_PATH",
+    os.path.join("template", "default.html"),
+)
+_DEFAULT_CSS_PATH = "/static/pico-css/pico.min.css"
+APP_GATEWAY_CSS_PATH_LIST = [
+    path
+    for path in os.getenv("MY_APP_GATEWAY_CSS_PATH", _DEFAULT_CSS_PATH).split(":")
+    if path != ""
+]
+APP_GATEWAY_JS_PATH_LIST = [
+    path for path in os.getenv("MY_APP_GATEWAY_JS_PATH", "").split(":") if path != ""
+]
+APP_GATEWAY_TITLE = os.getenv("MY_APP_GATEWAY_TITLE", "My App Name")
+APP_GATEWAY_SUBTITLE = os.getenv("MY_APP_GATEWAY_SUBTITLE", "Just Another App")
+APP_GATEWAY_LOGO_PATH = os.getenv(
+    "MY_APP_GATEWAY_LOGO", "/static/images/android-chrome-192x192.png"
+)
+APP_GATEWAY_FAVICON_PATH = os.getenv(
+    "MY_APP_GATEWAY_FAVICON", "/static/images/favicon-32x32.png"
+)
 
 APP_MODE = os.getenv("MY_APP_NAME_MODE", "monolith")
 APP_MODULES = [
@@ -15,7 +39,7 @@ APP_COMMUNICATION = os.getenv(
 )
 APP_REPOSITORY_TYPE = os.getenv("APP_REPOSITORY_TYPE", "db")
 APP_DB_URL = os.getenv(
-    "APP_DB_URL",
+    "MY_APP_NAME_DB_URL",
     (
         f"sqlite:///{APP_PATH}/monolith.db"
         if APP_MODE == "monolith" or len(APP_MODULES) == 0
@@ -26,5 +50,17 @@ APP_AUTH_SUPER_USER = os.getenv("MY_APP_NAME_AUTH_SUPER_USER", "admin")
 APP_AUTH_SUPER_USER_PASSWORD = os.getenv(
     "MY_APP_NAME_AUTH_SUPER_USER_PASSWORD", "my-secure-password"
 )
+APP_AUTH_GUEST_USER = os.getenv("MY_APP_NAME_AUTH_GUEST_USER", "user")
+APP_AUTH_GUEST_USER_PERMISSIONS = (
+    permission_name.strip()
+    for permission_name in os.getenv(
+        "MY_APP_NAME_AUTH_GUEST_USER_PERMISSIONS", ""
+    ).split(",")
+    if permission_name.strip() != ""
+)
+APP_MAX_PARALLEL_SESSION = int(os.getenv("MY_APP_NAME_MAX_PARALLEL_SESSION", "1"))
+APP_SESSION_EXPIRE_MINUTES = int(
+    os.getenv("MY_APP_NAME_SESSION_EXPIRE_MINUTES", "1440")
+)
 
 APP_AUTH_BASE_URL = os.getenv("MY_APP_NAME_AUTH_BASE_URL", "http://localhost:3001")

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

@@ -1,4 +1,4 @@
-from my_app_name.common.app import app
+from my_app_name.common.app_factory import app
 from my_app_name.module.auth import route as auth_route
 from my_app_name.module.gateway import route as gateway_route
 

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/auth_api_client.py

@@ -0,0 +1,16 @@
+from my_app_name.config import APP_AUTH_BASE_URL
+from my_app_name.module.auth.client.auth_client import AuthClient
+from my_app_name.module.auth.service.permission.permission_service_factory import (
+    permission_service,
+)
+from my_app_name.module.auth.service.role.role_service_factory import role_service
+from my_app_name.module.auth.service.user.user_service_factory import user_service
+
+
+class AuthAPIClient(
+    permission_service.as_api_client(base_url=APP_AUTH_BASE_URL),
+    role_service.as_api_client(base_url=APP_AUTH_BASE_URL),
+    user_service.as_api_client(base_url=APP_AUTH_BASE_URL),
+    AuthClient,
+):
+    pass

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/auth_client.py

@@ -0,0 +1,169 @@
+from abc import ABC, abstractmethod
+
+from my_app_name.schema.permission import (
+    MultiplePermissionResponse,
+    PermissionCreateWithAudit,
+    PermissionResponse,
+    PermissionUpdateWithAudit,
+)
+from my_app_name.schema.role import (
+    MultipleRoleResponse,
+    RoleCreateWithPermissionsAndAudit,
+    RoleResponse,
+    RoleUpdateWithPermissionsAndAudit,
+)
+from my_app_name.schema.user import (
+    MultipleUserResponse,
+    UserCreateWithRolesAndAudit,
+    UserResponse,
+    UserUpdateWithRolesAndAudit,
+)
+
+
+class AuthClient(ABC):
+
+    # Permission related methods
+
+    @abstractmethod
+    async def get_permission_by_id(self, permission_id: str) -> PermissionResponse:
+        """Get permission by id"""
+
+    @abstractmethod
+    async def get_permissions(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultiplePermissionResponse:
+        """Get permissions by filter and sort"""
+
+    @abstractmethod
+    async def create_permission_bulk(
+        self, data: list[PermissionCreateWithAudit]
+    ) -> list[PermissionResponse]:
+        """Create new permissions"""
+
+    @abstractmethod
+    async def create_permission(
+        self, data: PermissionCreateWithAudit
+    ) -> PermissionResponse:
+        """Create a new permission"""
+
+    @abstractmethod
+    async def update_permission_bulk(
+        self, permission_ids: list[str], data: PermissionUpdateWithAudit
+    ) -> PermissionResponse:
+        """Update some permissions"""
+
+    @abstractmethod
+    async def update_permission(
+        self, permission_id: str, data: PermissionUpdateWithAudit
+    ) -> PermissionResponse:
+        """Update a permission"""
+
+    @abstractmethod
+    async def delete_permission_bulk(
+        self, permission_ids: str, deleted_by: str
+    ) -> PermissionResponse:
+        """Delete some permissions"""
+
+    @abstractmethod
+    async def delete_permission(
+        self, permission_id: str, deleted_by: str
+    ) -> PermissionResponse:
+        """Delete a permission"""
+
+    # Role related methods
+
+    @abstractmethod
+    async def get_role_by_id(self, role_id: str) -> RoleResponse:
+        """Get role by id"""
+
+    @abstractmethod
+    async def get_roles(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultipleRoleResponse:
+        """Get roles by filter and sort"""
+
+    @abstractmethod
+    async def create_role_bulk(
+        self, data: list[RoleCreateWithPermissionsAndAudit]
+    ) -> list[RoleResponse]:
+        """Create new roles"""
+
+    @abstractmethod
+    async def create_role(
+        self, data: RoleCreateWithPermissionsAndAudit
+    ) -> RoleResponse:
+        """Create a new role"""
+
+    @abstractmethod
+    async def update_role_bulk(
+        self, role_ids: list[str], data: RoleUpdateWithPermissionsAndAudit
+    ) -> RoleResponse:
+        """Update some roles"""
+
+    @abstractmethod
+    async def update_role(
+        self, role_id: str, data: RoleUpdateWithPermissionsAndAudit
+    ) -> RoleResponse:
+        """Update a role"""
+
+    @abstractmethod
+    async def delete_role_bulk(self, role_ids: str, deleted_by: str) -> RoleResponse:
+        """Delete some roles"""
+
+    @abstractmethod
+    async def delete_role(self, role_id: str, deleted_by: str) -> RoleResponse:
+        """Delete a role"""
+
+    # User related methods
+
+    @abstractmethod
+    async def get_user_by_id(self, user_id: str) -> UserResponse:
+        """Get user by id"""
+
+    @abstractmethod
+    async def get_users(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultipleUserResponse:
+        """Get users by filter and sort"""
+
+    @abstractmethod
+    async def create_user_bulk(
+        self, data: list[UserCreateWithRolesAndAudit]
+    ) -> list[UserResponse]:
+        """Create new users"""
+
+    @abstractmethod
+    async def create_user(self, data: UserCreateWithRolesAndAudit) -> UserResponse:
+        """Create a new user"""
+
+    @abstractmethod
+    async def update_user_bulk(
+        self, user_ids: list[str], data: UserUpdateWithRolesAndAudit
+    ) -> UserResponse:
+        """Update some users"""
+
+    @abstractmethod
+    async def update_user(
+        self, user_id: str, data: UserUpdateWithRolesAndAudit
+    ) -> UserResponse:
+        """Update a user"""
+
+    @abstractmethod
+    async def delete_user_bulk(self, user_ids: str, deleted_by: str) -> UserResponse:
+        """Delete some users"""
+
+    @abstractmethod
+    async def delete_user(self, user_id: str, deleted_by: str) -> UserResponse:
+        """Delete a user"""

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/auth_client_factory.py

@@ -0,0 +1,9 @@
+from my_app_name.config import APP_COMMUNICATION
+from my_app_name.module.auth.client.auth_api_client import AuthAPIClient
+from my_app_name.module.auth.client.auth_client import AuthClient
+from my_app_name.module.auth.client.auth_direct_client import AuthDirectClient
+
+if APP_COMMUNICATION == "direct":
+    auth_client: AuthClient = AuthDirectClient()
+elif APP_COMMUNICATION == "api":
+    auth_client: AuthClient = AuthAPIClient()

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/auth_direct_client.py

@@ -0,0 +1,15 @@
+from my_app_name.module.auth.client.auth_client import AuthClient
+from my_app_name.module.auth.service.permission.permission_service_factory import (
+    permission_service,
+)
+from my_app_name.module.auth.service.role.role_service_factory import role_service
+from my_app_name.module.auth.service.user.user_service_factory import user_service
+
+
+class AuthDirectClient(
+    permission_service.as_direct_client(),
+    role_service.as_direct_client(),
+    user_service.as_direct_client(),
+    AuthClient,
+):
+    pass

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/migration/versions/3093c7336477_add_auth_tables.py

@@ -0,0 +1,160 @@
+"""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(
+        "permission",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=True),
+        sa.Column("created_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("updated_at", sa.DateTime(), nullable=True),
+        sa.Column("updated_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_permission_name"), "permission", ["name"], unique=True)
+    op.create_index(
+        op.f("ix_permission_created_at"), "permission", ["created_at"], unique=False
+    )
+    op.create_index(
+        op.f("ix_permission_created_by"), "permission", ["created_by"], unique=False
+    )
+    op.create_index(
+        op.f("ix_permission_updated_at"), "permission", ["updated_at"], unique=False
+    )
+    op.create_index(
+        op.f("ix_permission_updated_by"), "permission", ["updated_by"], unique=False
+    )
+
+    op.create_table(
+        "role",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=True),
+        sa.Column("created_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("updated_at", sa.DateTime(), nullable=True),
+        sa.Column("updated_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_role_name"), "role", ["name"], unique=True)
+    op.create_index(op.f("ix_role_created_at"), "role", ["created_at"], unique=False)
+    op.create_index(op.f("ix_role_created_by"), "role", ["created_by"], unique=False)
+    op.create_index(op.f("ix_role_updated_at"), "role", ["updated_at"], unique=False)
+    op.create_index(op.f("ix_role_updated_by"), "role", ["updated_by"], unique=False)
+
+    op.create_table(
+        "rolepermission",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("role_id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("permission_id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=True),
+        sa.Column("created_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(
+        op.f("ix_rolepermission_permission_id"),
+        "rolepermission",
+        ["permission_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_rolepermission_role_id"), "rolepermission", ["role_id"], unique=False
+    )
+
+    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.Column("created_at", sa.DateTime(), nullable=False),
+        sa.Column("created_by", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(), nullable=True),
+        sa.Column("updated_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_user_username"), "user", ["username"], unique=True)
+    op.create_index(op.f("ix_user_created_at"), "user", ["created_at"], unique=False)
+    op.create_index(op.f("ix_user_created_by"), "user", ["created_by"], unique=False)
+    op.create_index(op.f("ix_user_updated_at"), "user", ["updated_at"], unique=False)
+    op.create_index(op.f("ix_user_updated_by"), "user", ["updated_by"], unique=False)
+
+    op.create_table(
+        "userrole",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("user_id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("role_id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=True),
+        sa.Column("created_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_userrole_role_id"), "userrole", ["role_id"], unique=False)
+    op.create_index(op.f("ix_userrole_user_id"), "userrole", ["user_id"], unique=False)
+
+    op.create_table(
+        "session",
+        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("user_id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("token", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_session_user_id"), "session", ["user_id"], unique=False)
+    op.create_index(op.f("ix_session_token"), "session", ["token"], unique=True)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f("ix_session_token"), table_name="session")
+    op.drop_index(op.f("ix_session_user_id"), table_name="session")
+    op.drop_table("session")
+
+    op.drop_index(op.f("ix_userrole_user_id"), table_name="userrole")
+    op.drop_index(op.f("ix_userrole_role_id"), table_name="userrole")
+    op.drop_table("userrole")
+
+    op.drop_index(op.f("ix_user_username"), table_name="user")
+    op.drop_index(op.f("ix_user_updated_by"), table_name="user")
+    op.drop_index(op.f("ix_user_updated_at"), table_name="user")
+    op.drop_index(op.f("ix_user_created_by"), table_name="user")
+    op.drop_index(op.f("ix_user_created_at"), table_name="user")
+    op.drop_table("user")
+
+    op.drop_index(op.f("ix_rolepermission_role_id"), table_name="rolepermission")
+    op.drop_index(op.f("ix_rolepermission_permission_id"), table_name="rolepermission")
+    op.drop_table("rolepermission")
+
+    op.drop_index(op.f("ix_role_name"), table_name="role")
+    op.drop_index(op.f("ix_role_updated_by"), table_name="role")
+    op.drop_index(op.f("ix_role_updated_at"), table_name="role")
+    op.drop_index(op.f("ix_role_created_by"), table_name="role")
+    op.drop_index(op.f("ix_role_created_at"), table_name="role")
+    op.drop_table("role")
+
+    op.drop_index(op.f("ix_permission_updated_by"), table_name="permission")
+    op.drop_index(op.f("ix_permission_updated_at"), table_name="permission")
+    op.drop_index(op.f("ix_permission_created_by"), table_name="permission")
+    op.drop_index(op.f("ix_permission_created_at"), table_name="permission")
+    op.drop_index(op.f("ix_permission_name"), table_name="permission")
+    op.drop_table("permission")
+    # ### end Alembic commands ###

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

@@ -1,6 +1,23 @@
-from my_app_name.schema.user import User
+from my_app_name.schema.permission import Permission
+from my_app_name.schema.role import Role, RolePermission
+from my_app_name.schema.session import Session
+from my_app_name.schema.user import User, UserRole
 from sqlalchemy import MetaData
 
 metadata = MetaData()
+
+Permission.metadata = metadata
+Permission.__table__.tometadata(metadata)
+
+Role.metadata = metadata
+Role.__table__.tometadata(metadata)
+RolePermission.metadata = metadata
+RolePermission.__table__.tometadata(metadata)
+
 User.metadata = metadata
 User.__table__.tometadata(metadata)
+UserRole.metadata = metadata
+UserRole.__table__.tometadata(metadata)
+
+Session.metadata = metadata
+Session.__table__.tometadata(metadata)