feat(Internal): Apply SOLID principles to project_io.py and forge.py (#65)

Author: mslaursen

fastapi_forge/__main__.py

@@ -3,7 +3,10 @@
 import click
 
 from fastapi_forge.frontend.main import init
-from fastapi_forge.project_io import ProjectLoader
+from fastapi_forge.io import (
+    YamlProjectLoader,
+    create_postgres_project_loader,
+)
 
 
 @click.group()
@@ -38,7 +41,6 @@ def start(
     from_yaml: str | None = None,
     conn_string: str | None = None,
 ) -> None:
-    """Start the FastAPI Forge server and generate a new project."""
     option_count = sum([use_example, bool(from_yaml), bool(conn_string)])
     if option_count > 1:
         msg = "Only one of '--use-example', '--from-yaml', or '--conn-string' can be used."
@@ -54,16 +56,14 @@ def start(
         yaml_path = Path(from_yaml).expanduser().resolve()
         if not yaml_path.is_file():
             raise click.FileError(f"YAML file not found: {yaml_path}")
-        project_spec = ProjectLoader(project_path=yaml_path).load()
+        project_spec = YamlProjectLoader(project_path=yaml_path).load()
     elif conn_string:
-        project_spec = ProjectLoader.load_from_conn_string(
-            conn_string=conn_string,
-        )
+        project_spec = create_postgres_project_loader(conn_string).load()
     elif use_example:
         base_path = Path(__file__).parent / "example-projects"
         path = base_path / "game_zone.yaml"
 
-        project_spec = ProjectLoader(project_path=path).load()
+        project_spec = YamlProjectLoader(project_path=path).load()
 
     init(project_spec=project_spec, no_ui=no_ui)
 

fastapi_forge/core/__init__.py

@@ -0,0 +1,9 @@
+__all__ = [
+    "CookiecutterAdapter",
+    "OverwriteCookiecutterAdapter",
+    "ProjectBuildDirector",
+    "build_fastapi_project",
+]
+
+from .build import ProjectBuildDirector, build_fastapi_project
+from .cookiecutter_adapter import CookiecutterAdapter, OverwriteCookiecutterAdapter

fastapi_forge/core/build.py

@@ -0,0 +1,72 @@
+from collections.abc import Callable
+from pathlib import Path
+from time import perf_counter
+
+from fastapi_forge.io import ArtifactBuilder, create_fastapi_project_builder
+from fastapi_forge.logger import logger
+from fastapi_forge.schemas import ProjectSpec
+
+from .cookiecutter_adapter import CookiecutterAdapter, OverwriteCookiecutterAdapter
+from .project_validators import ProjectNameValidator, ProjectValidator
+from .template_processors import DefaultTemplateProcessor, TemplateProcessor
+
+
+class ProjectBuildDirector:
+    def __init__(
+        self,
+        builder: ArtifactBuilder,
+        template_processor: TemplateProcessor,
+        template_generator: CookiecutterAdapter,
+        template_resolver: Callable,
+        project_validator: ProjectValidator | None = None,
+    ):
+        self.builder = builder
+        self.validator = project_validator
+        self.template_processor = template_processor
+        self.template_generator = template_generator
+        self.template_resolver = template_resolver
+
+    async def build(self, spec: ProjectSpec) -> None:
+        if self.validator:
+            self.validator.validate(spec)
+        await self.builder.build_artifacts()
+
+        context = self.template_processor.process(spec)
+        template_path = self.template_resolver()
+
+        self.template_generator.generate(
+            template_path=template_path,
+            output_dir=Path.cwd().resolve(),
+            extra_context=context,
+        )
+
+
+def _get_template_path() -> Path:
+    template_path = Path(__file__).resolve().parent.parent / "template"
+    if not template_path.exists():
+        raise RuntimeError(f"Template directory not found: {template_path}")
+    if not template_path.is_dir():
+        raise RuntimeError(f"Template path is not a directory: {template_path}")
+    return template_path
+
+
+async def build_fastapi_project(spec: ProjectSpec) -> None:
+    start_time = perf_counter()
+
+    try:
+        director = ProjectBuildDirector(
+            builder=create_fastapi_project_builder(spec),
+            project_validator=ProjectNameValidator(),
+            template_processor=DefaultTemplateProcessor(),
+            template_generator=OverwriteCookiecutterAdapter(),
+            template_resolver=_get_template_path,
+        )
+
+        await director.build(spec)
+
+        build_time = perf_counter() - start_time
+        logger.info(f"Project built successfully in {build_time:.2f} seconds.")
+
+    except Exception as error:
+        logger.error(f"Project build failed: {error}")
+        raise

fastapi_forge/core/cookiecutter_adapter/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ["CookiecutterAdapter", "OverwriteCookiecutterAdapter"]
+
+from .adapters import OverwriteCookiecutterAdapter
+from .protocols import CookiecutterAdapter

fastapi_forge/core/cookiecutter_adapter/adapters.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+from typing import Any
+
+from cookiecutter.main import cookiecutter
+
+from .protocols import CookiecutterAdapter
+
+
+class OverwriteCookiecutterAdapter(CookiecutterAdapter):
+    def generate(
+        self,
+        template_path: Path,
+        output_dir: Path,
+        extra_context: dict[str, Any] | None = None,
+    ) -> None:
+        cookiecutter(
+            template=str(template_path),
+            output_dir=str(output_dir),
+            no_input=True,
+            overwrite_if_exists=True,
+            extra_context=extra_context,
+        )

fastapi_forge/core/cookiecutter_adapter/protocols.py

@@ -0,0 +1,14 @@
+from abc import abstractmethod
+from pathlib import Path
+from typing import Any, Protocol
+
+
+class CookiecutterAdapter(Protocol):
+    @abstractmethod
+    def generate(
+        self,
+        template_path: Path,
+        output_dir: Path,
+        extra_context: dict[str, Any] | None = None,
+    ) -> None:
+        raise NotImplementedError

fastapi_forge/core/project_validators/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ["ProjectNameValidator", "ProjectValidator"]
+
+from .protocols import ProjectValidator
+from .validators import ProjectNameValidator

fastapi_forge/core/project_validators/protocols.py

@@ -0,0 +1,10 @@
+from abc import abstractmethod
+from typing import Protocol
+
+from fastapi_forge.schemas import ProjectSpec
+
+
+class ProjectValidator(Protocol):
+    @abstractmethod
+    def validate(self, project_spec: ProjectSpec) -> None:
+        raise NotImplementedError

fastapi_forge/core/project_validators/validators.py

@@ -0,0 +1,26 @@
+from pathlib import PurePath
+
+from fastapi_forge.schemas import ProjectSpec
+
+from .protocols import ProjectValidator
+
+
+class ProjectNameValidator(ProjectValidator):
+    def validate(self, project_spec: ProjectSpec) -> None:
+        project_name = project_spec.project_name
+
+        if not project_name:
+            msg = "Project name cannot be empty"
+            raise ValueError(msg)
+        if not project_name.isidentifier():
+            raise ValueError(
+                f"Invalid project name: {project_name}. Must be a valid identifier."
+            )
+
+        if PurePath(project_name).is_absolute():
+            raise ValueError(
+                f"Project name cannot be an absolute path: {project_name}."
+            )
+
+        if not project_name.isascii():
+            raise ValueError(f"Project name must be ASCII: {project_name}.")

fastapi_forge/core/template_processors/__init__.py

@@ -0,0 +1,7 @@
+__all__ = [
+    "DefaultTemplateProcessor",
+    "TemplateProcessor",
+]
+
+from .processors import DefaultTemplateProcessor
+from .protocols import TemplateProcessor