zrb 0.23.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

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

@@ -1,28 +1,29 @@
 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
 from fastapi.responses import JSONResponse
-from integration.app_lifespan import app_lifespan, app_state
+from integration.app.app_lifespan import app_lifespan
+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):
@@ -37,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,
 )
 
 
@@ -59,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"},
@@ -80,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"},
@@ -92,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_lifespan.py → app/app_lifespan.py}

@@ -2,17 +2,17 @@ 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
 from helper.async_task import create_task
-from integration.app_state import app_state, set_not_ready_on_error
+from integration.app.app_state import app_state, set_not_ready_on_error
 from integration.log import logger
 from integration.messagebus import consumer
 from integration.rpc import rpc_server
@@ -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_state.py → 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/main.py

@@ -1,9 +1,7 @@
-from integration.app import app
+from integration.app.app import app
 from module.auth.register_module import register_auth
 from module.log.register_module import register_log
 
-# Make sure app is loaded.
-# Uvicorn or adny ASGII server you use will pick it up and run the app.
 assert app
 register_auth()
 register_log()

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()

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

@@ -1,33 +1,33 @@
 from config import (
-    app_auth_admin_email,
-    app_auth_admin_password,
-    app_auth_admin_phone,
-    app_auth_admin_user_id,
-    app_auth_admin_username,
-    app_auth_guest_email,
-    app_auth_guest_phone,
-    app_auth_guest_user_id,
-    app_auth_guest_username,
+    APP_AUTH_ADMIN_EMAIL,
+    APP_AUTH_ADMIN_PASSWORD,
+    APP_AUTH_ADMIN_PHONE,
+    APP_AUTH_ADMIN_USER_ID,
+    APP_AUTH_ADMIN_USERNAME,
+    APP_AUTH_GUEST_EMAIL,
+    APP_AUTH_GUEST_PHONE,
+    APP_AUTH_GUEST_USER_ID,
+    APP_AUTH_GUEST_USERNAME,
 )
 from module.auth.schema.user import User
 
-admin_user_password = app_auth_admin_password
+admin_user_password = APP_AUTH_ADMIN_PASSWORD
 
 admin_user = User(
-    id=app_auth_admin_user_id,
-    username=app_auth_admin_username,
-    email=app_auth_admin_email,
-    phone=app_auth_admin_phone,
+    id=APP_AUTH_ADMIN_USER_ID,
+    username=APP_AUTH_ADMIN_USERNAME,
+    email=APP_AUTH_ADMIN_EMAIL,
+    phone=APP_AUTH_ADMIN_PHONE,
     groups=[],
     permissions=[],
     description="System administrator",
 )
 
 guest_user = User(
-    id=app_auth_guest_user_id,
-    username=app_auth_guest_username,
-    email=app_auth_guest_email,
-    phone=app_auth_guest_phone,
+    id=APP_AUTH_GUEST_USER_ID,
+    username=APP_AUTH_GUEST_USERNAME,
+    email=APP_AUTH_GUEST_EMAIL,
+    phone=APP_AUTH_GUEST_PHONE,
     groups=[],
     permissions=[],
     description="Visitor",

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

@@ -1,4 +1,4 @@
-from config import app_enable_auth_module
+from config import APP_ENABLE_AUTH_MODULE
 from helper.migration import migrate
 from integration.db_connection import engine
 from integration.log import logger
@@ -7,7 +7,7 @@ from module.auth.register_permission import register_permission
 
 
 async def migrate_auth():
-    if not app_enable_auth_module:
+    if not APP_ENABLE_AUTH_MODULE:
         logger.info('🥪 Skip DB migration for "auth"')
         return
     logger.info('🥪 Perform DB migration for "auth"')

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

@@ -1,10 +1,10 @@
 from config import (
-    app_enable_api,
-    app_enable_auth_module,
-    app_enable_event_handler,
-    app_enable_rpc_server,
+    APP_ENABLE_API,
+    APP_ENABLE_AUTH_MODULE,
+    APP_ENABLE_EVENT_HANDLER,
+    APP_ENABLE_RPC_SERVER,
 )
-from integration.app import app
+from integration.app.app import app
 from integration.log import logger
 from integration.messagebus import consumer, publisher
 from integration.rpc import rpc_caller, rpc_server
@@ -15,10 +15,10 @@ from module.auth.rpc import register_rpc
 
 
 def register_auth():
-    if not app_enable_auth_module:
+    if not APP_ENABLE_AUTH_MODULE:
         logger.info('🥪 Skip registering "auth"')
         return
-    if app_enable_api:
+    if APP_ENABLE_API:
         register_api(
             logger=logger,
             app=app,
@@ -26,11 +26,11 @@ def register_auth():
             rpc_caller=rpc_caller,
             publisher=publisher,
         )
-    if app_enable_event_handler:
+    if APP_ENABLE_EVENT_HANDLER:
         register_event(
             logger=logger, consumer=consumer, rpc_caller=rpc_caller, publisher=publisher
         )
-    if app_enable_rpc_server:
+    if APP_ENABLE_RPC_SERVER:
         register_rpc(
             logger=logger,
             rpc_server=rpc_server,

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

@@ -1,4 +1,4 @@
-from config import app_enable_log_module
+from config import APP_ENABLE_LOG_MODULE
 from helper.migration import migrate
 from integration.db_connection import engine
 from integration.log import logger
@@ -6,7 +6,7 @@ from module.log.integration import Base
 
 
 async def migrate_log():
-    if not app_enable_log_module:
+    if not APP_ENABLE_LOG_MODULE:
         logger.info('🥪 Skip DB migration for "log"')
         return
     logger.info('🥪 Perform DB migration for "log"')