zrb 0.23.4__py3-none-any.whl → 0.26.0__py3-none-any.whl

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/helper/async_task.py

@@ -1,6 +1,6 @@
 import asyncio
 import inspect
-from typing import Awaitable, Callable
+from collections.abc import Awaitable, Callable
 
 
 def create_task(awaitable: Awaitable, on_error: Callable) -> asyncio.Task:

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/app/app.py

@@ -1,17 +1,17 @@
 from config import (
-    app_cors_allow_credentials,
-    app_cors_allow_headers,
-    app_cors_allow_methods,
-    app_cors_allow_origin_regex,
-    app_cors_allow_origins,
-    app_cors_expose_headers,
-    app_cors_max_age,
-    app_enable_frontend,
-    public_auth_access_token_cookie_key,
-    public_auth_refresh_token_cookie_key,
-    public_brand,
-    public_title,
-    zrb_app_name,
+    APP_AUTH_ACCESS_TOKEN_COOKIE_KEY,
+    APP_AUTH_REFRESH_TOKEN_COOKIE_KEY,
+    APP_BRAND,
+    APP_CORS_ALLOW_CREDENTIALS,
+    APP_CORS_ALLOW_HEADERS,
+    APP_CORS_ALLOW_METHODS,
+    APP_CORS_ALLOW_ORIGIN_REGEX,
+    APP_CORS_ALLOW_ORIGINS,
+    APP_CORS_EXPOSE_HEADERS,
+    APP_CORS_MAX_AGE,
+    APP_ENABLE_FRONTEND,
+    APP_NAME,
+    APP_TITLE,
 )
 from fastapi import FastAPI, status
 from fastapi.middleware.cors import CORSMiddleware
@@ -21,9 +21,9 @@ from integration.app.app_state import app_state
 from integration.frontend_index import frontend_index_response
 from schema.frontend_config import FrontendConfig
 
-app = FastAPI(title=zrb_app_name, lifespan=app_lifespan)
+app = FastAPI(title=APP_NAME, lifespan=app_lifespan)
 
-if app_enable_frontend:
+if APP_ENABLE_FRONTEND:
 
     @app.middleware("http")
     async def catch_all(request, call_next):
@@ -38,13 +38,13 @@ if app_enable_frontend:
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=app_cors_allow_origins,
-    allow_origin_regex=app_cors_allow_origin_regex,
-    allow_methods=app_cors_allow_methods,
-    allow_headers=app_cors_allow_headers,
-    allow_credentials=app_cors_allow_credentials,
-    expose_headers=app_cors_expose_headers,
-    max_age=app_cors_max_age,
+    allow_origins=APP_CORS_ALLOW_ORIGINS,
+    allow_origin_regex=APP_CORS_ALLOW_ORIGIN_REGEX,
+    allow_methods=APP_CORS_ALLOW_METHODS,
+    allow_headers=APP_CORS_ALLOW_HEADERS,
+    allow_credentials=APP_CORS_ALLOW_CREDENTIALS,
+    expose_headers=APP_CORS_EXPOSE_HEADERS,
+    max_age=APP_CORS_MAX_AGE,
 )
 
 
@@ -60,7 +60,7 @@ def get_application_liveness_status():
     """
     if app_state.get_liveness():
         return JSONResponse(
-            content={"app": zrb_app_name, "alive": True}, status_code=status.HTTP_200_OK
+            content={"app": APP_NAME, "alive": True}, status_code=status.HTTP_200_OK
         )
     return JSONResponse(
         content={"message": "Service is not alive"},
@@ -81,7 +81,7 @@ def get_application_readiness_status():
     """
     if app_state.get_readiness():
         return JSONResponse(
-            content={"app": zrb_app_name, "ready": True}, status_code=status.HTTP_200_OK
+            content={"app": APP_NAME, "ready": True}, status_code=status.HTTP_200_OK
         )
     return JSONResponse(
         content={"message": "Service is not ready"},
@@ -93,8 +93,8 @@ def get_application_readiness_status():
 @app.get("/api/v1/frontend/configs", response_model=FrontendConfig)
 def get_configs() -> FrontendConfig:
     return FrontendConfig(
-        brand=public_brand,
-        title=public_title,
-        access_token_cookie_key=public_auth_access_token_cookie_key,
-        refresh_token_cookie_key=public_auth_refresh_token_cookie_key,
+        brand=APP_BRAND,
+        title=APP_TITLE,
+        access_token_cookie_key=APP_AUTH_ACCESS_TOKEN_COOKIE_KEY,
+        refresh_token_cookie_key=APP_AUTH_REFRESH_TOKEN_COOKIE_KEY,
     )

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/app/app_lifespan.py

@@ -2,12 +2,12 @@ import os
 from contextlib import asynccontextmanager
 
 from config import (
-    app_db_auto_migrate,
-    app_enable_event_handler,
-    app_enable_frontend,
-    app_enable_rpc_server,
-    app_src_dir,
-    zrb_app_name,
+    APP_DB_AUTO_MIGRATE,
+    APP_ENABLE_EVENT_HANDLER,
+    APP_ENABLE_FRONTEND,
+    APP_ENABLE_RPC_SERVER,
+    APP_NAME,
+    APP_SRC_DIR,
 )
 from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
@@ -21,24 +21,24 @@ from migrate import migrate
 
 @asynccontextmanager
 async def app_lifespan(app: FastAPI):
-    logger.info(f"{zrb_app_name} started")
-    if app_db_auto_migrate:
+    logger.info(f"{APP_NAME} started")
+    if APP_DB_AUTO_MIGRATE:
         await migrate()
     app_state.set_liveness(True)
-    if app_enable_event_handler:
+    if APP_ENABLE_EVENT_HANDLER:
         create_task(consumer.start(), on_error=set_not_ready_on_error)
-    if app_enable_rpc_server:
+    if APP_ENABLE_RPC_SERVER:
         create_task(rpc_server.start(), on_error=set_not_ready_on_error)
-    if app_enable_frontend:
-        build_path = os.path.join(app_src_dir, "frontend", "build")
+    if APP_ENABLE_FRONTEND:
+        build_path = os.path.join(APP_SRC_DIR, "frontend", "build")
         app.mount(
             path="",
             app=StaticFiles(directory=build_path, html=True),
             name="frontend-static-resources",
         )
     app_state.set_readiness(True)
-    logger.info(f"{zrb_app_name} started")
+    logger.info(f"{APP_NAME} started")
     yield
-    if app_enable_event_handler:
+    if APP_ENABLE_EVENT_HANDLER:
         await consumer.stop()
-    logger.info(f"{zrb_app_name} closed")
+    logger.info(f"{APP_NAME} closed")

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/app/app_state.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from config import app_max_not_ready
+from config import APP_MAX_NOT_READY
 from integration.log import logger
 
 
@@ -35,5 +35,5 @@ app_state = AppState()
 async def set_not_ready_on_error(exception: Exception):
     logger.critical(exception)
     app_state.set_readiness(False)
-    await asyncio.sleep(app_max_not_ready)
+    await asyncio.sleep(APP_MAX_NOT_READY)
     app_state.set_liveness(False)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/db_connection.py

@@ -1,6 +1,12 @@
 import time
 
-from config import app_db_connection, app_db_engine_show_log
+from config import (
+    APP_DB_CONNECTION,
+    APP_DB_ENGINE_SHOW_LOG,
+    APP_DB_POOL_MAX_OVERFLOW,
+    APP_DB_POOL_PRE_PING,
+    APP_DB_POOL_SIZE,
+)
 from integration.log import logger
 from sqlalchemy import Engine, create_engine, event
 
@@ -27,4 +33,10 @@ def after_cursor_execute(conn, cursor, statement, parameters, context, executema
     )
 
 
-engine: Engine = create_engine(app_db_connection, echo=app_db_engine_show_log)
+engine: Engine = create_engine(
+    APP_DB_CONNECTION,
+    echo=APP_DB_ENGINE_SHOW_LOG,
+    pool_pre_ping=APP_DB_POOL_PRE_PING,
+    pool_size=APP_DB_POOL_SIZE,
+    max_identifier_length=APP_DB_POOL_MAX_OVERFLOW,
+)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/frontend_index.py

@@ -1,9 +1,9 @@
 import os
 
-from config import app_src_dir
+from config import APP_SRC_DIR
 from fastapi.responses import HTMLResponse
 
-index_html_path = os.path.join(app_src_dir, "frontend", "build", "index.html")
+index_html_path = os.path.join(APP_SRC_DIR, "frontend", "build", "index.html")
 with open(index_html_path, "r") as f:
     index_html_content = f.read()
 

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/log.py

@@ -1,6 +1,6 @@
 import logging
 
-from config import app_enable_otel, app_logging_level, app_otel_exporter_otlp_endpoint
+from config import APP_ENABLE_OTEL, APP_LOGGING_LEVEL, APP_OTEL_EXPORTER_OTLP_ENDPOINT
 from opentelemetry._logs import set_logger_provider
 from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
 from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
@@ -10,14 +10,14 @@ from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
 # Create logger
 ##############################################################################
 logger = logging.getLogger("src")
-logger.setLevel(app_logging_level)
+logger.setLevel(APP_LOGGING_LEVEL)
 
 ##############################################################################
 # Formatter log handler
 ##############################################################################
 
 stream_handler = logging.StreamHandler()
-stream_handler.setLevel(app_logging_level)
+stream_handler.setLevel(APP_LOGGING_LEVEL)
 # create formatter
 formatter = logging.Formatter("%(levelname)s:\t%(message)s")
 # set stream handler's formatter
@@ -29,17 +29,17 @@ logger.addHandler(stream_handler)
 # Open telemetry log handler
 ##############################################################################
 
-if app_enable_otel:
+if APP_ENABLE_OTEL:
     # create logger providers
     otlp_logger_provider = LoggerProvider()
     # set the providers
     set_logger_provider(otlp_logger_provider)
-    otlp_log_exporter = OTLPLogExporter(endpoint=app_otel_exporter_otlp_endpoint)
+    otlp_log_exporter = OTLPLogExporter(endpoint=APP_OTEL_EXPORTER_OTLP_ENDPOINT)
     # add the batch processors to the trace provider
     otlp_logger_provider.add_log_record_processor(
         BatchLogRecordProcessor(otlp_log_exporter)
     )
     otlp_log_handler = LoggingHandler(
-        level=app_logging_level, logger_provider=otlp_logger_provider
+        level=APP_LOGGING_LEVEL, logger_provider=otlp_logger_provider
     )
     logger.addHandler(otlp_log_handler)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/messagebus.py

@@ -14,31 +14,31 @@ from component.messagebus import (
     RMQPublisher,
 )
 from config import (
-    app_broker_type,
-    app_kafka_bootstrap_servers,
-    app_kafka_sasl_mechanism,
-    app_kafka_sasl_pass,
-    app_kafka_sasl_user,
-    app_kafka_security_protocol,
-    app_rmq_connection_string,
-    zrb_app_name,
+    APP_BROKER_TYPE,
+    APP_KAFKA_BOOTSTRAP_SERVERS,
+    APP_KAFKA_SASL_MECHANISM,
+    APP_KAFKA_SASL_PASS,
+    APP_KAFKA_SASL_USER,
+    APP_KAFKA_SECURITY_PROTOCOL,
+    APP_NAME,
+    APP_RMQ_CONNECTION_STRING,
 )
 from integration.log import logger
 
 
 def init_admin(default_admin: Admin) -> Admin:
-    if app_broker_type == "rabbitmq":
+    if APP_BROKER_TYPE == "rabbitmq":
         return RMQAdmin(
-            logger=logger, connection_string=app_rmq_connection_string, configs={}
+            logger=logger, connection_string=APP_RMQ_CONNECTION_STRING, configs={}
         )
-    if app_broker_type == "kafka":
+    if APP_BROKER_TYPE == "kafka":
         return KafkaAdmin(
             logger=logger,
-            bootstrap_servers=app_kafka_bootstrap_servers,
-            security_protocol=app_kafka_security_protocol,
-            sasl_mechanism=app_kafka_sasl_mechanism,
-            sasl_plain_username=app_kafka_sasl_user,
-            sasl_plain_password=app_kafka_sasl_pass,
+            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
+            security_protocol=APP_KAFKA_SECURITY_PROTOCOL,
+            sasl_mechanism=APP_KAFKA_SASL_MECHANISM,
+            sasl_plain_username=APP_KAFKA_SASL_USER,
+            sasl_plain_password=APP_KAFKA_SASL_PASS,
             configs={},
         )
     return default_admin
@@ -47,21 +47,21 @@ def init_admin(default_admin: Admin) -> Admin:
 def init_publisher(
     serializer: MessageSerializer, admin: Admin, default_publisher: Publisher
 ) -> Publisher:
-    if app_broker_type == "rabbitmq":
+    if APP_BROKER_TYPE == "rabbitmq":
         return RMQPublisher(
             logger=logger,
-            connection_string=app_rmq_connection_string,
+            connection_string=APP_RMQ_CONNECTION_STRING,
             serializer=serializer,
             rmq_admin=admin,
         )
-    if app_broker_type == "kafka":
+    if APP_BROKER_TYPE == "kafka":
         return KafkaPublisher(
             logger=logger,
-            bootstrap_servers=app_kafka_bootstrap_servers,
-            security_protocol=app_kafka_security_protocol,
-            sasl_mechanism=app_kafka_sasl_mechanism,
-            sasl_plain_username=app_kafka_sasl_user,
-            sasl_plain_password=app_kafka_sasl_pass,
+            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
+            security_protocol=APP_KAFKA_SECURITY_PROTOCOL,
+            sasl_mechanism=APP_KAFKA_SASL_MECHANISM,
+            sasl_plain_username=APP_KAFKA_SASL_USER,
+            sasl_plain_password=APP_KAFKA_SASL_PASS,
             serializer=serializer,
             kafka_admin=admin,
         )
@@ -71,22 +71,22 @@ def init_publisher(
 def init_consumer(
     serializer: MessageSerializer, admin: Admin, default_consumer: Consumer
 ) -> Consumer:
-    if app_broker_type == "rabbitmq":
+    if APP_BROKER_TYPE == "rabbitmq":
         return RMQConsumer(
             logger=logger,
-            connection_string=app_rmq_connection_string,
+            connection_string=APP_RMQ_CONNECTION_STRING,
             serializer=serializer,
             rmq_admin=admin,
         )
-    if app_broker_type == "kafka":
+    if APP_BROKER_TYPE == "kafka":
         return KafkaConsumer(
             logger=logger,
-            bootstrap_servers=app_kafka_bootstrap_servers,
-            security_protocol=app_kafka_security_protocol,
-            sasl_mechanism=app_kafka_sasl_mechanism,
-            sasl_plain_username=app_kafka_sasl_user,
-            sasl_plain_password=app_kafka_sasl_pass,
-            group_id=zrb_app_name,
+            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
+            security_protocol=APP_KAFKA_SECURITY_PROTOCOL,
+            sasl_mechanism=APP_KAFKA_SASL_MECHANISM,
+            sasl_plain_username=APP_KAFKA_SASL_USER,
+            sasl_plain_password=APP_KAFKA_SASL_PASS,
+            group_id=APP_NAME,
             serializer=serializer,
             kafka_admin=admin,
         )

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/rpc.py

@@ -1,10 +1,10 @@
 from component.messagebus import KafkaConsumer, RMQConsumer
 from component.rpc import Caller, MessagebusCaller, MessagebusServer, Server
 from config import (
-    app_broker_type,
-    app_kafka_bootstrap_servers,
-    app_rmq_connection_string,
-    zrb_app_name,
+    APP_BROKER_TYPE,
+    APP_KAFKA_BOOTSTRAP_SERVERS,
+    APP_NAME,
+    APP_RMQ_CONNECTION_STRING,
 )
 from integration.log import logger
 from integration.messagebus import (
@@ -18,20 +18,20 @@ from ulid import ULID
 
 
 def create_consumer():
-    if app_broker_type == "rabbitmq":
+    if APP_BROKER_TYPE == "rabbitmq":
         return RMQConsumer(
             logger=logger,
-            connection_string=app_rmq_connection_string,
+            connection_string=APP_RMQ_CONNECTION_STRING,
             serializer=message_serializer,
             rmq_admin=admin,
             identifier="rmq-rpc-reply-consumer",
         )
-    if app_broker_type == "kafka":
+    if APP_BROKER_TYPE == "kafka":
         random_uuid = str(ULID())
-        group_id = f"{zrb_app_name}-reply-{random_uuid}"
+        group_id = f"{APP_NAME}-reply-{random_uuid}"
         return KafkaConsumer(
             logger=logger,
-            bootstrap_servers=app_kafka_bootstrap_servers,
+            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
             group_id=group_id,
             serializer=message_serializer,
             kafka_admin=admin,

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/component/access_token/scheme.py

@@ -1,4 +1,5 @@
-from typing import Callable, Optional
+from collections.abc import Callable
+from typing import Optional
 
 from fastapi import Depends
 from fastapi.security import OAuth2PasswordBearer

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/component/access_token/util.py

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
+from collections.abc import Mapping
 from datetime import datetime, timedelta
-from typing import Any, Mapping
+from typing import Any
 
 import jsons
 from component.error import HTTPAPIException

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/entity/group/repo.py

@@ -1,5 +1,6 @@
 from abc import ABC
-from typing import Any, Mapping
+from collections.abc import Mapping
+from typing import Any
 
 from component.repo import DBEntityMixin, DBRepo, Repo
 from module.auth.entity.permission.repo import DBEntityPermission

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/entity/group/rpc.py

@@ -1,5 +1,6 @@
+from collections.abc import Mapping
 from logging import Logger
-from typing import Any, Mapping
+from typing import Any
 
 from component.messagebus import Publisher
 from component.repo import SearchFilter

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/entity/permission/rpc.py

@@ -1,5 +1,6 @@
+from collections.abc import Mapping
 from logging import Logger
-from typing import Any, Mapping
+from typing import Any
 
 from component.messagebus import Publisher
 from component.repo import SearchFilter

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/entity/user/api.py

@@ -1,5 +1,6 @@
+from collections.abc import Mapping
 from logging import Logger
-from typing import Annotated, List, Mapping
+from typing import Annotated
 
 from component.error import HTTPAPIException
 from component.messagebus import Publisher

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/entity/user/model.py

@@ -1,4 +1,5 @@
-from typing import List, Mapping, Optional
+from collections.abc import Mapping
+from typing import Optional
 
 from component.messagebus.messagebus import Publisher
 from module.auth.component import AccessTokenUtil, RefreshTokenUtil
@@ -81,7 +82,7 @@ class UserModel(HistoricalRepoModel[User, UserData, UserResult]):
             for permission_name in permission_names
         }
 
-    def _get_permission_names(self, user: User) -> List[str]:
+    def _get_permission_names(self, user: User) -> list[str]:
         permission_names = [permission.name for permission in user.permissions]
         for group in user.groups:
             additional_permission_names = [

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/entity/user/repo.py

@@ -1,6 +1,7 @@
 import logging
 from abc import ABC, abstractmethod
-from typing import Any, List, Mapping
+from collections.abc import Mapping
+from typing import Any
 
 from component.repo import DBEntityMixin, DBRepo, Repo
 from module.auth.component import PasswordHasher
@@ -46,7 +47,7 @@ class UserDBRepo(DBRepo[User, UserData], UserRepo):
 
     async def get_by_user_login(self, user_login: UserLogin) -> User:
         db = self._get_db_session()
-        db_users: List[DBEntityUser] = []
+        db_users: list[DBEntityUser] = []
         try:
             search_filter = or_(
                 DBEntityUser.username == user_login.identity,

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/entity/user/rpc.py

@@ -1,5 +1,6 @@
+from collections.abc import Mapping
 from logging import Logger
-from typing import Any, List, Mapping, Union
+from typing import Any, Union
 
 from component.messagebus import Publisher
 from component.repo import SearchFilter
@@ -30,7 +31,7 @@ def register_rpc(
 
     @rpc_server.register("auth_is_user_authorized")
     async def is_user_having_permission(
-        id: str, permission_name: Union[str, List[str]]
+        id: str, permission_name: Union[str, list[str]]
     ) -> Mapping[str, bool]:
         """
         Used by RPC Authenticator

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/integration/access_token_scheme.py

@@ -1,4 +1,4 @@
-from config import app_auth_access_token_cookie_key
+from config import APP_AUTH_ACCESS_TOKEN_COOKIE_KEY
 from module.auth.component import (
     AccessTokenScheme,
     create_oauth2_bearer_access_token_scheme,
@@ -11,6 +11,6 @@ access_token_scheme: AccessTokenScheme = (
         guest_user=guest_user,
         access_token_util=access_token_util,
         token_url="/api/v1/auth/login-oauth",
-        token_cookie_key=app_auth_access_token_cookie_key,
+        token_cookie_key=APP_AUTH_ACCESS_TOKEN_COOKIE_KEY,
     )
 )

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/integration/access_token_util.py

@@ -1,18 +1,18 @@
 from config import (
-    app_auth_access_token_type,
-    app_auth_jwt_token_algorithm,
-    app_auth_jwt_token_secret_key,
+    APP_AUTH_ACCESS_TOKEN_TYPE,
+    APP_AUTH_JWT_TOKEN_ALGORITHM,
+    APP_AUTH_JWT_TOKEN_SECRET_KEY,
 )
 from module.auth.component import AccessTokenUtil, JWTAccessTokenUtil
 
 
 def init_token_util() -> AccessTokenUtil:
-    if app_auth_access_token_type.lower() == "jwt":
+    if APP_AUTH_ACCESS_TOKEN_TYPE.lower() == "jwt":
         return JWTAccessTokenUtil(
-            secret_key=app_auth_jwt_token_secret_key,
-            algorithm=app_auth_jwt_token_algorithm,
+            secret_key=APP_AUTH_JWT_TOKEN_SECRET_KEY,
+            algorithm=APP_AUTH_JWT_TOKEN_ALGORITHM,
         )
-    raise ValueError(f"Invalid auth token type: {app_auth_access_token_type}")
+    raise ValueError(f"Invalid auth token type: {APP_AUTH_ACCESS_TOKEN_TYPE}")
 
 
 access_token_util = init_token_util()

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/integration/model/user_model.py

@@ -1,7 +1,7 @@
 from config import (
-    app_auth_access_token_expire_seconds,
-    app_auth_admin_active,
-    app_auth_refresh_token_expire_seconds,
+    APP_AUTH_ACCESS_TOKEN_EXPIRE_SECONDS,
+    APP_AUTH_ADMIN_ACTIVE,
+    APP_AUTH_REFRESH_TOKEN_EXPIRE_SECONDS,
 )
 from integration.messagebus import publisher
 from module.auth.entity.user.model import UserModel
@@ -15,10 +15,10 @@ user_model: UserModel = UserModel(
     publisher=publisher,
     permission_model=permission_model,
     access_token_util=access_token_util,
-    access_token_expire_seconds=app_auth_access_token_expire_seconds,
+    access_token_expire_seconds=APP_AUTH_ACCESS_TOKEN_EXPIRE_SECONDS,
     refresh_token_util=refresh_token_util,
-    refresh_token_expire_seconds=app_auth_refresh_token_expire_seconds,
+    refresh_token_expire_seconds=APP_AUTH_REFRESH_TOKEN_EXPIRE_SECONDS,
     guest_user=guest_user,
-    admin_user=admin_user if app_auth_admin_active else None,
+    admin_user=admin_user if APP_AUTH_ADMIN_ACTIVE else None,
     admin_user_password=admin_user_password,
 )

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/integration/refresh_token_util.py

@@ -1,18 +1,18 @@
 from config import (
-    app_auth_jwt_token_algorithm,
-    app_auth_jwt_token_secret_key,
-    app_auth_refresh_token_type,
+    APP_AUTH_JWT_TOKEN_ALGORITHM,
+    APP_AUTH_JWT_TOKEN_SECRET_KEY,
+    APP_AUTH_REFRESH_TOKEN_TYPE,
 )
 from module.auth.component import JWTRefreshTokenUtil, RefreshTokenUtil
 
 
 def init_token_util() -> RefreshTokenUtil:
-    if app_auth_refresh_token_type.lower() == "jwt":
+    if APP_AUTH_REFRESH_TOKEN_TYPE.lower() == "jwt":
         return JWTRefreshTokenUtil(
-            secret_key=app_auth_jwt_token_secret_key,
-            algorithm=app_auth_jwt_token_algorithm,
+            secret_key=APP_AUTH_JWT_TOKEN_SECRET_KEY,
+            algorithm=APP_AUTH_JWT_TOKEN_ALGORITHM,
         )
-    raise ValueError(f"Invalid auth token type: {app_auth_refresh_token_type}")
+    raise ValueError(f"Invalid auth token type: {APP_AUTH_REFRESH_TOKEN_TYPE}")
 
 
 refresh_token_util = init_token_util()