Fin

Author: mslaursen

fastapi_forge/frontend/panels/project_config_panel.py

@@ -197,7 +197,7 @@ def _handle_builtin_auth_change(self, event: ValueChangeEventArguments) -> None:
                 state.render_models_fn()
             ui.notify("The 'auth_user' model has been deleted.", type="positive")
 
-    async def _warn_override(self) -> bool:
+    async def _warn_overwrite(self) -> bool:
         """Show a confirmation dialog if the project already exists."""
         dialog = ui.dialog()
         with dialog, ui.card().classes("w-full max-w-md p-6 text-center"):
@@ -222,8 +222,8 @@ async def _create_project(self) -> None:
 
         if project_path.exists():
             try:
-                override = await self._warn_override()
-                if not override:
+                overwrite = await self._warn_overwrite()
+                if not overwrite:
                     ui.notify("Project generation cancelled.", type="warning")
                     return
             except Exception as e:

fastapi_forge/template/hooks/post_gen_project.py

@@ -2,98 +2,112 @@
 import yaml
 import os
 import shutil
-from typing import Any
 from fastapi_forge.logger import logger
 
 
-def git_init() -> None:
-    subprocess.run(["git", "init"])
-    subprocess.run(["git", "add", "."])
+def run_command(command: list[str]) -> None:
+    subprocess.run(command, check=True)
 
 
 def uv_init() -> None:
-    subprocess.run(["uv", "lock"])
+    run_command(["uv", "lock"])
 
 
 def lint() -> None:
-    subprocess.run(["make", "lint"])
+    run_command(["make", "lint"])
 
 
 def make_env() -> None:
-    subprocess.run(["cp", ".env.example", ".env"])
+    run_command(["cp", ".env.example", ".env"])
+
+
+def _process_paths(paths: list[str], cwd: str) -> tuple[list[str], list[str]]:
+    files = []
+    folders = []
+    for path in paths:
+        if not path:
+            continue
+        full_path = os.path.join(cwd, path)
+        if path.endswith((".py", ".yaml")):
+            files.append(full_path)
+        else:
+            folders.append(full_path)
+    return files, folders
 
 
 def _get_delete_flagged() -> tuple[list[str], list[str]]:
-    conf_fn = "forge-config.yaml"
-    with open(conf_fn) as stream:
-        y = yaml.safe_load(stream)
-        cwd = os.getcwd()
-        files = [os.path.join(cwd, conf_fn)]
-        folders = []
-        config: dict[str, Any] = y["config"]
-
-        for _, v in config.items():
-            item_type = v["type"]
-            if item_type != "bool":
-                continue
-            value: bool = v["value"]
-            if value is True:
-                continue
-            paths: list[str] = v["paths"]
-            if not paths:
-                continue
-            for path in paths:
-                full_path = os.path.join(cwd, path)
-                if path.endswith(".py") or path.endswith(".yaml"):
-                    files.append(full_path)
-                else:
-                    folders.append(full_path)
+    files = []
+    folders = []
+    cwd = os.getcwd()
+
+    try:
+        with open("forge-config.yaml") as stream:
+            config = yaml.safe_load(stream) or {}
+            paths_config = config.get("paths", {})
+
+            for item in paths_config.values():
+                if "enabled" in item and not item["enabled"]:
+                    new_files, new_folders = _process_paths(item.get("paths", []), cwd)
+                    files.extend(new_files)
+                    folders.extend(new_folders)
+
+                if "requires_all" in item:
+                    conditions_met = all(
+                        paths_config.get(req, {}).get("enabled", False) is False
+                        for req in item["requires_all"]
+                    )
+                    if conditions_met:
+                        new_files, new_folders = _process_paths(
+                            item.get("paths", []), cwd
+                        )
+                        files.extend(new_files)
+                        folders.extend(new_folders)
+
+    except Exception as e:
+        logger.error(f"Error reading config file: {e}")
 
     return files, folders
 
 
-def delete_empty_init_folders(root_dir: str = "src") -> None:
-    """Delete folders that only contain empty __init__.py files."""
-    for dirpath, dirnames, filenames in os.walk(root_dir, topdown=False):
-        if dirpath == root_dir:
-            continue
+def _is_empty_init(dirpath: str) -> bool:
+    init_file = os.path.join(dirpath, "__init__.py")
+    try:
+        with open(init_file, "r") as f:
+            return not any(
+                line.strip() and not line.strip().startswith("#")
+                for line in f.read().splitlines()
+            )
+    except OSError:
+        return False
 
-        if set(filenames) == {"__init__.py"} and not dirnames:
-            init_file = os.path.join(dirpath, "__init__.py")
 
-            try:
-                with open(init_file, "r") as f:
-                    content = f.read()
-                    has_code = any(
-                        line.strip() and not line.strip().startswith("#")
-                        for line in content.splitlines()
-                    )
-                if not has_code:
-                    os.remove(init_file)
-                    os.rmdir(dirpath)
-                    logger.info(f"Deleted empty package: {dirpath}")
-                else:
-                    logger.info(f"Keeping package with code: {dirpath}")
-            except OSError as exc:
-                logger.info(f"Error processing package {dirpath}: {exc}")
+def delete_empty_init_folders(root_dir: str = "src") -> None:
+    for dirpath, dirnames, filenames in os.walk(root_dir, topdown=False):
+        if dirpath != root_dir and set(filenames) == {"__init__.py"} and not dirnames:
+            if _is_empty_init(dirpath):
+                os.remove(os.path.join(dirpath, "__init__.py"))
+                os.rmdir(dirpath)
+                logger.info(f"Deleted empty package: {dirpath}")
 
 
-def cleanup():
+def cleanup() -> None:
     files, folders = _get_delete_flagged()
 
-    for file_path in files:
+    for path in files:
         try:
-            os.remove(file_path)
-            logger.info(f"Deleted file: {file_path}")
+            if os.path.exists(path):
+                os.remove(path)
+                logger.info(f"Deleted file: {path}")
         except OSError as exc:
-            logger.info(f"Error deleting file {file_path}: {exc}")
+            logger.error(f"Error deleting file {path}: {exc}")
 
-    for folder_path in folders:
+    for path in folders:
         try:
-            shutil.rmtree(folder_path)
-            logger.info(f"Deleted folder: {folder_path}")
+            if os.path.exists(path):
+                shutil.rmtree(path)
+                logger.info(f"Deleted folder: {path}")
         except OSError as exc:
-            logger.info(f"Error deleting folder {folder_path}: {exc}")
+            logger.error(f"Error deleting folder {path}: {exc}")
 
     delete_empty_init_folders()
 
@@ -103,4 +117,3 @@ def cleanup():
     uv_init()
     make_env()
     lint()
-    # git_init()

fastapi_forge/template/{{cookiecutter.project_name}}/docker-compose.yaml

@@ -9,6 +9,7 @@ services:
       - "8000:8000"
     env_file:
       - .env
+    {%- if cookiecutter.use_postgres or cookiecutter.use_redis or cookiecutter.use_rabbitmq %}
     depends_on:
       {%- if cookiecutter.use_postgres %}
       postgres:
@@ -18,6 +19,11 @@ services:
       redis:
         condition: service_healthy
       {%- endif %}
+      {%- if cookiecutter.use_rabbitmq %}
+      rabbitmq:
+        condition: service_healthy
+      {%- endif %}
+    {%- endif %}
     environment:
       {{ cookiecutter.project_name|upper|replace('-', '_') }}_RELOAD: "True"
       {{ cookiecutter.project_name|upper|replace('-', '_') }}_SERVER_HOST: 0.0.0.0
@@ -119,6 +125,7 @@ services:
     volumes:
       - {{ cookiecutter.project_name }}-rabbitmq-data:/var/lib/rabbitmq
   {% endif %}
+{%- if cookiecutter.use_postgres or cookiecutter.use_redis or cookiecutter.use_rabbitmq %}
 volumes:
   {%- if cookiecutter.use_postgres %}
   {{ cookiecutter.project_name }}-pg-data:
@@ -131,4 +138,5 @@ volumes:
   {%- if cookiecutter.use_rabbitmq -%}
   {{ cookiecutter.project_name }}-rabbitmq-data:
     name: {{ cookiecutter.project_name }}-rabbitmq-data
-  {% endif %}
+  {% endif %}
+{%- endif %}

fastapi_forge/template/{{cookiecutter.project_name}}/forge-config.yaml

@@ -1,38 +1,38 @@
-# Used for post project generation tasks.
+# Used for post project generation tasks
 # You may delete this file!
 
-config:
+paths:
   use_postgres:
-    value: {{cookiecutter.use_postgres | lower}}
-    type: bool
-    paths:
-
+    enabled: {{cookiecutter.use_postgres | lower}}
+    paths: []
+    
   use_alembic:
-    value: {{cookiecutter.use_alembic | lower}}
-    type: bool
+    enabled: {{cookiecutter.use_alembic | lower}}
     paths:
       - migrations
 
   use_builtin_auth:
-    value: {{cookiecutter.use_builtin_auth | lower}}
-    type: bool
+    enabled: {{cookiecutter.use_builtin_auth | lower}}
     paths:
       - src/dependencies/auth_dependencies.py
       - src/dtos/auth_dtos.py
       - src/routes/auth_routes.py
       - src/utils/auth_utils.py
-      - src/constants.py
 
   use_redis:
-    value: {{cookiecutter.use_redis | lower}}
-    type: bool
+    enabled: {{cookiecutter.use_redis | lower}}
     paths:
       - src/services/redis
 
   use_rabbitmq:
-    value: {{cookiecutter.use_rabbitmq | lower}}
-    type: bool
+    enabled: {{cookiecutter.use_rabbitmq | lower}}
     paths:
       - src/services/rabbitmq
       - src/routes/demo_routes.py
 
+  constants:
+    requires_all:
+      - use_builtin_auth
+      - use_rabbitmq
+    paths:
+      - src/constants.py

fastapi_forge/template/{{cookiecutter.project_name}}/src/dependencies/auth_dependencies.py

@@ -1,3 +1,4 @@
+{% if cookiecutter.use_builtin_auth %}
 from typing import Annotated
 
 from fastapi import Depends, HTTPException, Request
@@ -53,3 +54,4 @@ async def get_current_user(
 
 
 GetCurrentUser = Annotated[{{ cookiecutter.auth_model.name_cc }}DTO, Depends(get_current_user)]
+{% endif %}

fastapi_forge/template/{{cookiecutter.project_name}}/src/main.py

@@ -6,13 +6,13 @@
 from src.settings import settings
 from src.routes import base_router
 from src.middleware import add_middleware
-{%- if cookiecutter.use_postgres %}
+{% if cookiecutter.use_postgres %}
 from src.db import db_lifetime
 {% endif %}
-{%- if cookiecutter.use_redis -%}
+{% if cookiecutter.use_redis -%}
 from src.services.redis import redis_lifetime
 {% endif %}
-{%- if cookiecutter.use_rabbitmq -%}
+{% if cookiecutter.use_rabbitmq -%}
 from src.services.rabbitmq import rabbitmq_lifetime
 from src.constants import QUEUE_CONFIGS
 {% endif %}

fastapi_forge/template/{{cookiecutter.project_name}}/src/routes/demo_routes.py

@@ -1,20 +1,45 @@
 from fastapi import APIRouter
 from src import exceptions
 from src.services.redis import GetRedis
+{% if cookiecutter.use_rabbitmq %}
+from src.services.rabbitmq import GetRabbitMQ
+{% endif %}
+from pydantic import BaseModel
+from typing import Any
 
 router = APIRouter(prefix="/demo")
 
+{% if cookiecutter.use_rabbitmq %}
+class RabbitMQDemoMessage(BaseModel):
+    key: str
+    value: str
+{% endif %}
+
 {% if cookiecutter.use_redis %}
 @router.post("/set-redis")
-async def set_redis_value(key: str, value: str, redis: GetRedis) -> dict[str, str]:
+async def set_redis_value(key: str, value: str, redis: GetRedis,) -> dict[str, Any]:
     await redis.set(key, value)
     return {"message": "Value set successfully", "key": key, "value": value}
 
 
 @router.get("/get-redis")
-async def get_redis_value(key: str, redis: GetRedis) -> dict[str, str]:
+async def get_redis_value(key: str, redis: GetRedis,) -> dict[str, Any]:
     value = await redis.get(key)
     if value is None:
         raise exceptions.Http404(detail="Key not found in Redis")
     return {"key": key, "value": value}
+{% endif %}
+
+{% if cookiecutter.use_rabbitmq %}
+@router.post("/send-rabbitmq")
+async def send_rabbitmq_message(
+    message: RabbitMQDemoMessage,
+    rabbitmq: GetRabbitMQ,
+) -> dict[str, Any]:
+    await rabbitmq.send_demo_message(message)
+    return {
+        "message": "RabbitMQ message sent successfully",
+        "key": message.key,
+        "value": message.value,
+    }
 {% endif %}

fastapi_forge/template/{{cookiecutter.project_name}}/src/services/rabbitmq/__init__.py

@@ -0,0 +1,3 @@
+from src.services.rabbitmq.rabbitmq_dependencies import GetRabbitMQ
+
+__all__ = ["GetRabbitMQ"]