FastAPI-fastkit 1.3.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

fastapi_fastkit/backend/interactive/__init__.py

@@ -16,10 +16,13 @@ from .prompts import (
     prompt_custom_packages,
     prompt_database_selection,
     prompt_deployment_options,
+    prompt_logging_selection,
+    prompt_migrations_selection,
     prompt_monitoring_selection,
     prompt_package_manager_selection,
     prompt_template_selection,
     prompt_testing_selection,
+    prompt_tooling_selection,
     prompt_utilities_selection,
 )
 from .selectors import confirm_selections, multi_select_prompt, render_selection_table
@@ -37,6 +40,9 @@ __all__ = [
     "prompt_database_selection",
     "prompt_authentication_selection",
     "prompt_additional_features",
+    "prompt_logging_selection",
+    "prompt_migrations_selection",
+    "prompt_tooling_selection",
     "prompt_testing_selection",
     "prompt_deployment_options",
     "prompt_custom_packages",

fastapi_fastkit/backend/interactive/config_builder.py

@@ -10,6 +10,8 @@ from typing import Any, Dict, List
 
 from fastapi_fastkit.utils.main import console, print_warning
 
+from ..project_builder.config_schema import normalize_project_config
+from ..project_builder.dependency_collector import DependencyCollector
 from .prompts import (
     prompt_additional_features,
     prompt_architecture_preset,
@@ -107,6 +109,32 @@ class InteractiveConfigBuilder:
         features = prompt_additional_features(self.settings)
         self.config.update(features)
 
+    def build_config_from_mapping(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Complete a configuration that came from a file instead of prompts.
+
+        ``fastkit init --config`` accepts a hand-written file that lists only
+        feature selections; running them back through the same dependency
+        collection the interactive flow uses keeps both entry points in
+        agreement about which packages a selection implies.
+
+        The mapping is normalised first, so a file that spells an axis
+        differently than the prompts do (a ``{"type": ...}`` block for a
+        single-select axis, say) still resolves to the catalog choice the
+        rest of the pipeline reads.
+
+        Args:
+            config: Configuration mapping (interactive builder shape)
+
+        Returns:
+            The normalised mapping with ``all_dependencies`` filled in
+
+        Raises:
+            ConfigSchemaError: If the mapping holds an unknown key or choice
+        """
+        self.config = normalize_project_config(config, self.settings)
+        return self._build_final_config()
+
     def _build_final_config(self) -> Dict[str, Any]:
         """
         Build and validate final configuration.
@@ -114,6 +142,10 @@ class InteractiveConfigBuilder:
         Returns:
             Complete configuration dictionary with collected dependencies
         """
+        # Normalise before anything reads the selections, so an interactive
+        # session and a ``--config`` file hand the pipeline the same shape.
+        self.config = normalize_project_config(self.config, self.settings)
+
         # Collect all dependencies
         all_deps = self._collect_all_dependencies()
 
@@ -126,74 +158,24 @@ class InteractiveConfigBuilder:
         """
         Collect all dependencies from selected features.
 
+        Delegates to :class:`DependencyCollector`, which walks every axis in
+        ``PACKAGE_CATALOG`` generically. Duplicating the walk here meant a
+        newly added axis (logging, migrations, tooling) was silently skipped
+        for interactive projects while ``fastkit init --config`` picked it up.
+
         Returns:
             Deduplicated list of all package dependencies
         """
-        dependencies = set()
-
-        # Always add base FastAPI dependencies
-        dependencies.update(["fastapi", "uvicorn", "pydantic", "pydantic-settings"])
-
-        # Database dependencies
-        db_info = self.config.get("database", {})
-        if isinstance(db_info, dict) and db_info.get("packages"):
-            dependencies.update(db_info["packages"])
-
-        # Authentication dependencies
-        auth_type = self.config.get("authentication", "None")
-        if auth_type != "None":
-            auth_packages = self.settings.PACKAGE_CATALOG["authentication"].get(
-                auth_type, []
-            )
-            dependencies.update(auth_packages)
-
-        # Async tasks dependencies
-        tasks_type = self.config.get("async_tasks", "None")
-        if tasks_type != "None":
-            task_packages = self.settings.PACKAGE_CATALOG["async_tasks"].get(
-                tasks_type, []
-            )
-            dependencies.update(task_packages)
-
-        # Caching dependencies
-        cache_type = self.config.get("caching", "None")
-        if cache_type != "None":
-            cache_packages = self.settings.PACKAGE_CATALOG["caching"].get(
-                cache_type, []
-            )
-            dependencies.update(cache_packages)
-
-        # Monitoring dependencies
-        monitoring_type = self.config.get("monitoring", "None")
-        if monitoring_type != "None":
-            monitoring_packages = self.settings.PACKAGE_CATALOG["monitoring"].get(
-                monitoring_type, []
-            )
-            dependencies.update(monitoring_packages)
-
-        # Testing dependencies
-        testing_type = self.config.get("testing", "None")
-        if testing_type != "None":
-            testing_packages = self.settings.PACKAGE_CATALOG["testing"].get(
-                testing_type, []
-            )
-            dependencies.update(testing_packages)
-
-        # Utilities dependencies
-        utilities = self.config.get("utilities", [])
-        for util in utilities:
-            if util in self.settings.PACKAGE_CATALOG["utilities"]:
-                util_packages = self.settings.PACKAGE_CATALOG["utilities"][util]
-                dependencies.update(util_packages)
-
-        # Custom packages
-        custom_packages = self.config.get("custom_packages", [])
+        config = dict(self.config)
+
+        # Custom packages are free-form user input, so they are sanitized
+        # before the collector merges them with the catalog-derived set.
+        custom_packages = config.get("custom_packages", [])
         if custom_packages:
-            sanitized = sanitize_custom_packages(custom_packages)
-            dependencies.update(sanitized)
+            config["custom_packages"] = sanitize_custom_packages(custom_packages)
 
-        # Convert to sorted list
-        return sorted(list(dependencies))
+        collector = DependencyCollector(self.settings)
+        return collector.collect_from_config(config)
 
     def get_config(self) -> Dict[str, Any]:
         """

fastapi_fastkit/backend/interactive/prompts.py

@@ -16,6 +16,14 @@ from typing import Any, Dict, List, Optional, cast
 
 import click
 
+from fastapi_fastkit.backend.project_builder.config_generator import SQL_DATABASES
+from fastapi_fastkit.core.settings import (
+    NONE_CHOICE,
+    FeatureAxis,
+    LoggingChoice,
+    MigrationsChoice,
+    ToolingChoice,
+)
 from fastapi_fastkit.utils.main import console, print_error
 
 from .selectors import render_selection_table
@@ -103,7 +111,7 @@ def prompt_architecture_preset(settings: Any) -> str:
     }
     render_selection_table("Architecture Presets", display_options)
 
-    preset_ids = list(presets.keys())
+    preset_ids: List[str] = list(presets.keys())
     default_idx = preset_ids.index(default_id) + 1
 
     choice = click.prompt(
@@ -112,7 +120,8 @@ def prompt_architecture_preset(settings: Any) -> str:
         default=default_idx,
     )
 
-    return cast(str, preset_ids[choice - 1])
+    result: str = preset_ids[choice - 1]
+    return result
 
 
 def prompt_template_selection(settings: Any) -> Optional[str]:
@@ -161,11 +170,10 @@ def prompt_template_selection(settings: Any) -> Optional[str]:
         default=1,
     )
 
-    selected_key = list(options.keys())[choice - 1]
+    template_keys: List[str] = list(options.keys())
+    selected_key: str = template_keys[choice - 1]
 
-    return cast(
-        Optional[str], selected_key if selected_key != "Empty Project" else None
-    )
+    return selected_key if selected_key != "Empty Project" else None
 
 
 def prompt_database_selection(settings: Any) -> Dict[str, Any]:
@@ -436,6 +444,137 @@ def prompt_utilities_selection(settings: Any) -> List[str]:
         return []
 
 
+def prompt_logging_selection(settings: Any) -> str:
+    """
+    Prompt for the application logging format.
+
+    Args:
+        settings: FastkitConfig instance
+
+    Returns:
+        Logging style name
+    """
+    console.print("\n[bold cyan]🪵 Logging Format[/bold cyan]")
+    console.print("[dim]Choose how the application emits its logs[/dim]\n")
+
+    logging_catalog = settings.PACKAGE_CATALOG[FeatureAxis.LOGGING]
+    descriptions = {
+        LoggingChoice.STRUCTURED: (
+            "JSON logs + X-Request-ID correlation middleware (stdlib only)"
+        ),
+        LoggingChoice.NONE: "Uvicorn's default plain-text logging",
+    }
+    options = {
+        name: descriptions.get(name, f"Packages: {', '.join(pkgs) or 'None'}")
+        for name, pkgs in logging_catalog.items()
+    }
+
+    render_selection_table("Logging Options", options)
+
+    choice = click.prompt(
+        "\nSelect logging format",
+        type=click.IntRange(1, len(options)),
+        default=len(options),  # Default to "None"
+    )
+
+    return cast(str, list(options.keys())[choice - 1])
+
+
+def prompt_migrations_selection(settings: Any, database_type: str = "None") -> str:
+    """
+    Prompt for the schema migration tool.
+
+    Alembic only has something to migrate on a relational database, so it is
+    pre-selected as the default when the user picked one and the prompt
+    defaults to ``None`` otherwise.
+
+    Args:
+        settings: FastkitConfig instance
+        database_type: The database chosen earlier in the flow
+
+    Returns:
+        Migration tool name
+    """
+    console.print("\n[bold cyan]🧬 Database Migrations[/bold cyan]")
+    console.print("[dim]Version-control your database schema[/dim]\n")
+
+    migrations_catalog = settings.PACKAGE_CATALOG[FeatureAxis.MIGRATIONS]
+    is_sql = database_type in SQL_DATABASES
+
+    descriptions = {
+        MigrationsChoice.ALEMBIC: (
+            "alembic.ini + async alembic/env.py + scripts/migrate.sh"
+            + (
+                " [bold green](recommended for SQL databases)[/bold green]"
+                if is_sql
+                else " [yellow](needs a relational database)[/yellow]"
+            )
+        ),
+        MigrationsChoice.NONE: "No migration tooling",
+    }
+    options = {name: descriptions.get(name, "") for name in migrations_catalog}
+
+    render_selection_table("Migration Options", options)
+
+    option_names = list(options.keys())
+    default_idx = (
+        option_names.index(MigrationsChoice.ALEMBIC) + 1 if is_sql else len(options)
+    )
+
+    choice = click.prompt(
+        "\nSelect migration tool",
+        type=click.IntRange(1, len(options)),
+        default=default_idx,
+    )
+
+    return cast(str, option_names[choice - 1])
+
+
+def prompt_tooling_selection(settings: Any) -> List[str]:
+    """
+    Prompt for developer tooling (multi-select).
+
+    Args:
+        settings: FastkitConfig instance
+
+    Returns:
+        List of selected tooling names
+    """
+    console.print("\n[bold cyan]🧰 Developer Tooling[/bold cyan]")
+    console.print(
+        "[dim]Select tooling to generate (comma-separated numbers, e.g., 1,3)[/dim]\n"
+    )
+
+    tooling_catalog = settings.PACKAGE_CATALOG[FeatureAxis.TOOLING]
+    descriptions = {
+        ToolingChoice.RUFF: "ruff + ruff-format config in pyproject.toml (replaces black/isort)",
+        ToolingChoice.PRE_COMMIT: ".pre-commit-config.yaml",
+        ToolingChoice.GITHUB_ACTIONS: ".github/workflows/test.yml (Python 3.12)",
+        ToolingChoice.DEVCONTAINER: ".devcontainer/devcontainer.json",
+        ToolingChoice.MAKEFILE: "Makefile with install/test/lint/format/run",
+    }
+
+    options = [name for name in tooling_catalog if name != NONE_CHOICE]
+    for i, option in enumerate(options, 1):
+        console.print(
+            f"  [cyan]{i}[/cyan]. {option} [dim]{descriptions.get(option, '')}[/dim]"
+        )
+
+    selected_input = console.input(
+        "\n[cyan]Your choice (or press Enter to skip):[/cyan] "
+    ).strip()
+
+    if not selected_input:
+        return []
+
+    try:
+        indices = [int(x.strip()) for x in selected_input.split(",") if x.strip()]
+        return [options[idx - 1] for idx in indices if 1 <= idx <= len(options)]
+    except (ValueError, IndexError):
+        console.print("[yellow]Invalid selection. Skipping tooling.[/yellow]")
+        return []
+
+
 def prompt_deployment_options() -> List[str]:
     """
     Prompt for deployment configuration.
@@ -561,12 +700,22 @@ def prompt_additional_features(settings: Any) -> Dict[str, Any]:
     # Monitoring
     features["monitoring"] = prompt_monitoring_selection(settings)
 
+    # Logging format
+    features["logging"] = prompt_logging_selection(settings)
+
     # Testing
     features["testing"] = prompt_testing_selection(settings)
 
+    # Migrations — the database choice decides the recommended default.
+    database_type = features["database"].get("type", NONE_CHOICE)
+    features["migrations"] = prompt_migrations_selection(settings, database_type)
+
     # Utilities
     features["utilities"] = prompt_utilities_selection(settings)
 
+    # Developer tooling
+    features["tooling"] = prompt_tooling_selection(settings)
+
     # Deployment
     features["deployment"] = prompt_deployment_options()
 

fastapi_fastkit/backend/interactive/selectors.py

@@ -13,6 +13,7 @@ from typing import Any, Dict, List, Optional
 from rich.panel import Panel
 from rich.table import Table
 
+from fastapi_fastkit.core.settings import MULTI_SELECT_AXES
 from fastapi_fastkit.utils.main import console
 
 
@@ -177,11 +178,26 @@ def confirm_selections(config: Dict[str, Any]) -> bool:
     if testing_type != "None":
         table.add_row("Testing", testing_type)
 
+    # Logging format
+    logging_type = config.get("logging", "None")
+    if logging_type != "None":
+        table.add_row("Logging", logging_type)
+
+    # Migrations
+    migrations_type = config.get("migrations", "None")
+    if migrations_type != "None":
+        table.add_row("Migrations", migrations_type)
+
     # Utilities
     utilities = config.get("utilities", [])
     if utilities:
         table.add_row("Utilities", ", ".join(utilities))
 
+    # Developer tooling
+    tooling = config.get("tooling", [])
+    if tooling:
+        table.add_row("Tooling", ", ".join(tooling))
+
     # Custom packages
     custom = config.get("custom_packages", [])
     if custom:
@@ -229,8 +245,8 @@ def display_feature_catalog(
     console.print(panel)
 
     for category, options in catalog.items():
-        if category == "utilities":
-            continue  # Skip utilities as they may have empty package lists
+        if category in MULTI_SELECT_AXES:
+            continue  # Skip multi-selects: several options ship no packages
 
         desc = descriptions.get(category, category.title())
         table = Table(title=f"{desc}", show_header=True, header_style="bold yellow")