[FIX] fix hardcoded dockerfile generator

Author: bnbong

src/fastapi_fastkit/backend/project_builder/config_generator.py

@@ -447,12 +447,20 @@ def _generate_fastapi_users_config(self) -> str:
 
         return "\n".join(content)
 
-    def generate_docker_files(self) -> None:
-        """Generate Dockerfile and docker-compose.yml."""
+    def generate_docker_files(self, app_module: str = "src.main:app") -> None:
+        """Generate Dockerfile and docker-compose.yml.
+
+        The ``app_module`` is the ``module:attr`` string baked into the
+        Dockerfile's ``CMD`` (and into docker-compose's `command` if the
+        compose generator ever needs it). Architecture presets that put
+        the FastAPI app at a non-default location (e.g. ``domain-starter``
+        ships ``src/app/main.py``) must pass the matching dotted path so
+        the generated container actually starts.
+        """
         deployment = self.config.get("deployment", [])
 
         if "Docker" in deployment:
-            dockerfile_content = self._generate_dockerfile()
+            dockerfile_content = self._generate_dockerfile(app_module=app_module)
             dockerfile_path = self.project_dir / "Dockerfile"
             with open(dockerfile_path, "w") as f:
                 f.write(dockerfile_content)
@@ -463,8 +471,8 @@ def generate_docker_files(self) -> None:
             with open(compose_path, "w") as f:
                 f.write(compose_content)
 
-    def _generate_dockerfile(self) -> str:
-        """Generate Dockerfile content."""
+    def _generate_dockerfile(self, app_module: str = "src.main:app") -> str:
+        """Generate Dockerfile content with a layout-aware uvicorn target."""
         content = []
         content.append(
             "# --------------------------------------------------------------------------"
@@ -487,7 +495,7 @@ def _generate_dockerfile(self) -> str:
         content.append("")
         content.append("# Run application")
         content.append(
-            'CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8000"]'
+            f'CMD ["uvicorn", "{app_module}", "--host", "0.0.0.0", "--port", "8000"]'
         )
         content.append("")
 

src/fastapi_fastkit/backend/project_builder/preset_layout.py

@@ -130,6 +130,21 @@ def main_py_target(self, project_dir: str) -> Path:
         """Absolute path where the dynamic main.py overlay should land."""
         return Path(project_dir) / self.profile.main_py_relpath
 
+    @property
+    def app_module(self) -> str:
+        """Return the ``module:attr`` string uvicorn / Docker should target.
+
+        Derived from ``main_py_relpath`` so docker generation, runserver,
+        and any future container-orchestration code all agree on the
+        entrypoint a given preset produces.
+        """
+        # Strip the trailing ``.py`` and convert path separators to dots.
+        relpath = self.profile.main_py_relpath
+        if relpath.endswith(".py"):
+            relpath = relpath[: -len(".py")]
+        module_part = relpath.replace("/", ".").replace("\\", ".")
+        return f"{module_part}:app"
+
     def db_config_target(self, project_dir: str) -> Path:
         """Absolute path for the generated database config module."""
         return Path(project_dir) / self.profile.db_config_relpath

src/fastapi_fastkit/cli.py

@@ -8,7 +8,6 @@
 import shutil
 import subprocess
 import sys
-from pathlib import Path
 from typing import Union, cast
 
 import click
@@ -486,12 +485,14 @@ def init(
             # placeholder app (minimal, single-module). For richer presets
             # (classic-layered, domain-starter) we keep the template's
             # router-aware main.py intact.
+            #
+            # The strategist's ``main_py_target`` is always ``src/main.py``
+            # for both regenerate-main presets, and both fastapi-empty and
+            # fastapi-single-module ship that file, so we can write
+            # straight to the strategist's path without a flat-``main.py``
+            # fallback branch.
             if strategist.should_regenerate_main:
                 main_py_path = strategist.main_py_target(project_dir)
-                if not main_py_path.exists():
-                    fallback = Path(project_dir) / "main.py"
-                    if fallback.exists():
-                        main_py_path = fallback
                 main_py_path.parent.mkdir(parents=True, exist_ok=True)
                 main_py_path.write_text(generator.generate_main_py())
             else:
@@ -531,7 +532,12 @@ def init(
             # Generate Docker files if deployment selected
             deployment = config.get("deployment", [])
             if deployment and deployment != ["None"]:
-                generator.generate_docker_files()
+                # Thread the preset-aware app module so the generated
+                # Dockerfile's ``CMD ["uvicorn", "<module>:app", ...]``
+                # matches the layout the user actually generated. Default
+                # ``src.main:app`` only works for minimal / single-module /
+                # classic-layered; domain-starter needs ``src.app.main:app``.
+                generator.generate_docker_files(app_module=strategist.app_module)
                 print_success("Generated Docker deployment files")
 
             # Surface preset-specific warnings (e.g. "you picked a preset

tests/test_backends/test_preset_layout.py

@@ -123,6 +123,25 @@ def test_targets_match_documented_matrix(
         assert strategist.auth_config_target(project) == Path(project) / expected_auth
 
 
+class TestAppModule:
+    """The ``app_module`` property must match each preset's main.py path."""
+
+    @pytest.mark.parametrize(
+        "preset_id, expected_app_module",
+        [
+            ("minimal", "src.main:app"),
+            ("single-module", "src.main:app"),
+            ("classic-layered", "src.main:app"),
+            ("domain-starter", "src.app.main:app"),
+        ],
+    )
+    def test_app_module_matches_main_py_path(
+        self, preset_id: str, expected_app_module: str
+    ) -> None:
+        strategist = PresetLayoutStrategist(preset_id)
+        assert strategist.app_module == expected_app_module
+
+
 class TestCompatibilityWarnings:
     """Warnings only fire on presets that don't regenerate main.py."""
 

tests/test_backends/test_project_builder_config_generator.py

@@ -368,6 +368,35 @@ def test_generated_dockerfile_uses_exec_form_cmd(self) -> None:
             assert parsed[0] == "uvicorn"
             assert "src.main:app" in parsed
 
+    def test_generated_dockerfile_honors_custom_app_module(self) -> None:
+        """The Dockerfile CMD must target the caller-supplied app module.
+
+        Regression for the Codex P1 finding on PR #55: domain-starter
+        ships ``src/app/main.py``, so the default ``src.main:app`` would
+        produce a container that fails at startup. Callers (like the
+        interactive init flow, via ``PresetLayoutStrategist.app_module``)
+        thread the layout-correct module through ``generate_docker_files``.
+        """
+        # given
+        with tempfile.TemporaryDirectory() as tmp:
+            config = {"deployment": ["Docker"]}
+            generator = DynamicConfigGenerator(config, tmp)
+
+            # when
+            generator.generate_docker_files(app_module="src.app.main:app")
+
+            # then
+            dockerfile = Path(tmp) / "Dockerfile"
+            content = dockerfile.read_text()
+            cmd_lines = [
+                line for line in content.splitlines() if line.startswith("CMD ")
+            ]
+            assert len(cmd_lines) == 1
+            parsed = json.loads(cmd_lines[0][len("CMD ") :])
+            assert "src.app.main:app" in parsed
+            # The bogus default must not leak in alongside the override.
+            assert "src.main:app" not in parsed
+
 
 class TestHelperMethods:
     """Test cases for helper methods."""

tests/test_cli_operations/test_cli_interactive_integration.py

@@ -349,6 +349,90 @@ def test_init_interactive_cleans_up_on_failure(
         ),
     ]
 
+    @patch("fastapi_fastkit.cli.subprocess.run")
+    @patch("fastapi_fastkit.backend.package_managers.uv_manager.UvManager.is_available")
+    def test_domain_starter_dockerfile_targets_src_app_main(
+        self,
+        mock_uv_available: MagicMock,
+        mock_subprocess: MagicMock,
+        temp_dir: str,
+    ) -> None:
+        """Regression for Codex P1 on PR #55.
+
+        domain-starter ships ``src/app/main.py``; the generated Dockerfile's
+        ``CMD`` must target ``src.app.main:app``, not the legacy default
+        ``src.main:app`` — otherwise the container fails to boot.
+        """
+        # given
+        os.chdir(temp_dir)
+        project_name = "docker-domain-starter"
+        mock_uv_available.return_value = True
+
+        def _mock_subprocess(*args: Any, **kwargs: Any) -> MagicMock:
+            if args and "venv" in str(args[0]):
+                venv_path = Path(temp_dir) / project_name / ".venv"
+                venv_path.mkdir(parents=True, exist_ok=True)
+                bin_dir = "Scripts" if os.name == "nt" else "bin"
+                (venv_path / bin_dir).mkdir(exist_ok=True)
+            mock_result = MagicMock()
+            mock_result.returncode = 0
+            return mock_result
+
+        mock_subprocess.side_effect = _mock_subprocess
+
+        # when — pick the domain-starter preset and Docker-only deployment.
+        result = self.runner.invoke(
+            fastkit_cli,
+            ["init", "--interactive"],
+            input="\n".join(
+                [
+                    project_name,
+                    "Docker Tester",
+                    "docker@test.com",
+                    "Domain-starter Docker regression",
+                    "4",  # Architecture preset: domain-starter
+                    "6",  # Database: None (last option)
+                    "5",  # Authentication: None (last option)
+                    "3",  # Background Tasks: None (last option)
+                    "2",  # Caching: None (last option)
+                    "4",  # Monitoring: None (last option)
+                    "1",  # Testing: Basic
+                    "",  # Utilities: skip
+                    "1",  # Deployment: Docker
+                    "2",  # Package manager: uv
+                    "",  # Custom packages: skip
+                    "Y",  # Proceed
+                    "Y",  # Create project folder
+                ]
+            ),
+        )
+
+        # then
+        project_path = Path(temp_dir) / project_name
+        assert project_path.exists(), (
+            f"project not created. exit_code={result.exit_code}\n"
+            f"output:\n{result.output}"
+        )
+
+        dockerfile = project_path / "Dockerfile"
+        assert dockerfile.exists(), (
+            f"Dockerfile missing despite Docker deployment selection.\n"
+            f"output:\n{result.output}"
+        )
+
+        content = dockerfile.read_text()
+        assert "src.app.main:app" in content, (
+            "Domain-starter Dockerfile must target src.app.main:app; "
+            "the CMD currently reads:\n"
+            + "\n".join(
+                line for line in content.splitlines() if line.startswith("CMD ")
+            )
+        )
+        assert '"src.main:app"' not in content, (
+            "Bogus legacy default src.main:app leaked into the generated "
+            "Dockerfile despite the preset override."
+        )
+
     @pytest.mark.parametrize(
         "preset_choice,suffix,base_template_name,main_relpath,db_relpath,regenerates_main",
         _PRESET_LAYOUT_CASES,