zrb 1.0.0b8__tar.gz → 1.0.0b9__tar.gz

{zrb-1.0.0b8 → zrb-1.0.0b9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0b8
+Version: 1.0.0b9
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -23,6 +23,7 @@ Requires-Dist: fastembed (>=0.5.1,<0.6.0)
 Requires-Dist: isort (>=5.13.2,<5.14.0)
 Requires-Dist: libcst (>=1.5.0,<2.0.0)
 Requires-Dist: pdfplumber (>=0.11.4,<0.12.0) ; extra == "rag"
+Requires-Dist: psutil (>=6.1.1,<7.0.0)
 Requires-Dist: pydantic-ai (>=0.0.19,<0.0.20)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.3.0,<4.0.0)

{zrb-1.0.0b8 → zrb-1.0.0b9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.0.0b8"
+version = "1.0.0b9"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"
@@ -52,6 +52,7 @@ python-jose = {extras = ["cryptography"], version = "^3.3.0"}
 ulid-py = "^1.1.0"
 pydantic-ai = "^0.0.19"
 fastembed = "^0.5.1"
+psutil = "^6.1.1"
 
 [tool.poetry.extras]
 # poetry install -E rag

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/__main__.py

@@ -16,8 +16,11 @@ def serve_cli():
         cli.run(sys.argv[1:])
     except KeyboardInterrupt:
         print(stylize_warning("\nStopped"), file=sys.stderr)
+        sys.exit(1)
     except RuntimeError as e:
         if f"{e}".lower() != "event loop is closed":
             raise e
+        sys.exit(1)
     except NodeNotFoundError as e:
         print(stylize_error(f"{e}"), file=sys.stderr)
+        sys.exit(1)

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_task.py

@@ -57,6 +57,7 @@ scaffold_fastapp = Scaffolder(
                 "my_app_name": "{to_snake_case(ctx.input.app)}",
                 "MY_APP_NAME": "{to_snake_case(ctx.input.app).upper()}",
                 "my-secure-password": lambda _: get_random_name(),
+                "my-secret-key": lambda _: get_random_name(),
             },
         ),
         # Register fastapp's tasks to project's zrb_init (project_dir/zrb_init.py)

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/add_entity_task.py

@@ -88,6 +88,7 @@ scaffold_my_app_name_entity = Scaffolder(
             match=is_in_app_schema_dir,
             transform={
                 "MyEntity": "{to_pascal_case(ctx.input.entity)}",
+                "my_entities": "{to_snake_case(ctx.input.plural)}",
                 "my_column": "{to_snake_case(ctx.input.column)}",
             },
         ),

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/module/my_module/service/my_entity/my_entity_service.py

@@ -67,11 +67,11 @@ class MyEntityService(BaseService):
     @BaseService.route(
         "/api/v1/my-entities/bulk",
         methods=["put"],
-        response_model=MyEntityResponse,
+        response_model=list[MyEntityResponse],
     )
     async def update_my_entity_bulk(
         self, my_entity_ids: list[str], data: MyEntityUpdateWithAudit
-    ) -> MyEntityResponse:
+    ) -> list[MyEntityResponse]:
         await self.my_entity_repository.update_bulk(my_entity_ids, data)
         return await self.my_entity_repository.get_by_ids(my_entity_ids)
 
@@ -89,11 +89,11 @@ class MyEntityService(BaseService):
     @BaseService.route(
         "/api/v1/my-entities/bulk",
         methods=["delete"],
-        response_model=MyEntityResponse,
+        response_model=list[MyEntityResponse],
     )
     async def delete_my_entity_bulk(
         self, my_entity_ids: list[str], deleted_by: str
-    ) -> MyEntityResponse:
+    ) -> list[MyEntityResponse]:
         my_entities = await self.my_entity_repository.get_by_ids(my_entity_ids)
         await self.my_entity_repository.delete_bulk(my_entity_ids)
         return my_entities
@@ -106,6 +106,6 @@ class MyEntityService(BaseService):
     async def delete_my_entity(
         self, my_entity_id: str, deleted_by: str
     ) -> MyEntityResponse:
-        my_entity = await self.my_entity_repository.get_by_id(my_entity.id)
+        my_entity = await self.my_entity_repository.get_by_id(my_entity_id)
         await self.my_entity_repository.delete(my_entity_id)
         return my_entity

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/schema/my_entity.py

@@ -39,6 +39,7 @@ class MultipleMyEntityResponse(BaseModel):
 
 
 class MyEntity(SQLModel, table=True):
+    __tablename__ = "my_entities"
     id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
     created_at: datetime.datetime = Field(index=True)
     created_by: str = Field(index=True)

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/input.py

@@ -3,6 +3,14 @@ from my_app_name._zrb.util import get_existing_module_names, get_existing_schema
 from zrb import OptionInput, StrInput
 from zrb.util.string.conversion import pluralize
 
+run_env_input = OptionInput(
+    name="env",
+    description="Running environment",
+    prompt="Running Environment",
+    options=["dev", "prod"],
+    default_str="prod",
+)
+
 new_module_input = StrInput(
     name="module", description="Module name", prompt="New module name"
 )

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/task.py

@@ -9,8 +9,14 @@ from my_app_name._zrb.group import (
     app_migrate_group,
     app_run_group,
 )
+from my_app_name._zrb.input import run_env_input
 from my_app_name._zrb.module.add_module_task import add_my_app_name_module
-from my_app_name._zrb.util import create_migration, migrate_module, run_microservice
+from my_app_name._zrb.task_util import (
+    create_migration,
+    migrate_module,
+    run_microservice,
+    run_my_app_name,
+)
 from my_app_name._zrb.venv_task import prepare_venv
 
 from zrb import CmdTask, EnvFile, EnvMap, Task
@@ -52,6 +58,7 @@ run_monolith = app_run_group.add_task(
     CmdTask(
         name="run-monolith-my-app-name",
         description="🗿 Run My App Name as a monolith",
+        input=run_env_input,
         env=[
             EnvFile(path=os.path.join(APP_DIR, "template.env")),
             EnvMap(vars=MONOLITH_ENV_VARS),
@@ -59,7 +66,7 @@ run_monolith = app_run_group.add_task(
         cwd=APP_DIR,
         cmd=[
             ACTIVATE_VENV_SCRIPT,
-            'fastapi dev main.py --port "${MY_APP_NAME_PORT}"',
+            run_my_app_name,
         ],
         render_cmd=False,
         retries=2,

zrb-1.0.0b8/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/util.py → zrb-1.0.0b9/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/task_util.py

@@ -1,5 +1,4 @@
 import os
-import platform
 
 from my_app_name._zrb.config import (
     ACTIVATE_VENV_SCRIPT,
@@ -7,9 +6,17 @@ from my_app_name._zrb.config import (
     MICROSERVICES_ENV_VARS,
     MONOLITH_ENV_VARS,
 )
+from my_app_name._zrb.input import run_env_input
+from my_app_name._zrb.util import (
+    cd_module_script,
+    run_my_app_name,
+    set_create_migration_db_url_env,
+    set_env,
+    set_module_env,
+)
 
 from zrb import Cmd, CmdTask, EnvFile, EnvMap, StrInput, Task
-from zrb.util.string.conversion import double_quote, to_snake_case
+from zrb.util.string.conversion import to_snake_case
 
 
 def create_migration(name: str, module: str) -> Task:
@@ -72,6 +79,7 @@ def run_microservice(name: str, port: int, module: str) -> Task:
     return CmdTask(
         name=f"run-my-app-name-{name}",
         description=f"🧩 Run My App Name {name.capitalize()}",
+        input=run_env_input,
         env=[
             EnvFile(path=os.path.join(APP_DIR, "template.env")),
             EnvMap(
@@ -85,54 +93,8 @@ def run_microservice(name: str, port: int, module: str) -> Task:
             ACTIVATE_VENV_SCRIPT,
             set_env("MY_APP_NAME_MODULES", module),
             set_env("MY_APP_NAME_PORT", f"{port}"),
-            'fastapi dev main.py --port "${MY_APP_NAME_PORT}"',
+            run_my_app_name,
         ],
         render_cmd=False,
         retries=2,
     )
-
-
-def get_existing_module_names() -> list[str]:
-    module_dir_path = os.path.join(APP_DIR, "module")
-    return [entry.name for entry in os.scandir(module_dir_path) if entry.is_dir()]
-
-
-def get_existing_schema_names() -> list[str]:
-    module_dir_path = os.path.join(APP_DIR, "schema")
-    return [
-        os.path.splitext(entry.name)[0]
-        for entry in os.scandir(module_dir_path)
-        if entry.is_file() and entry.name.endswith(".py")
-    ]
-
-
-def set_create_migration_db_url_env(module_name: str) -> str:
-    return set_env(
-        "MY_APP_NAME_DB_URL",
-        f"sqlite:///{APP_DIR}/.migration.{to_snake_case(module_name)}.db",
-    )
-
-
-def set_module_env(module_name: str) -> str:
-    return (set_env("MY_APP_NAME_MODULES", to_snake_case(module_name)),)
-
-
-def cd_module_script(module_name: str) -> str:
-    module_dir_path = os.path.join(APP_DIR, "module", to_snake_case(module_name))
-    return f"cd {module_dir_path}"
-
-
-def set_env(var_name: str, var_value: str) -> str:
-    """
-    Generates a script to set an environment variable depending on the OS.
-    :param var_name: Name of the environment variable.
-    :param var_value: Value of the environment variable.
-    :return: A string containing the appropriate script.
-    """
-    if platform.system() == "Windows":
-        # PowerShell script for Windows
-        script = f'[Environment]::SetEnvironmentVariable({double_quote(var_name)}, {double_quote(var_value)}, "User")'  # noqa
-    else:
-        # Bash script for Unix-like systems
-        script = f"export {var_name}={double_quote(var_value)}"
-    return script

zrb-1.0.0b9/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/util.py

@@ -0,0 +1,58 @@
+import os
+import platform
+
+from my_app_name._zrb.config import APP_DIR
+
+from zrb import AnyContext
+from zrb.util.string.conversion import double_quote, to_snake_case
+
+
+def run_my_app_name(ctx: AnyContext) -> str:
+    subcommand = "dev" if ctx.input.env == "dev" else "run"
+    return f'fastapi {subcommand}  main.py --port "${{MY_APP_NAME_PORT}}"'
+
+
+def get_existing_module_names() -> list[str]:
+    module_dir_path = os.path.join(APP_DIR, "module")
+    return [entry.name for entry in os.scandir(module_dir_path) if entry.is_dir()]
+
+
+def get_existing_schema_names() -> list[str]:
+    module_dir_path = os.path.join(APP_DIR, "schema")
+    return [
+        os.path.splitext(entry.name)[0]
+        for entry in os.scandir(module_dir_path)
+        if entry.is_file() and entry.name.endswith(".py")
+    ]
+
+
+def set_create_migration_db_url_env(module_name: str) -> str:
+    return set_env(
+        "MY_APP_NAME_DB_URL",
+        f"sqlite:///{APP_DIR}/.migration.{to_snake_case(module_name)}.db",
+    )
+
+
+def set_module_env(module_name: str) -> str:
+    return (set_env("MY_APP_NAME_MODULES", to_snake_case(module_name)),)
+
+
+def cd_module_script(module_name: str) -> str:
+    module_dir_path = os.path.join(APP_DIR, "module", to_snake_case(module_name))
+    return f"cd {module_dir_path}"
+
+
+def set_env(var_name: str, var_value: str) -> str:
+    """
+    Generates a script to set an environment variable depending on the OS.
+    :param var_name: Name of the environment variable.
+    :param var_value: Value of the environment variable.
+    :return: A string containing the appropriate script.
+    """
+    if platform.system() == "Windows":
+        # PowerShell script for Windows
+        script = f'[Environment]::SetEnvironmentVariable({double_quote(var_name)}, {double_quote(var_value)}, "User")'  # noqa
+    else:
+        # Bash script for Unix-like systems
+        script = f"export {var_name}={double_quote(var_value)}"
+    return script

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/base_db_repository.py

@@ -122,9 +122,19 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
         return self._ensure_one(rows)
 
     async def get_by_ids(self, id_list: list[str]) -> list[ResponseModel]:
-        return await self._select_to_response(
+        rows = await self._select_to_response(
             lambda q: q.where(self.db_model.id.in_(id_list))
         )
+        # raise error if any id not in id_list
+        existing_id_list = [row.id for row in rows]
+        inexist_id_list = [id for id in id_list if id not in existing_id_list]
+        if len(inexist_id_list) > 0:
+            raise NotFoundError(
+                f"{self.entity_name} not found, inexist ids: {', '.join(inexist_id_list)}"
+            )
+        # sort rows
+        row_dict = {row.id: row for row in rows}
+        return [row_dict[id] for id in id_list]
 
     async def count(self, filter: str | None = None) -> int:
         count_statement = select(func.count(1)).select_from(self.db_model)
@@ -184,21 +194,22 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
 
     async def create_bulk(self, data_list: list[CreateModel]) -> list[DBModel]:
         now = datetime.datetime.now(datetime.timezone.utc)
-        data_dicts = [
+        data_dict_list = [
             self._model_to_data_dict(data, created_at=now, id=ulid.new().str)
             for data in data_list
         ]
+        id_list = [data_dict["id"] for data_dict in data_dict_list]
         async with self._session_scope() as session:
             await self._execute_statement(
-                session, insert(self.db_model).values(data_dicts)
+                session, insert(self.db_model).values(data_dict_list)
             )
-            id_list = [d["id"] for d in data_dicts]
             statement = select(self.db_model).where(self.db_model.id.in_(id_list))
             result = await self._execute_statement(session, statement)
-            return [
-                self.db_model(**entity.model_dump())
+            row_dict = {
+                entity.id: self.db_model(**entity.model_dump())
                 for entity in result.scalars().all()
-            ]
+            }
+            return [row_dict[id] for id in id_list]
 
     async def delete(self, id: str) -> DBModel:
         async with self._session_scope() as session:
@@ -220,11 +231,15 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
             await self._execute_statement(
                 session, delete(self.db_model).where(self.db_model.id.in_(id_list))
             )
-            return [self.db_model(**entity.model_dump()) for entity in entities]
+            row_dict = {
+                entity.id: self.db_model(**entity.model_dump()) for entity in entities
+            }
+            return [row_dict[id] for id in id_list]
 
     async def update(self, id: str, data: UpdateModel) -> DBModel:
         now = datetime.datetime.now(datetime.timezone.utc)
         update_data = self._model_to_data_dict(data, updated_at=now)
+        update_data = {k: v for k, v in update_data.items() if v is not None}
         async with self._session_scope() as session:
             statement = (
                 update(self.db_model)
@@ -256,7 +271,8 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
             result = await self._execute_statement(
                 session, select(self.db_model).where(self.db_model.id.in_(id_list))
             )
-            return [
-                self.db_model(**entity.model_dump())
+            row_dict = {
+                entity.id: self.db_model(**entity.model_dump())
                 for entity in result.scalars().all()
-            ]
+            }
+            return [row_dict[id] for id in id_list]

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/base_service.py

@@ -56,7 +56,6 @@ class BaseService:
         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,
         deprecated: bool | None = None,
@@ -160,56 +159,62 @@ def _create_direct_client_method(logger: Logger, func: Callable, service: BaseSe
     return client_method
 
 
-def _create_api_client_method(logger: Logger, param: RouteParam, base_url: str):
+def _create_api_client_method(logger: Logger, route_param: RouteParam, base_url: str):
     async def client_method(*args, **kwargs):
-        url = base_url + param.path
+        url = base_url + route_param.path
         method = (
-            param.methods[0].lower()
-            if isinstance(param.methods, list)
-            else param.methods.lower()
+            route_param.methods[0].lower()
+            if isinstance(route_param.methods, list)
+            else route_param.methods.lower()
         )
         # Get the signature of the original function
-        sig = inspect.signature(param.func)
+        sig = inspect.signature(route_param.func)
         # Bind the arguments to the signature
         bound_args = sig.bind(*args, **kwargs)
         bound_args.apply_defaults()
         # Analyze parameters
-        params = list(sig.parameters.values())
-        body_params = [
-            p
-            for p in params
-            if p.name != "self" and p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
+        function_params = list(sig.parameters.values())
+        body_param_names = [
+            p.name
+            for p in function_params
+            if (
+                p.name != "self"
+                and f"{{{p.name}}}" not in route_param.path
+                and p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
+                and (
+                    method not in ["get", "delete"]
+                    or (method == "delete" and p.annotation not in [str, float, bool])
+                )
+            )
         ]
         # Prepare the request
         path_params = {}
         query_params = {}
-        body = {}
+        body_params = {}
         for name, value in bound_args.arguments.items():
             if name == "self":
                 continue
-            if f"{{{name}}}" in param.path:
+            if f"{{{name}}}" in route_param.path:
                 path_params[name] = value
-            elif isinstance(value, BaseModel):
-                body = _parse_api_param(value)
-            elif method in ["get", "delete"]:
+            elif name not in body_param_names:
                 query_params[name] = _parse_api_param(value)
-            elif len(body_params) == 1 and name == body_params[0].name:
+            elif len(body_param_names) == 1 and name == body_param_names[0]:
                 # If there's only one body parameter, use its value directly
-                body = _parse_api_param(value)
+                body_params = _parse_api_param(value)
             else:
-                body[name] = _parse_api_param(value)
+                body_params[name] = _parse_api_param(value)
         # Format the URL with path parameters
         url = url.format(**path_params)
         logger.info(
-            f"Sending request to {url} with method {method}, json={body}, params={query_params}"  # noqa
+            f"Sending request to {url} with method {method}, json={body_params}, params={query_params}"  # noqa
         )
         async with httpx.AsyncClient() as client:
-            if method in ["get", "delete"]:
-                response = await getattr(client, method)(url, params=query_params)
-            else:
-                response = await getattr(client, method)(
-                    url, json=body, params=query_params
-                )
+            response = await client.request(
+                method=method,
+                url=url,
+                params=query_params,
+                json=None if method == "get" else body_params,
+            )
             logger.info(
                 f"Received response: status={response.status_code}, content={response.content}"
             )

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/error.py

@@ -8,11 +8,26 @@ class NotFoundError(HTTPException):
         super().__init__(404, {"message": message}, headers)
 
 
+class ForbiddenError(HTTPException):
+    def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
+        super().__init__(403, {"message": message}, headers)
+
+
+class UnauthorizedError(HTTPException):
+    def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
+        super().__init__(401, {"message": message}, headers)
+
+
 class InvalidValueError(HTTPException):
     def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
         super().__init__(422, {"message": message}, headers)
 
 
+class InternalServerError(HTTPException):
+    def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
+        super().__init__(500, {"message": message}, headers)
+
+
 class ClientAPIError(HTTPException):
     def __init__(
         self, status_code: int, message: str, headers: Dict[str, str] | None = None

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/config.py

@@ -1,5 +1,8 @@
 import os
 
+TRUE_STRS = ["true", "1", "yes", "y", "active", "on"]
+FALSE_STRS = ["false", "0", "no", "n", "inactive", "off"]
+
 APP_PATH = os.path.dirname(__file__)
 APP_VERSION = "0.1.0"
 
@@ -51,16 +54,30 @@ 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 = (
+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_AUTH_MAX_PARALLEL_SESSION = int(
+    os.getenv("MY_APP_NAME_AUTH_MAX_PARALLEL_SESSION", "1")
 )
-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_ACCESS_TOKEN_EXPIRE_MINUTES = int(
+    os.getenv("MY_APP_NAME_AUTH_ACCESS_TOKEN_EXPIRE_MINUTES", "30")
+)
+APP_AUTH_REFRESH_TOKEN_EXPIRE_MINUTES = int(
+    os.getenv("MY_APP_NAME_AUTH_REFRESH_TOKEN_EXPIRE_MINUTES", "1440")
+)
+APP_AUTH_ACCESS_TOKEN_COOKIE_NAME = os.getenv(
+    "MY_APP_NAME_AUTH_ACCESS_TOKEN_COOKIE_NAME", "access_token"
+)
+APP_AUTH_REFRESH_TOKEN_COOKIE_NAME = os.getenv(
+    "MY_APP_NAME_AUTH_REFRESH_TOKEN_COOKIE_NAME", "refresh_token"
+)
+APP_AUTH_SECRET_KEY = os.getenv("MY_APP_NAME_AUTH_SECRET_KEY", "my-secret-key")
+APP_AUTH_PRIORITIZE_NEW_SESSION = (
+    os.getenv("MY_APP_NAME_AUTH_PRIORITIZE_NEW_SESSION", "1").lower() in TRUE_STRS
 )
-
 APP_AUTH_BASE_URL = os.getenv("MY_APP_NAME_AUTH_BASE_URL", "http://localhost:3001")

{zrb-1.0.0b8 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/auth_client.py

@@ -13,15 +13,36 @@ from my_app_name.schema.role import (
     RoleUpdateWithPermissionsAndAudit,
 )
 from my_app_name.schema.user import (
+    AuthUserResponse,
     MultipleUserResponse,
     UserCreateWithRolesAndAudit,
+    UserCredentials,
     UserResponse,
+    UserSessionResponse,
     UserUpdateWithRolesAndAudit,
 )
 
 
 class AuthClient(ABC):
 
+    @abstractmethod
+    async def get_current_user(self, access_token: str) -> AuthUserResponse:
+        """Get current user based on access token"""
+
+    @abstractmethod
+    async def create_user_session(
+        self, credential: UserCredentials
+    ) -> UserSessionResponse:
+        """Create new user session"""
+
+    @abstractmethod
+    async def update_user_session(self, refresh_token: str) -> UserSessionResponse:
+        """Update user session"""
+
+    @abstractmethod
+    async def delete_user_session(self, refresh_token: str) -> UserSessionResponse:
+        """Delete user session"""
+
     # Permission related methods
 
     @abstractmethod