quadkit-cli 0.0.41__tar.gz → 0.0.43__tar.gz

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: quadkit-cli
-Version: 0.0.41
+Version: 0.0.43
 Summary: Command-line interface for Quadkit Framework - Project scaffolding, code generation, and development tools
 Project-URL: Homepage, https://dbtinoy-.github.io/quadkit/
 Project-URL: Repository, https://github.com/dbtinoy-/quadkit
@@ -167,10 +167,10 @@ review release notes on upgrade. Report vulnerabilities privately per
 
 ## Stability
 
-Version `0.0.3` in the `0.x` series, released in lockstep with the
+Version `0.0.43` in the `0.x` series, released in lockstep with the
 other four distributions; APIs may change between minor versions until
-1.0 — pin an exact version (`quadkit-cli==0.0.3`) or a tight range
-(`>=0.0.3,<0.1.0`). Full policy:
+1.0 — pin an exact version (`quadkit-cli==0.0.43`) or a tight range
+(`>=0.0.43,<0.1.0`). Full policy:
 [stability and compatibility](https://dbtinoy-.github.io/quadkit/reference/stability/).
 
 ## Links

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/README.md

@@ -111,10 +111,10 @@ review release notes on upgrade. Report vulnerabilities privately per
 
 ## Stability
 
-Version `0.0.3` in the `0.x` series, released in lockstep with the
+Version `0.0.43` in the `0.x` series, released in lockstep with the
 other four distributions; APIs may change between minor versions until
-1.0 — pin an exact version (`quadkit-cli==0.0.3`) or a tight range
-(`>=0.0.3,<0.1.0`). Full policy:
+1.0 — pin an exact version (`quadkit-cli==0.0.43`) or a tight range
+(`>=0.0.43,<0.1.0`). Full policy:
 [stability and compatibility](https://dbtinoy-.github.io/quadkit/reference/stability/).
 
 ## Links

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quadkit-cli"
-version = "0.0.41"
+version = "0.0.43"
 description = "Command-line interface for Quadkit Framework - Project scaffolding, code generation, and development tools"
 readme = "README.md"
 requires-python = ">=3.11"

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/src/quadkit/cli/commands/config.py

@@ -78,6 +78,9 @@ def show(
             config_path = find_config()
             config_data = await load_config_yaml_async(config_path)
         except (ConfigNotFoundError, FileNotFoundError):
+            # Both are reachable here: find_config() raises the former, and
+            # the try also wraps the read, which can lose the file to a
+            # race after the walk.
             out.error(
                 "No application.yaml found in current directory or any parent.",
                 hint="Run `quadkit init` to create one.",
@@ -342,7 +345,10 @@ def env_cmd(
     async def _run() -> None:
         try:
             config_path = find_config()
-        except (ConfigNotFoundError, FileNotFoundError):
+        except ConfigNotFoundError:
+            # find_config() raises ConfigNotFoundError (a CliError), never
+            # FileNotFoundError: it walks candidates with ``.is_file()``. The
+            # old arm therefore never ran, and this message never printed.
             out.error("No application.yaml found")
             raise typer.Exit(1) from None
 
@@ -458,7 +464,10 @@ def env_example(
     async def _run() -> None:
         try:
             config_path = find_config()
-        except (ConfigNotFoundError, FileNotFoundError):
+        except ConfigNotFoundError:
+            # find_config() raises ConfigNotFoundError (a CliError), never
+            # FileNotFoundError: it walks candidates with ``.is_file()``. The
+            # old arm therefore never ran, and this message never printed.
             out.error("No application.yaml found")
             raise typer.Exit(1) from None
 

quadkit_cli-0.0.43/src/quadkit/cli/commands/db_commands_data.py

@@ -0,0 +1,327 @@
+"""Seed, reset, and schema-setup commands for the db command group."""
+
+from __future__ import annotations
+
+import asyncio
+import importlib
+import importlib.util
+from pathlib import Path
+import sys
+from typing import Annotated
+
+import typer
+
+from quadkit.cli.commands import db_bootstrap
+from quadkit.cli.layout import read_project_layout, resolve_output_dir
+from quadkit.cli.output import OutputManager
+from quadkit.cli.runtime import handle_errors
+from quadkit.contracts.cli.contributions import (
+    SchemaSetupContribution,
+    SchemaSetupOutcome,
+    SchemaSetupResult,
+)
+from quadkit.contracts.data.sql.database import DatabaseProviderProtocol
+
+
+def _seeder_sources() -> list[tuple[Path, str | None]]:
+    """Every directory this project keeps seeders in, and how to import each.
+
+    Resolution order:
+
+    1. the canonical ``seeders`` component — where ``quadkit gen seeder``
+       writes and where a generated application keeps the seeders its
+       persistence provider boots;
+    2. **one per bounded context** — ``src/<app>/modules/<slug>/seeders``.
+       A seeder seeds one entity, so it follows that entity into its module
+       (OQ-L1). Before that, every seeder in a modular project shared one
+       ``shared/seeders`` directory and a single lookup found them all;
+       scanning the modules is what keeps ``db seed`` complete now that they
+       are spread out. Missing this is how the command would silently seed
+       nothing in exactly the projects that need it most;
+    3. the project-root ``seeds/`` directory — what a project generated
+       before the ``seeders`` row landed has, and what a hand-written
+       collection looks like. Those files sit outside any package, so they
+       stay path-loaded, exactly as this command always loaded them.
+
+    Returns:
+        ``(directory, module_prefix)`` pairs: the directory to read, and the
+        dotted package its modules belong to when it lives inside ``src/`` —
+        ``None`` when it does not, which is the signal to load by path.
+    """
+    layout = read_project_layout()
+    found: list[tuple[Path, str | None]] = []
+
+    canonical = Path(resolve_output_dir("src/seeders", app_package=layout.app_package))
+    if canonical.is_dir():
+        found.append((canonical, _module_prefix(canonical)))
+
+    # The app package's `modules/` tree, if this project has bounded contexts.
+    app_root = canonical.parent if canonical.name == "seeders" else None
+    modules_root = (app_root / "modules") if app_root else None
+    if modules_root and modules_root.is_dir():
+        for module_dir in sorted(modules_root.iterdir()):
+            seeders = module_dir / "seeders"
+            if seeders.is_dir():
+                found.append((seeders, _module_prefix(seeders)))
+
+    if found:
+        return found
+    # The legacy root directory is returned whether or not it exists: the
+    # callers report "no seeds directory found" from it, so handing back an
+    # absent path is how that message still gets made.
+    return [(Path("seeds"), None)]
+
+
+def _seeder_source() -> tuple[Path, str | None]:
+    """The first seeder directory, for callers that only report existence."""
+    return _seeder_sources()[0]
+
+
+def _module_prefix(directory: Path) -> str | None:
+    """Dotted package name for *directory*, when it is inside ``src/``."""
+    parts = directory.parts
+    if "src" not in parts:
+        return None
+    after_src = parts[parts.index("src") + 1 :]
+    return ".".join(after_src) if after_src else None
+
+
+def _make_importable(directory: Path) -> None:
+    """Put the package root of *directory* on ``sys.path``.
+
+    Seeders import the application's own packages (``from my_app.shared...``),
+    and the CLI is not run with the project's ``src`` on the path the way the
+    project's own entry point is.
+    """
+    parts = directory.parts
+    if "src" not in parts:
+        return
+    root = Path(*parts[: parts.index("src") + 1])
+    resolved = str(root.resolve())
+    if resolved not in sys.path:
+        sys.path.insert(0, resolved)
+
+
+def _seed_files(directory: Path) -> list[Path]:
+    """Seeders to run, in filename order.
+
+    ``__init__.py`` is skipped: seeders below ``src/`` live in a package, and
+    the package marker is not a seeder -- running it would report "No 'run'
+    function found" for a file the user never wrote.
+    """
+    return [
+        path for path in sorted(directory.glob("*.py")) if path.name != "__init__.py"
+    ]
+
+
+async def _run_seeder(
+    out: OutputManager,
+    provider: DatabaseProviderProtocol,
+    seed_file: Path,
+    module_prefix: str | None,
+) -> None:
+    """Execute one seeder file.
+
+    A seeder inside the application package is *imported*: it is an ordinary
+    module there, and importing is what the generated application itself does
+    when it boots its seeders. Anything else is loaded from its path, which is
+    the only thing that works for a file outside ``src/``.
+    """
+    out.info(f"Running seeder: {seed_file}")
+
+    if module_prefix is not None:
+        _make_importable(seed_file)
+        module = importlib.import_module(f"{module_prefix}.{seed_file.stem}")
+    else:
+        spec = importlib.util.spec_from_file_location("seed_module", seed_file)
+        if spec is None or spec.loader is None:
+            out.warning(f"Could not load seeder: {seed_file}")
+            return
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+    if not hasattr(module, "run"):
+        out.warning(f"No 'run' function found in {seed_file}")
+        return
+
+    if asyncio.iscoroutinefunction(module.run):
+        await module.run(provider)
+    else:
+        module.run(provider)
+    out.success(f"Seeder {seed_file} completed.")
+
+
+@handle_errors
+def seed(
+    file: str | None = typer.Argument(None, help="Specific seed file to run"),
+    env: str | None = typer.Option("--env", "-e", help="Environment name"),
+) -> None:
+    """Run database seeders."""
+    out = OutputManager()
+
+    async def _run() -> None:
+        manager = await db_bootstrap.get_migration_manager()
+        await manager.provider.boot()
+        try:
+            sources = _seeder_sources()
+            seeds_dir = sources[0][0]
+            if not any(d.exists() for d, _ in sources) and not file:
+                out.warning("No seeds directory found.")
+                return
+
+            # Annotated: the first branch appends ``(path, None)`` and the
+            # second rebuilds with a module prefix, so inference from the
+            # empty list would pin the tuple's second element to ``None``.
+            files_to_run: list[tuple[Path, str | None]] = []
+            if file:
+                # An explicit file is run as given, by path: the user named a
+                # file, not a module.
+                files_to_run.append((Path(file), None))
+            else:
+                files_to_run = [
+                    (seed_file, prefix)
+                    for directory, prefix in _seeder_sources()
+                    for seed_file in _seed_files(directory)
+                ]
+
+            for seed_file, prefix in files_to_run:
+                await _run_seeder(out, manager.provider, seed_file, prefix)
+
+        except Exception as e:  # noqa: BLE001 — any seeder failure is a CLI error
+            out.error(f"Seeder failed: {e}")
+            raise typer.Exit(1) from None
+        finally:
+            await manager.provider.shutdown()
+
+    asyncio.run(_run())
+
+
+@handle_errors
+def reset(
+    seed: bool = typer.Option(False, "--seed", help="Run seeders after reset"),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Force reset without confirmation",
+    ),
+    env: str | None = typer.Option("--env", "-e", help="Environment name"),
+) -> None:
+    """Drop and recreate the database."""
+    out = OutputManager()
+    if not force:
+        confirm = typer.confirm(
+            "Are you sure you want to reset the database? This will delete ALL data.",
+        )
+        if not confirm:
+            raise typer.Abort
+
+    async def _run() -> None:
+        manager = await db_bootstrap.get_migration_manager()
+        await manager.provider.boot()
+        try:
+            out.info("Resetting database...")
+
+            if "sqlite" in str(manager.provider.url):
+                res = await manager.provider.execute_query(
+                    "SELECT name FROM sqlite_master WHERE type='table'",
+                )
+                tables = [row["name"] for row in res.rows]
+                for table in tables:
+                    if table != "sqlite_sequence":
+                        out.print(f"[dim]Dropping table: {table}[/dim]")
+                        await manager.provider.execute(f"DROP TABLE {table}")
+            else:
+                out.warning(
+                    "Reset is only fully optimized for SQLite currently.",
+                )
+
+            out.success("Database cleared.")
+
+            await manager.initialize_migration_table()
+            applied = await manager.apply_pending_migrations()
+            if applied:
+                for v in applied:
+                    out.success(f"Applied {v}")
+            else:
+                out.info("No pending migrations.")
+
+            if seed:
+                sources = _seeder_sources()
+                if any(d.exists() for d, _ in sources):
+                    for directory, prefix in sources:
+                        for seed_file in _seed_files(directory):
+                            await _run_seeder(out, manager.provider, seed_file, prefix)
+                else:
+                    out.warning("No seeds directory found, skipping seed step.")
+
+        except Exception as e:  # noqa: BLE001 — any reset failure is a CLI error
+            out.error(f"Reset failed: {e}")
+            raise typer.Exit(1) from None
+        finally:
+            await manager.provider.shutdown()
+
+    asyncio.run(_run())
+
+
+@handle_errors
+def setup(
+    package: Annotated[
+        str | None,
+        typer.Option(
+            "--package", help="Only run setup for this package's contributions."
+        ),
+    ] = None,
+) -> None:
+    """Run schema setup for all installed packages that need database tables."""
+    asyncio.run(_run_setup(package))
+
+
+async def _run_setup(package: str | None) -> None:
+    from quadkit.cli.contributors.runtime import ContributorRuntime
+
+    out = OutputManager()
+    runtime = ContributorRuntime.from_entry_points()
+    contributions = runtime.schema_setups
+    if package:
+        contributions = [c for c in contributions if c.name.split(".")[0] == package]
+
+    if not contributions:
+        out.info("Nothing to do — no schema setup contributions discovered.")
+        return
+
+    db, provider = await db_bootstrap._bootstrap_db_provider()
+
+    failed = False
+    try:
+        for contribution in contributions:
+            outcome = await _run_one_schema_setup(contribution, db)
+            if outcome.status == SchemaSetupResult.CREATED:
+                out.success(f"{contribution.name}: created")
+            elif outcome.status == SchemaSetupResult.ALREADY_PRESENT:
+                out.info(f"{contribution.name}: already present")
+            else:
+                out.error(f"{contribution.name}: failed — {outcome.message}")
+                failed = True
+    finally:
+        await provider.shutdown()
+
+    if failed:
+        raise typer.Exit(1)
+
+
+async def _run_one_schema_setup(
+    contribution: SchemaSetupContribution,
+    db: DatabaseProviderProtocol,
+) -> SchemaSetupOutcome:
+    try:
+        module_path, _, fn_name = contribution.setup_fn_path.partition(":")
+        mod = importlib.import_module(module_path)
+        ensure_fn = getattr(mod, fn_name)
+        outcome: SchemaSetupOutcome = await ensure_fn(db)
+        return outcome
+    except Exception as exc:
+        return SchemaSetupOutcome(status=SchemaSetupResult.FAILED, message=str(exc))
+
+
+__all__ = ["reset", "seed", "setup"]

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/src/quadkit/cli/commands/new.py

@@ -32,7 +32,7 @@ def _valid_name(value: str, kind: str) -> str:
 def main(
     name: str = typer.Argument(..., help="Name of the project"),
     template: str = typer.Option(
-        "web-api",
+        "api",
         "--template",
         "-t",
         help=(
@@ -58,7 +58,7 @@ def main(
 
         selected_template = typer.prompt(
             "Select a template",
-            default="web-api",
+            default="api",
             type=click.Choice(template_names()),
         )
 

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/src/quadkit/cli/contributors/core.py

@@ -13,7 +13,7 @@ _GENERATOR_SPECS: tuple[tuple[str, str, str, str], ...] = (
         "provider",
         "Generate provider",
         "quadkit.cli.generators.provider:ProviderGenerator",
-        "src/providers",
+        "src/di",
     ),
     (
         "test",

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/src/quadkit/cli/generators/provider.py

@@ -20,9 +20,9 @@ class ProviderGenerator(GeneratorBase):
 
     name = "provider"
     description = "Generate provider"
-    default_output_dir = "src/providers"
+    default_output_dir = "src/di"
 
-    def __init__(self, output_dir: str | Path = "src/providers") -> None:
+    def __init__(self, output_dir: str | Path = "src/di") -> None:
         super().__init__(output_dir=output_dir)
 
     def generate(

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/src/quadkit/cli/layout.py

@@ -64,17 +64,48 @@ class ComponentDir:
 COMPONENTS: tuple[ComponentDir, ...] = (
     ComponentDir("admin/actions", "admin/actions", False, ("admin_action",)),
     ComponentDir("admin/resources", "admin/resources", False, ("admin_resource",)),
-    ComponentDir("audit", "audit", True, ("audited",)),
+    # Per-entity attachment: an audit log is written for one entity's table,
+    # so it belongs wherever that entity does (the rule `validators` states
+    # below). Cross-cutting `shared/` put it where every context could see a
+    # file only one of them owns.
+    ComponentDir("audit", "audit", False, ("audited",)),
+    # ``auth``, ``contracts`` and ``validators`` carry no generators on
+    # purpose: no registered generator writes there yet (the CLI ships
+    # ``provider`` and ``test``; subsystems contribute the rest), and a
+    # ``generators`` entry is the map's authorisation for a generator's
+    # declared output directory, so it should name a generator that exists.
+    # The rows are the map's answer for *placement and scope*, which is what
+    # the builder needed to delete its own copy of them
+    # (docs/upstream/2026-09-02-component-rows.md).
+    # API-key issuance and verification. Cross-cutting by definition: one
+    # key store, checked by every bounded context.
+    ComponentDir("auth", "auth", True, ()),
     ComponentDir("clients", "clients", False, ("api_client",)),
     ComponentDir("commands", "commands", False, ("command",)),
     ComponentDir("consumers", "consumers", False, ("message_consumer",)),
+    # Request/response schemas shared across controllers. They are the
+    # interface between a context and its callers, so they cannot be
+    # module-local without every consumer reaching across a boundary.
+    ComponentDir("contracts", "contracts", True, ()),
     ComponentDir("controllers", "controllers", False, ("controller",)),
+    # Cross-cutting DI providers. Every quadkit subsystem keeps its own
+    # provider at ``<subsystem>/di/provider.py`` (30 of them, no
+    # exceptions), so a generated provider reads like the framework it
+    # is built on. The ``providers`` row below is kept for projects
+    # that already generated into it.
+    ComponentDir("di", "di", True, ("provider",)),
     ComponentDir("domains", "domains", False, ("domain",)),
     ComponentDir("errors", "errors", True, ("error",)),
     ComponentDir("events", "events", False, ("event",)),
     ComponentDir("features", "features", True, ("feature_flag",)),
     ComponentDir("filters", "filters", True, ("exception_filter", "filter")),
-    ComponentDir("guards", "guards", False, ("auth_guard", "guard")),
+    # Cross-cutting, like ``filters`` above: ``@require_auth()`` decorates
+    # controllers in every bounded context, and the palette already scopes
+    # ``auth``/``role`` as shared kinds. While this row said module-local,
+    # the two answers met at generation time and a modular app containing
+    # an Auth Guard could not be generated at all (playground TASK-6 /
+    # MODULAR-3).
+    ComponentDir("guards", "guards", True, ("auth_guard", "guard")),
     ComponentDir("handlers", "handlers", False, ("event_handler",)),
     ComponentDir("health", "health", True, ("health",)),
     ComponentDir("interceptors", "interceptors", True, ("interceptor",)),
@@ -85,7 +116,9 @@ COMPONENTS: tuple[ComponentDir, ...] = (
     ComponentDir("pipelines", "pipelines", False, ("pipeline",)),
     ComponentDir("policies", "policies", False, ("auth_policy",)),
     ComponentDir("projections", "projections", False, ("projection",)),
-    ComponentDir("providers", "providers", True, ("provider",)),
+    # Superseded by the ``di`` row above; kept (with no generators) so a
+    # project that already has ``shared/providers/`` keeps resolving.
+    ComponentDir("providers", "providers", True, ()),
     ComponentDir("queries", "queries", False, ("query",)),
     ComponentDir(
         "repositories",
@@ -96,11 +129,25 @@ COMPONENTS: tuple[ComponentDir, ...] = (
     ComponentDir("sagas", "sagas", False, ("saga", "saga_step")),
     ComponentDir("schema", "schema", True, ("graphql",)),
     ComponentDir("schema/dataloaders", "schema/dataloaders", True, ("dataloader",)),
-    ComponentDir("search", "search", True, ("search_index",)),
+    # Per-entity attachment: a search index indexes one entity's fields.
+    ComponentDir("search", "search", False, ("search_index",)),
+    # Generated seeders live inside the application package so they are
+    # importable: a project boots them from its persistence provider, and
+    # `quadkit db seed` imports the same modules. ``seeds`` (project root)
+    # stays resolvable in ROOT_DIRS below, because that is where every
+    # project generated before 2026-09-23 kept them and where the command
+    # still looks second.
+    # Per-entity attachment: a seeder seeds exactly one entity, so it follows
+    # that entity into its module. `quadkit db seed` discovers seeders through
+    # the layout rather than a fixed path, so it finds them either way.
+    ComponentDir("seeders", "seeders", False, ("seeder",)),
     ComponentDir("services", "services", False, ("service",)),
     ComponentDir("storage/backends", "storage/backends", True, ("storage_driver",)),
     ComponentDir("tasks", "tasks", False, ("task",)),
     ComponentDir("tenancy", "tenancy", True, ("tenant_resolver",)),
+    # Per-entity rules. They know an entity's fields, so they belong
+    # wherever that entity belongs: module-local.
+    ComponentDir("validators", "validators", False, ()),
     ComponentDir(
         "vector/collections", "vector/collections", True, ("vector_collection",)
     ),
@@ -112,6 +159,10 @@ COMPONENTS: tuple[ComponentDir, ...] = (
 # Root-level output directories of the generator SDK (no ``src/`` prefix).
 ROOT_DIRS: tuple[tuple[str, tuple[str, ...]], ...] = (
     ("migrations/versions", ("migration",)),
+    # ``seeds`` is legacy-but-supported: the ``seeders`` component above is
+    # where the generator writes now, while this row keeps ``quadkit gen
+    # seeder --output seeds`` and projects generated before 2026-09-23
+    # resolvable. ``quadkit db seed`` looks here second.
     ("seeds", ("seeder",)),
     ("tests/unit", ("test",)),
 )

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/src/quadkit/cli/registry/presets.py

@@ -99,9 +99,9 @@ class FullStackPreset(PresetDefinition):
     """Full-stack application preset."""
 
     name = "fullstack"
-    description = "Complete web application with database, auth, cache, and messaging"
+    description = "Complete web application: auth, cache, storage, events, tasks, HTTP, monitoring"
     packages = packages_for(
-        "web", "sql", "auth", "admin", "cache", "tasks", "monitoring"
+        "web", "sql", "auth", "cache", "storage", "events", "tasks", "http", "monitor"
     )
     config = {
         "web": {"host": "0.0.0.0", "port": 8000},  # noqa: S104 — preset template default

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/src/quadkit/cli/registry/template.py

@@ -109,8 +109,10 @@ class FullStackTemplate(ProjectTemplate):
     """Full-stack application template."""
 
     name = "fullstack"
-    description = "Full application with auth, admin, and more"
-    packages = packages_for("web", "sql", "auth", "admin", "cache", "tasks", "monitor")
+    description = "Full application: auth, cache, storage, events, tasks, HTTP, monitoring"
+    packages = packages_for(
+        "web", "sql", "auth", "cache", "storage", "events", "tasks", "http", "monitor"
+    )
 
     def get_config(self) -> TemplateConfig:
         return TemplateConfig(
@@ -154,7 +156,7 @@ class TemplateRegistry:
         optional = (
             (GraphQLTemplate, ("sql", "graphql")),
             (WorkerTemplate, ("sql", "tasks", "queue")),
-            (FullStackTemplate, ("web", "sql", "auth", "admin", "cache", "tasks")),
+            (FullStackTemplate, ("web", "sql", "auth", "cache", "storage", "events", "tasks", "http", "monitor")),
         )
         for entry, features in optional:
             if all(provider_available(feature) for feature in features):

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/src/quadkit/cli/scaffold/module_files.py

@@ -17,7 +17,17 @@ from quadkit.cli.scaffold.specs import ProjectTemplateSpec
 
 
 def _package_line(package: str, generators: tuple[str, ...]) -> str:
+    """Docstring for a pre-created package.
+
+    A shared row can exist with no generator behind it (``contracts``,
+    ``auth``): the map answers *where* the package lives, and the code that
+    fills it is written by hand or by a tool outside the CLI. Saying
+    "Writers:  (quadkit gen)" in that case would advertise a command that
+    does not exist.
+    """
     names = ", ".join(generators)
+    if not names:
+        return f'"""{package} package."""\n'
     return f'"""{package} package.\n\nWriters: {names} (quadkit gen)."""\n'
 
 
@@ -32,7 +42,14 @@ def _component_files(package_name: str) -> dict[str, str]:
     """
     files: dict[str, str] = {}
     for component in COMPONENTS:
-        if component.shared:
+        # A shared row with no generator behind it is a *resolution* row, not
+        # a package the scaffold creates: `providers` exists so a project
+        # generated into it before the `di` row landed keeps resolving, and
+        # `auth`/`contracts` exist because the map is where a project's
+        # cross-cutting packages are declared -- nothing in the CLI writes
+        # there, so pre-creating them would put an unexplained empty package
+        # in every fresh project and change the scaffold for existing users.
+        if component.shared and component.generators:
             path = f"src/{package_name}/shared/{component.modular}"
             files[f"{path}/__init__.py"] = _package_line(
                 f"{component.modular} (shared)", component.generators

{quadkit_cli-0.0.41 → quadkit_cli-0.0.43}/src/quadkit/cli/scaffold/specs.py

@@ -121,18 +121,20 @@ _TEMPLATE_SPECS: dict[str, ProjectTemplateSpec] = {
     ),
     "full": _spec(
         "full",
-        "Full application with auth, admin, feature flags, cache, tasks, and SQL",
+        "Full application: auth, cache, storage, events, tasks, HTTP, monitoring, and SQL",
         _dependencies(
             "web",
             "sql",
             "auth",
-            "admin",
-            "features",
             "cache",
+            "storage",
+            "events",
             "tasks",
+            "http",
+            "monitor",
             tools=("uvicorn",),
         ),
-        frozenset({"web", "sql", "auth", "admin", "features", "cache", "tasks"}),
+        frozenset({"web", "sql", "auth", "cache", "storage", "events", "tasks", "http", "monitor"}),
         (
             (
                 "Auth ships with dev secret keys; replace QK_AUTH__SECRET_KEY "