model-generator-kit 0.1.0__py3-none-any.whl

model_generator/generators/infrastructure.py

@@ -0,0 +1,679 @@
+"""
+Infrastructure file generation (base, engine, main, errors, validators, etc.).
+"""
+
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment
+
+from ..utils.constants import GENERATED_MARKER
+from ..utils.templates import path_to_import
+
+
+def generate_base(
+    config: dict[str, Any], env: Environment, project_root: Path
+) -> dict[str, Any] | None:
+    """Generate SQLAlchemy Base class."""
+    db_models = config["paths"].get("database_models", "backend/src/database/models")
+    base_path = config["paths"].get("base", f"{db_models}/base.py")
+    output_path = project_root / base_path
+
+    if output_path.exists():
+        return None
+
+    template = env.get_template("infrastructure/base.py.j2")
+    content = template.render()
+
+    return {"path": output_path, "content": content}
+
+
+def generate_engine(
+    config: dict[str, Any], env: Environment, project_root: Path
+) -> dict[str, Any] | None:
+    """Generate database engine and session management."""
+    engine_path = config["paths"].get("engine", "backend/src/database/engine.py")
+    output_path = project_root / engine_path
+
+    if output_path.exists():
+        return None
+
+    template = env.get_template("infrastructure/engine.py.j2")
+    content = template.render()
+
+    return {"path": output_path, "content": content}
+
+
+def generate_types(
+    config: dict[str, Any], env: Environment, project_root: Path
+) -> dict[str, Any] | None:
+    """Generate custom SQLAlchemy types (SqliteNumeric for financial/percentage)."""
+    db_models = config["paths"].get("database_models", "backend/src/database/models")
+    db_dir = str(Path(db_models).parent)
+    output_path = project_root / db_dir / "types.py"
+
+    if output_path.exists():
+        return None
+
+    template = env.get_template("infrastructure/types.py.j2")
+    content = template.render()
+
+    return {"path": output_path, "content": content}
+
+
+def generate_database_init(
+    config: dict[str, Any], env: Environment, project_root: Path
+) -> dict[str, Any] | None:
+    """Generate database package __init__.py with get_session export."""
+    db_models = config["paths"].get("database_models", "backend/src/database/models")
+    db_dir = str(Path(db_models).parent)
+    output_path = project_root / db_dir / "__init__.py"
+
+    if output_path.exists():
+        return None
+
+    template = env.get_template("infrastructure/database_init.py.j2")
+    content = template.render()
+
+    return {"path": output_path, "content": content}
+
+
+def generate_errors(
+    config: dict[str, Any], env: Environment, project_root: Path
+) -> dict[str, Any] | None:
+    """Generate API error formatting utilities."""
+    errors_path = config["paths"].get("errors", "backend/src/api/errors.py")
+    output_path = project_root / errors_path
+
+    if output_path.exists():
+        return None
+
+    template = env.get_template("infrastructure/errors.py.j2")
+    content = template.render()
+
+    return {"path": output_path, "content": content}
+
+
+def generate_validators(
+    config: dict[str, Any], env: Environment, project_root: Path
+) -> dict[str, Any] | None:
+    """Generate API validation utilities.
+
+    Bootstrap-only: returns None when the file already exists so adopters
+    who add domain-specific validators are not overwritten on regeneration.
+    """
+    validators_path = config["paths"].get("validators", "backend/src/api/validators.py")
+    output_path = project_root / validators_path
+
+    if output_path.exists():
+        return None
+
+    template = env.get_template("infrastructure/validators.py.j2")
+    content = template.render()
+
+    return {"path": output_path, "content": content}
+
+
+def generate_utils(
+    config: dict[str, Any], env: Environment, project_root: Path
+) -> dict[str, Any] | None:
+    """Generate API utility functions (normalize_decimal).
+
+    Bootstrap-only: returns None when the file already exists so adopters
+    who add domain-specific utilities are not overwritten on regeneration.
+    """
+    api_models_path = config["paths"].get("api_models", "backend/src/api/models")
+    api_dir = str(Path(api_models_path).parent)
+    output_path = project_root / api_dir / "utils.py"
+
+    if output_path.exists():
+        return None
+
+    template = env.get_template("infrastructure/utils.py.j2")
+    content = template.render()
+
+    return {"path": output_path, "content": content}
+
+
+def generate_gitignore(
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    no_root_files: bool = False,
+) -> dict[str, Any] | None:
+    """Generate .gitignore for new projects (only if none exists).
+
+    Returns None when ``no_root_files`` is set, so adopters using
+    --no-root-files for scratch-and-migrate workflows keep their own
+    repository's .gitignore unchanged.
+    """
+    if no_root_files:
+        return None
+
+    output_path = project_root / ".gitignore"
+
+    if output_path.exists():
+        return None
+
+    template = env.get_template("infrastructure/gitignore.j2")
+    content = template.render()
+
+    return {"path": output_path, "content": content}
+
+
+def generate_pyproject(
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    project_config: dict[str, Any],
+    extra_deps: list[str] | None = None,
+    no_root_files: bool = False,
+) -> dict[str, Any] | None:
+    """Generate pyproject.toml for new projects (only if none exists).
+
+    Returns None when ``no_root_files`` is set, so adopters using
+    --no-root-files for scratch-and-migrate workflows keep their own
+    repository's pyproject.toml unchanged.
+    """
+    if no_root_files:
+        return None
+
+    output_path = project_root / "pyproject.toml"
+
+    if output_path.exists():
+        return None
+
+    project = project_config.get("project", {})
+    raw_name = project.get("name", "my-project")
+    project_slug = raw_name.lower().replace(" ", "-")
+
+    deps = config.get("dependencies", {})
+    runtime_deps = deps.get("runtime", [])
+    dev_deps = deps.get("dev", [])
+
+    # Merge domain-level extra dependencies
+    if extra_deps:
+        runtime_deps = sorted(set(runtime_deps + extra_deps))
+
+    paths = config.get("paths", {})
+    validators_path = paths.get("validators", "backend/src/api/validators.py")
+
+    api_models_path = paths.get("api_models", "backend/src/api/models")
+    utils_path = str(Path(api_models_path).parent / "utils.py")
+
+    constraints_path = paths.get(
+        "constraints", "backend/src/database/models/constraints.py"
+    )
+
+    # Top-level source directory for mutmut also_copy
+    also_copy_dir = Path(validators_path).parts[0] + "/"
+
+    # Package root for setuptools discovery (e.g., "backend/src")
+    main_path = paths.get("main", "backend/src/main.py")
+    package_root = str(Path(main_path).parent)
+
+    raw_style = {
+        **(config.get("style") or {}),
+        **(project_config.get("style") or {}),
+    }
+    style = {
+        "python_version": raw_style.get("python_version") or "3.11",
+        "line_length": raw_style.get("line_length"),
+        "quote_style": raw_style.get("quote_style"),
+        "indent_style": raw_style.get("indent_style"),
+    }
+
+    template = env.get_template("infrastructure/pyproject.toml.j2")
+    content = template.render(
+        project=project,
+        project_slug=project_slug,
+        runtime_deps=runtime_deps,
+        dev_deps=dev_deps,
+        validators_path=validators_path,
+        utils_path=utils_path,
+        constraints_path=constraints_path,
+        also_copy_dir=also_copy_dir,
+        package_root=package_root,
+        style=style,
+    )
+
+    return {"path": output_path, "content": content}
+
+
+def generate_main(
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    domains: list[str],
+    project_config: dict[str, Any],
+    route_modules: list[str] | None = None,
+) -> dict[str, Any] | None:
+    """Generate FastAPI main application.
+
+    ``domains`` is kept for backward compatibility. ``route_modules`` is the
+    layout-aware list of route module stems imported by main.py — entity
+    snake_case names in per-entity mode, domain names in per-domain mode.
+    Defaults to ``domains`` when not provided.
+
+    Bootstrap-only: returns None when the file already exists so adopters
+    who wire up additional routers / middleware are not overwritten on
+    regeneration. New domains/routes added later must be wired manually.
+    """
+    main_path = config["paths"].get("main", "backend/src/main.py")
+    output_path = project_root / main_path
+
+    if output_path.exists():
+        return None
+
+    python_root = config.get("python_root", "")
+
+    api_routes_path = config["paths"].get("api_routes", "backend/src/api/routes")
+    api_routes_import = path_to_import(api_routes_path, python_root=python_root)
+
+    db_models_path = config["paths"].get(
+        "database_models", "backend/src/database/models"
+    )
+    db_import = path_to_import(
+        str(Path(db_models_path).parent), python_root=python_root
+    )
+
+    main_dir = str(Path(main_path).parent)
+    main_module = path_to_import(main_dir, "main", python_root=python_root)
+
+    auth_router_import = None
+    auth = config.get("auth") or {}
+    if auth.get("strategy"):
+        auth_path = auth.get("path", "backend/src/auth/router.py")
+        auth_module_path = auth_path[:-3] if auth_path.endswith(".py") else auth_path
+        auth_router_import = path_to_import(auth_module_path, python_root=python_root)
+
+    csrf_module_import = None
+    if auth.get("strategy"):
+        auth_path = auth.get("path", "backend/src/auth/router.py")
+        csrf_module_path = str(Path(auth_path).parent / "csrf")
+        csrf_module_import = path_to_import(csrf_module_path, python_root=python_root)
+
+    rate_limit_module_import = None
+    if auth.get("strategy"):
+        rate_limit = auth.get("rate_limit") or {}
+        if rate_limit.get("enabled") is not False:
+            auth_path = auth.get("path", "backend/src/auth/router.py")
+            rate_limit_module_path = str(Path(auth_path).parent / "rate_limit")
+            rate_limit_module_import = path_to_import(
+                rate_limit_module_path, python_root=python_root
+            )
+
+    template = env.get_template("infrastructure/main.py.j2")
+    content = template.render(
+        domains=route_modules if route_modules is not None else domains,
+        api_routes_import=api_routes_import,
+        db_import=db_import,
+        main_module=main_module,
+        project=project_config.get("project", {}),
+        auth_router_import=auth_router_import,
+        csrf_module_import=csrf_module_import,
+        rate_limit_module_import=rate_limit_module_import,
+    )
+
+    return {"path": output_path, "content": content}
+
+
+def generate_auth_router(
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    project_config: dict[str, Any],
+) -> dict[str, Any] | None:
+    """Generate the auth router (register / login / logout / etc.).
+
+    Emitted only when ``config.auth.strategy`` is set. Bootstrap-only:
+    returns None when the file already exists at the configured
+    ``auth.path`` so adopters who customize the router are not overwritten
+    on regeneration.
+    """
+    if not config.get("auth", {}).get("strategy"):
+        return None
+
+    auth_path = config.get("auth", {}).get("path", "backend/src/auth/router.py")
+    output_path = project_root / auth_path
+
+    if output_path.exists():
+        return None
+
+    python_root = config.get("python_root", "")
+
+    db_models_path = config["paths"].get(
+        "database_models", "backend/src/database/models"
+    )
+    db_models_import = path_to_import(db_models_path, python_root=python_root)
+    db_import = path_to_import(
+        str(Path(db_models_path).parent), python_root=python_root
+    )
+
+    template = env.get_template("infrastructure/auth_router.py.j2")
+    content = template.render(
+        config=config,
+        db_models_import=db_models_import,
+        db_import=db_import,
+        project=project_config.get("project", {}),
+        rate_limit_enabled=(config.get("auth", {}).get("rate_limit") or {}).get(
+            "enabled"
+        )
+        is not False,
+    )
+
+    return {"path": output_path, "content": content}
+
+
+def generate_csrf(
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+) -> dict[str, Any] | None:
+    """Generate the CSRF middleware (double-submit cookie pattern).
+
+    Emitted only when ``config.auth.strategy`` is set. The file lives next
+    to the auth router (sibling in the same package) so the router can
+    import it via ``from .csrf import set_csrf_cookie``. Bootstrap-only:
+    returns None when the file already exists.
+    """
+    if not config.get("auth", {}).get("strategy"):
+        return None
+
+    auth_path = config.get("auth", {}).get("path", "backend/src/auth/router.py")
+    csrf_path = str(Path(auth_path).parent / "csrf.py")
+    output_path = project_root / csrf_path
+
+    if output_path.exists():
+        return None
+
+    cookie_name = config.get("auth", {}).get("cookie_name", "session_id")
+
+    template = env.get_template("infrastructure/csrf.py.j2")
+    content = template.render(cookie_name=cookie_name)
+
+    return {"path": output_path, "content": content}
+
+
+def generate_encrypted_bytes(
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    has_encrypted_binary: bool = False,
+) -> dict[str, Any] | None:
+    """Generate the EncryptedBytes TypeDecorator next to the model files.
+
+    Emitted only when at least one entity in the project has a ``binary``
+    field with an ``encrypt`` block — mirrors the ``ns.has_encrypted_binary``
+    gate that ``model.py.j2`` uses to conditionally emit
+    ``from .encrypted_bytes import EncryptedBytes``. Bootstrap-only:
+    returns None when the file already exists at the target path.
+    """
+    if not has_encrypted_binary:
+        return None
+
+    db_models = config["paths"].get("database_models", "backend/src/database/models")
+    output_path = project_root / db_models / "encrypted_bytes.py"
+
+    if output_path.exists():
+        return None
+
+    template = env.get_template("infrastructure/encrypted_bytes.py.j2")
+    content = template.render(config=config)
+
+    return {"path": output_path, "content": content}
+
+
+def generate_rate_limit(
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+) -> dict[str, Any] | None:
+    """Generate the rate-limit module (shared slowapi Limiter instance).
+
+    Emitted only when ``config.auth.strategy`` is set AND
+    ``config.auth.rate_limit.enabled`` is not False (rate limiting is on
+    by default for auth-enabled projects). The file lives next to the
+    auth router so the router can import it via
+    ``from .rate_limit import limiter``. Bootstrap-only: returns None
+    when the file already exists.
+    """
+    auth = config.get("auth") or {}
+    if not auth.get("strategy"):
+        return None
+
+    rate_limit = auth.get("rate_limit") or {}
+    if rate_limit.get("enabled") is False:
+        return None
+
+    auth_path = auth.get("path", "backend/src/auth/router.py")
+    rate_limit_path = str(Path(auth_path).parent / "rate_limit.py")
+    output_path = project_root / rate_limit_path
+
+    if output_path.exists():
+        return None
+
+    backend = rate_limit.get("backend", "memory")
+    default_storage_uri = (
+        "redis://localhost:6379/0" if backend == "redis" else "memory://"
+    )
+
+    template = env.get_template("infrastructure/rate_limit.py.j2")
+    content = template.render(
+        login_limit=rate_limit.get("login", "5/minute"),
+        register_limit=rate_limit.get("register", "3/hour"),
+        forgot_limit=rate_limit.get("forgot", "3/hour"),
+        default_storage_uri=default_storage_uri,
+    )
+
+    return {"path": output_path, "content": content}
+
+
+def generate_test_conftest_root(
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    domains: list[str],
+    factory_modules: list[str] | None = None,
+) -> dict[str, Any] | None:
+    """Generate root test conftest with database and client fixtures.
+
+    ``domains`` is kept for backward compatibility. ``factory_modules`` is the
+    layout-aware list of factory module stems imported by conftest.py — entity
+    snake_case names in per-entity mode, domain names in per-domain mode.
+    Defaults to ``domains`` when not provided.
+
+    Bootstrap-only: returns None when the file already exists so adopters
+    who add fixture overrides are not overwritten on regeneration. New
+    factory modules added later must be wired manually.
+    """
+    conftest_path = config["paths"].get("test_conftest_root", "tests/conftest.py")
+    output_path = project_root / conftest_path
+
+    if output_path.exists():
+        return None
+
+    python_root = config.get("python_root", "")
+
+    database_models_path = config["paths"].get(
+        "database_models", "backend/src/database/models"
+    )
+    database_models_import = path_to_import(
+        database_models_path, python_root=python_root
+    )
+
+    main_path = config["paths"].get("main", "backend/src/main.py")
+    main_dir = str(Path(main_path).parent)
+    main_import = path_to_import(main_dir, "main", python_root=python_root)
+
+    engine_path = config["paths"].get("engine", "backend/src/database/engine.py")
+    engine_dir = str(Path(engine_path).parent)
+    engine_import = path_to_import(engine_dir, "engine", python_root=python_root)
+
+    factories_path = config["paths"].get(
+        "factories", "backend/src/database/models/factories"
+    )
+    factories_import = path_to_import(factories_path, python_root=python_root)
+
+    template = env.get_template("tests/conftest_root.py.j2")
+    content = template.render(
+        domains=factory_modules if factory_modules is not None else domains,
+        database_models_import=database_models_import,
+        main_import=main_import,
+        engine_import=engine_import,
+        factories_import=factories_import,
+    )
+
+    return {"path": output_path, "content": content}
+
+
+def generate_package_init_files(
+    config: dict[str, Any], project_root: Path
+) -> list[dict[str, Any]]:
+    """
+    Generate __init__.py files for all package directories.
+
+    Creates empty __init__.py files in all necessary directories
+    to make them proper Python packages.
+    """
+    outputs = []
+    paths_config = config.get("paths", {})
+
+    # Collect all directories that need __init__.py
+    paths_to_init = []
+
+    # Main source directory
+    main_path = paths_config.get("main", "backend/src/main.py")
+    src_dir = str(Path(main_path).parent)
+    paths_to_init.append(src_dir)
+
+    # Database paths
+    db_models = paths_config.get("database_models", "backend/src/database/models")
+    paths_to_init.append(db_models)
+
+    # Factories
+    factories = paths_config.get("factories", "backend/src/database/models/factories")
+    paths_to_init.append(factories)
+
+    # API paths
+    api_models = paths_config.get("api_models", "backend/src/api/models")
+    paths_to_init.append(api_models)
+    api_dir = str(Path(api_models).parent)
+    paths_to_init.append(api_dir)
+
+    api_routes = paths_config.get("api_routes", "backend/src/api/routes")
+    paths_to_init.append(api_routes)
+
+    # Auth package (when auth.strategy is set, the auth router and CSRF
+    # middleware live in the same package and use relative imports).
+    if config.get("auth", {}).get("strategy"):
+        auth_path = config.get("auth", {}).get("path", "backend/src/auth/router.py")
+        paths_to_init.append(str(Path(auth_path).parent))
+
+    # Test paths (including parent directories)
+    api_tests = paths_config.get("api_tests", "tests/contract/api")
+    paths_to_init.append(api_tests)
+    test_dir = api_tests
+    while "/" in test_dir:
+        test_dir = str(Path(test_dir).parent)
+        paths_to_init.append(test_dir)
+
+    # Generate __init__.py for each unique path
+    init_content = f"{GENERATED_MARKER}\n"
+    for path in sorted(set(paths_to_init)):
+        init_path = project_root / path / "__init__.py"
+        if not init_path.exists():
+            outputs.append({"path": init_path, "content": init_content})
+
+    return outputs
+
+
+def generate_infrastructure(
+    config: dict[str, Any],
+    env: Environment,
+    project_root: Path,
+    domains: list[str],
+    project_config: dict[str, Any],
+    extra_deps: list[str] | None = None,
+    diff: bool = False,
+    dry_run: bool = False,
+    route_modules: list[str] | None = None,
+    factory_modules: list[str] | None = None,
+    has_encrypted_binary: bool = False,
+    no_root_files: bool = False,
+) -> list[Path]:
+    """
+    Generate all infrastructure files.
+
+    Returns list of generated file paths.
+    """
+    print("\n🏗️  Generating infrastructure files...")
+
+    outputs = []
+
+    # Collect all infrastructure outputs
+    generators = [
+        generate_gitignore(config, env, project_root, no_root_files=no_root_files),
+        generate_pyproject(
+            config,
+            env,
+            project_root,
+            project_config,
+            extra_deps,
+            no_root_files=no_root_files,
+        ),
+        generate_base(config, env, project_root),
+        generate_engine(config, env, project_root),
+        generate_types(config, env, project_root),
+        generate_database_init(config, env, project_root),
+        generate_errors(config, env, project_root),
+        generate_validators(config, env, project_root),
+        generate_utils(config, env, project_root),
+        generate_main(
+            config,
+            env,
+            project_root,
+            domains,
+            project_config,
+            route_modules=route_modules,
+        ),
+        generate_auth_router(config, env, project_root, project_config),
+        generate_csrf(config, env, project_root),
+        generate_encrypted_bytes(
+            config, env, project_root, has_encrypted_binary=has_encrypted_binary
+        ),
+        generate_rate_limit(config, env, project_root),
+        generate_test_conftest_root(
+            config, env, project_root, domains, factory_modules=factory_modules
+        ),
+    ]
+
+    for result in generators:
+        if result:
+            outputs.append(result)
+
+    # Add package init files
+    outputs.extend(generate_package_init_files(config, project_root))
+
+    # Process outputs
+    generated_files = []
+    for output in outputs:
+        path = output["path"]
+        content = output["content"]
+
+        if diff:
+            print(f"\n--- {path} ---")
+            print(content[:500] + "..." if len(content) > 500 else content)
+            continue
+
+        if dry_run:
+            print(f"  Would write: {path}")
+            continue
+
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w") as f:
+            f.write(content)
+        print(f"  ✅ Generated: {path}")
+        generated_files.append(path)
+
+    return generated_files