ignition-stack 0.1.0__py3-none-any.whl

ignition_stack/postsetup/generator.py

@@ -0,0 +1,187 @@
+"""Matrix-driven ``POST-SETUP.md`` generator.
+
+``ignition-stack`` pre-seeds every connection the Phase-1 seedability matrix
+marks file-seedable (db-connection, the internal-secret-provider that holds
+its password, OPC-UA endpoints, ...). The connections it *cannot* fully seed -
+a secret generated at runtime, a module that isn't publicly downloadable, a
+gateway-network handshake approved in the UI - are deferred to ``POST-SETUP.md``
+and finished by hand once the stack is up.
+
+This module turns the deferred set into that document. It is purely a function
+of the resolved :class:`~ignition_stack.config.schema.ProjectConfig`:
+
+1. Each catalog service's manifest declares its deferred connections in
+   ``post_setup`` (a list of ``connection``/``reason`` pairs). The database and
+   every selected service contribute theirs.
+2. Three profile-level flags add steps the matrix flags as not-fully-seedable:
+   ``profile == "scaleout"`` (the gateway-network link is UI-approved),
+   ``mcp_dropin`` (the EA-gated MCP module), and a set ``reverse_proxy`` (the
+   Traefik scaffold).
+
+Each step renders through a per-connection Jinja2 snippet at
+``templates/post-setup/<connection>.md.j2`` (falling back to ``_default.md.j2``)
+so adding a new fallback connection is a manifest entry + a snippet, with no
+change here. Every snippet gives the reader the three things the validation
+contract requires: the **deep-link URL** to open, the **in-UI screen path** to
+navigate to, and the exact **``.env`` variable name** to copy.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from jinja2 import Environment, PackageLoader, StrictUndefined, TemplateNotFound
+
+from ignition_stack.config.schema import ProjectConfig
+from ignition_stack.services.loader import load_all_services
+
+_HEADER = """\
+# Post-setup steps
+
+`ignition-stack` pre-seeds everything the Phase-1 seedability matrix marks
+file-seedable. The connections below carry a secret or a handshake that
+cannot travel in a file, so finish them by hand after `docker compose up -d`.
+Each step names the screen to open and the `.env` value to copy into it.
+"""
+
+_NO_MANUAL_STEPS = """\
+# Post-setup steps
+
+**No manual steps required.** Every connection in this stack is pre-seeded
+from files. Bring it up with `docker compose up -d` and the gateway is ready.
+"""
+
+# Reasons for the profile-level steps that aren't tied to a single service
+# manifest. Kept here (not in a manifest) because they're a property of the
+# resolved topology, not of any one catalog entry.
+_GATEWAY_NETWORK_LINK_REASON = (
+    "The Phase-1 matrix marks the gateway-network-link row partial: each "
+    "gateway's UUID and the outbound peer-link path are file-seeded, but the "
+    "per-link approval happens in the gateway UI, so the frontend<->backend "
+    "link is finished by hand."
+)
+_MCP_MODULE_REASON = (
+    "The Ignition MCP module is Early-Access and gated behind a survey, so the "
+    "CLI cannot bundle it. Request the .modl, drop it in, and re-up the stack."
+)
+_REVERSE_PROXY_REASON = (
+    "The CLI never clones a proxy silently. The wizard scaffolded a README that "
+    "walks through installing ia-eknorr/traefik-reverse-proxy in front of the "
+    "stack."
+)
+
+
+@dataclass(frozen=True)
+class _Step:
+    """One manual follow-up: a deferred connection plus why it's deferred.
+
+    ``service`` is the catalog slug the step came from (so the renderer can pull
+    that service's ``.env`` keys), or ``""`` for the profile-level steps that
+    aren't owned by a single service.
+    """
+
+    connection: str
+    reason: str
+    service: str
+
+
+def generate_post_setup(config: ProjectConfig) -> str:
+    """Render the body of ``POST-SETUP.md`` for a resolved project config.
+
+    Always returns a document: a "no manual steps required" note when the stack
+    is fully seedable, or a header plus one section per deferred connection.
+    """
+    steps = _collect_steps(config)
+    if not steps:
+        return _NO_MANUAL_STEPS
+
+    env = _jinja_env()
+    sections = [_render_step(env, _context(config, step)) for step in steps]
+    return _HEADER + "\n" + "\n\n".join(sections) + "\n"
+
+
+def _collect_steps(config: ProjectConfig) -> list[_Step]:
+    """Gather every deferred connection, service steps first then profile steps."""
+    catalog = load_all_services()
+    steps: list[_Step] = []
+
+    # Database slug == its kind (postgres/mysql/mariadb/mongo); the catalog is
+    # keyed the same way, so look both up by slug.
+    slugs: list[str] = []
+    if config.database is not None:
+        slugs.append(config.database.kind)
+    slugs.extend(config.services)
+
+    for slug in slugs:
+        manifest = catalog.get(slug)
+        if manifest is None:
+            continue
+        for item in manifest.post_setup:
+            steps.append(_Step(item.connection, item.reason, slug))
+
+    if config.profile == "scaleout":
+        steps.append(_Step("gateway-network-link", _GATEWAY_NETWORK_LINK_REASON, ""))
+    if config.mcp_dropin:
+        steps.append(_Step("mcp-module", _MCP_MODULE_REASON, ""))
+    if config.reverse_proxy is not None:
+        steps.append(_Step("reverse-proxy", _REVERSE_PROXY_REASON, ""))
+
+    return steps
+
+
+def _context(config: ProjectConfig, step: _Step) -> dict[str, object]:
+    """Build the render context one snippet sees.
+
+    ``env_vars`` is the (key, value) list the reader copies into the gateway
+    screen: a service step exposes that service's preset ``.env`` keys; the
+    gateway-network-link step exposes ``COMPOSE_PROJECT_NAME`` (the link target
+    is named after the compose project); the rest copy nothing.
+    """
+    catalog = load_all_services()
+    gateways = [
+        {
+            "name": gw.name,
+            "role": gw.role or gw.name,
+            "edition": gw.ignition_edition,
+            "url": f"http://localhost:{gw.http_port}",
+        }
+        for gw in config.gateways
+    ]
+
+    if step.service:
+        env_vars = sorted(catalog[step.service].env.items())
+    elif step.connection == "gateway-network-link":
+        env_vars = [("COMPOSE_PROJECT_NAME", config.name)]
+    else:
+        env_vars = []
+
+    return {
+        "project_name": config.name,
+        "connection": step.connection,
+        "reason": step.reason,
+        "service": step.service,
+        "gateway_url": gateways[0]["url"],
+        "gateways": gateways,
+        "env_vars": env_vars,
+        "env_map": dict(env_vars),
+        "proxy_path": config.reverse_proxy.path if config.reverse_proxy else "",
+        "dropin_dir": "modules/dropin",
+    }
+
+
+def _render_step(env: Environment, ctx: dict[str, object]) -> str:
+    connection = ctx["connection"]
+    try:
+        template = env.get_template(f"{connection}.md.j2")
+    except TemplateNotFound:
+        template = env.get_template("_default.md.j2")
+    return template.render(**ctx).rstrip()
+
+
+def _jinja_env() -> Environment:
+    return Environment(
+        loader=PackageLoader("ignition_stack.templates", "post-setup"),
+        undefined=StrictUndefined,
+        keep_trailing_newline=True,
+        autoescape=False,
+    )

ignition_stack/profiles/__init__.py

@@ -0,0 +1,27 @@
+"""Architecture profiles: pre-canned shapes that turn intent into config.
+
+Importing this package registers every built-in profile by side-effect so
+``get_profile("scaleout")`` works without explicit module imports.
+"""
+
+from ignition_stack.profiles import hub_and_spoke, mcp_n8n, scaleout, standalone  # noqa: F401
+from ignition_stack.profiles.advisory import Advisory, spoke_advisory
+from ignition_stack.profiles.base import (
+    Profile,
+    ProfileOptions,
+    build_profile,
+    get_profile,
+    list_profiles,
+)
+from ignition_stack.profiles.hub_and_spoke import ProfileError
+
+__all__ = [
+    "Advisory",
+    "Profile",
+    "ProfileError",
+    "ProfileOptions",
+    "build_profile",
+    "get_profile",
+    "list_profiles",
+    "spoke_advisory",
+]

ignition_stack/profiles/advisory.py

@@ -0,0 +1,132 @@
+"""Hub-and-spoke RAM advisory.
+
+The hub-and-spoke profile spins up one hub gateway plus *N* spokes; each
+Ignition gateway needs ~1.5 GB to run comfortably. The advisory turns that
+math into a proportional friction signal so SEs can see the cost of a
+large demo without being silently blocked when they really do want it:
+
+- **green** (≤4 spokes): the common case; proceed without prompting.
+- **yellow** (5-8 spokes): show the advisory, ask the user to confirm.
+- **red** (≥9 spokes): refuse unless ``--force`` is set, with a message
+  explaining the RAM estimate.
+
+The actual *threshold* is the spoke count (per the design's tiered-advisory
+decision); the RAM math is folded into the message so the user understands
+*why* the tier landed where it did. ``available_bytes`` is injectable so
+tests don't depend on the host's free memory.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+import psutil
+
+Tier = Literal["green", "yellow", "red"]
+
+# A single Ignition gateway needs ~1.5 GB at idle (anchor heap = 2 GB default
+# memory_mb, plus JVM overhead). The advisory estimate stays conservative
+# enough that "fits in available RAM" is a real signal, not a worst-case wall.
+_BYTES_PER_GATEWAY = 1_500 * 1024 * 1024
+
+# Tier thresholds by spoke count (1 hub + N spokes). Closed intervals; ties go
+# to the lower tier (5 spokes is yellow, 9 spokes is red).
+_YELLOW_MIN_SPOKES = 5
+_RED_MIN_SPOKES = 9
+
+
+@dataclass(frozen=True)
+class Advisory:
+    """Outcome of evaluating a hub-and-spoke spoke count.
+
+    ``tier`` drives the CLI flow (green = proceed silently; yellow = confirm;
+    red = exit non-zero unless --force). ``message`` is the human-readable
+    explanation suitable for stderr or a confirm prompt; it always references
+    the totals so the user sees the math.
+    """
+
+    tier: Tier
+    spoke_count: int
+    total_gateways: int
+    estimated_gb: float
+    available_gb: float
+    message: str
+
+
+def spoke_advisory(spoke_count: int, available_bytes: int | None = None) -> Advisory:
+    """Compute the advisory for ``spoke_count`` spoke gateways.
+
+    ``available_bytes`` defaults to ``psutil.virtual_memory().available`` so
+    callers don't have to reach for psutil themselves. Tests pass a concrete
+    value to make tier+message assertions deterministic.
+
+    Raises ``ValueError`` for negative spoke counts; zero is allowed (a
+    hub-only stack, which is just standalone in disguise but the user might
+    pick it explicitly during exploration).
+    """
+    if spoke_count < 0:
+        raise ValueError(f"spoke_count must be >= 0, got {spoke_count}")
+
+    if available_bytes is None:
+        available_bytes = psutil.virtual_memory().available
+
+    total_gateways = 1 + spoke_count
+    estimated_bytes = total_gateways * _BYTES_PER_GATEWAY
+    estimated_gb = estimated_bytes / (1024**3)
+    available_gb = available_bytes / (1024**3)
+
+    tier = _tier_for(spoke_count)
+    message = _message_for(tier, spoke_count, total_gateways, estimated_gb, available_gb)
+    return Advisory(
+        tier=tier,
+        spoke_count=spoke_count,
+        total_gateways=total_gateways,
+        estimated_gb=estimated_gb,
+        available_gb=available_gb,
+        message=message,
+    )
+
+
+def _tier_for(spoke_count: int) -> Tier:
+    if spoke_count >= _RED_MIN_SPOKES:
+        return "red"
+    if spoke_count >= _YELLOW_MIN_SPOKES:
+        return "yellow"
+    return "green"
+
+
+def _message_for(
+    tier: Tier,
+    spoke_count: int,
+    total_gateways: int,
+    estimated_gb: float,
+    available_gb: float,
+) -> str:
+    """Render the advisory message for the given tier.
+
+    Keep these short and concrete: the user sees ``message`` on stderr (red)
+    or inside a confirm prompt (yellow); green callers usually skip it
+    entirely. Mention spoke count, total gateways, the RAM estimate, and what
+    happens next (proceed / confirm / --force).
+    """
+    estimate = f"{total_gateways} gateways x ~1.5 GB = ~{estimated_gb:.1f} GB needed"
+    available = f"{available_gb:.1f} GB available on this host"
+
+    if tier == "green":
+        return f"Hub-and-spoke with {spoke_count} spoke(s). {estimate}; {available}. Proceeding."
+    if tier == "yellow":
+        return (
+            f"Hub-and-spoke with {spoke_count} spokes is a heavy demo: "
+            f"{estimate}, {available}. "
+            f"Each gateway has its own JVM, so memory pressure stacks up fast. "
+            f"Confirm to proceed."
+        )
+    # red
+    return (
+        f"Hub-and-spoke with {spoke_count} spokes ({total_gateways} gateways total) "
+        f"needs ~{estimated_gb:.1f} GB; this host has ~{available_gb:.1f} GB available. "
+        f"Stacks this large routinely OOM-kill gateways at startup and are slow to "
+        f"demo from. Re-run with --force if you really need this many spokes, or "
+        f"drop to <= 8."
+    )

ignition_stack/profiles/base.py

@@ -0,0 +1,108 @@
+"""Profile contract + options + registry.
+
+A *profile* is the small piece of code that turns the user's high-level
+intent ("scaleout", "hub-and-spoke with 3 spokes", "mcp-n8n demo") into a
+fully-formed :class:`ProjectConfig`. The compose engine and the dependency
+resolver are profile-agnostic; profiles only shape the inputs they take.
+
+Two-stage pipeline:
+
+1. Either the CLI flags or the wizard answers populate a
+   :class:`ProfileOptions` and pick a profile slug.
+2. ``build_profile(slug, name, options)`` looks up the profile and calls
+   its ``build()`` method, returning a ``ProjectConfig`` that
+   ``services.resolver.resolve()`` then expands the usual implicit deps on.
+
+Each profile is a small dataclass with three pieces:
+
+- ``slug`` - the wizard/flag value users type.
+- ``summary`` - one-line description for the wizard menu + docs.
+- ``build`` - pure function ``(name, options) -> ProjectConfig``.
+
+Keeping ``build`` pure (no I/O, no prompts) is what lets the wizard layer
+and the CLI flag layer share the same code path and stay testable.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+from ignition_stack.config import ProjectConfig, ReverseProxyConfig
+
+
+@dataclass(frozen=True)
+class ProfileOptions:
+    """Inputs each profile reads to shape the resolved config.
+
+    Every field has a sensible default so callers only set what they
+    actually care about. The wizard fills in many of these from prompts;
+    the non-interactive CLI path fills in a subset from flags and leaves
+    the rest at their defaults.
+    """
+
+    spokes: int = 3
+    """Hub-and-spoke spoke count. Ignored by other profiles."""
+
+    force: bool = False
+    """Bypass the hub-and-spoke red-tier advisory. Ignored elsewhere."""
+
+    edge_role: str | None = None
+    """Which gateway role (if any) runs the Edge edition.
+
+    For scaleout this is typically 'frontend'; for hub-and-spoke it can
+    be 'spoke' (every spoke runs Edge) or None. The profile is free to
+    apply its own default when this is None.
+    """
+
+    reverse_proxy: ReverseProxyConfig | None = None
+    """Reverse-proxy scaffolding. None = plain host-port mapping."""
+
+    database_kind: str | None = "postgres"
+    """SQL database for the stack. None = no database (gateway-only)."""
+
+    services: tuple[str, ...] = ()
+    """Additional service catalog slugs the user picked beyond profile defaults."""
+
+
+class Profile(Protocol):
+    """A factory that turns ``ProfileOptions`` into a ``ProjectConfig``."""
+
+    slug: str
+    summary: str
+
+    def build(self, name: str, options: ProfileOptions) -> ProjectConfig: ...
+
+
+# Registry populated by the profile modules at import time. Keep alphabetical
+# insertion-order for stable wizard menus + --help listings.
+_REGISTRY: dict[str, Profile] = {}
+
+
+def register(profile: Profile) -> Profile:
+    """Register a profile by slug. Returns the profile so module-level uses
+    can write ``standalone = register(StandaloneProfile())``.
+    """
+    if profile.slug in _REGISTRY:
+        raise ValueError(f"profile '{profile.slug}' is already registered")
+    _REGISTRY[profile.slug] = profile
+    return profile
+
+
+def get_profile(slug: str) -> Profile:
+    """Look up a registered profile by slug. Raises ``KeyError`` if unknown."""
+    try:
+        return _REGISTRY[slug]
+    except KeyError as exc:
+        known = ", ".join(sorted(_REGISTRY))
+        raise KeyError(f"unknown profile '{slug}'; known profiles: {known}") from exc
+
+
+def list_profiles() -> list[Profile]:
+    """All registered profiles in stable insertion order."""
+    return list(_REGISTRY.values())
+
+
+def build_profile(slug: str, name: str, options: ProfileOptions) -> ProjectConfig:
+    """Materialize a ``ProjectConfig`` for the named profile."""
+    return get_profile(slug).build(name, options)

ignition_stack/profiles/hub_and_spoke.py

@@ -0,0 +1,87 @@
+"""Hub-and-spoke profile: 1 central hub + N spoke gateways.
+
+Edge gateways typically run as the spokes (lightweight, deployed close to
+the data); the hub aggregates them. Per the design's tiered-advisory
+decision, the spoke count drives an advisory: green ≤4, yellow 5-8, red
+≥9 (refuses without ``--force``). The advisory itself lives in
+:mod:`ignition_stack.profiles.advisory`; this profile wires it into the
+build path so a bare ``build()`` raises ``ProfileError`` on the red tier
+unless ``options.force`` is set.
+
+Reverse-proxy / database / services flow through the standard
+``ProfileOptions`` contract; a hub-and-spoke stack is just a multi-gateway
+arrangement with a specific role layout and the advisory gate.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ignition_stack.config import DatabaseConfig, GatewayConfig, ProjectConfig
+from ignition_stack.profiles.advisory import Advisory, spoke_advisory
+from ignition_stack.profiles.base import Profile, ProfileOptions, register
+
+
+class ProfileError(Exception):
+    """Raised when a profile's preconditions are not met.
+
+    The CLI catches this and exits non-zero with the message. Carries the
+    advisory (for hub-and-spoke red-tier) so callers can surface tier +
+    counts alongside the message.
+    """
+
+    def __init__(self, message: str, advisory: Advisory | None = None) -> None:
+        super().__init__(message)
+        self.advisory = advisory
+
+
+@dataclass(frozen=True)
+class HubAndSpokeProfile:
+    slug: str = "hub-and-spoke"
+    summary: str = "Central hub gateway + N Edge spoke gateways. Spoke count > 8 needs --force."
+
+    def build(self, name: str, options: ProfileOptions) -> ProjectConfig:
+        advisory = spoke_advisory(options.spokes)
+        if advisory.tier == "red" and not options.force:
+            raise ProfileError(advisory.message, advisory=advisory)
+
+        # Hub is a standard gateway; spokes default to Edge unless the user
+        # explicitly opted them out via edge_role.
+        spokes_run_edge = options.edge_role != "hub" and options.edge_role != "none"
+        gateways: list[GatewayConfig] = [
+            GatewayConfig(
+                name="hub",
+                role="hub",
+                ignition_edition="standard",
+                http_port=9088,
+            )
+        ]
+        # Spoke ports start at 9089 and step up - one host port per spoke so
+        # the SE can hit any of them directly from the laptop.
+        for i in range(1, options.spokes + 1):
+            gateways.append(
+                GatewayConfig(
+                    name=f"spoke-{i}",
+                    role="spoke",
+                    ignition_edition="edge" if spokes_run_edge else "standard",
+                    http_port=9088 + i,
+                )
+            )
+
+        return ProjectConfig(
+            name=name,
+            profile=self.slug,
+            gateways=gateways,
+            database=_database(options),
+            services=list(options.services),
+            reverse_proxy=options.reverse_proxy,
+        )
+
+
+def _database(options: ProfileOptions) -> DatabaseConfig | None:
+    if options.database_kind is None:
+        return None
+    return DatabaseConfig(kind=options.database_kind)
+
+
+profile: Profile = register(HubAndSpokeProfile())

ignition_stack/profiles/mcp_n8n.py

@@ -0,0 +1,55 @@
+"""MCP + n8n profile: one Ignition gateway, n8n, and a manual MCP drop-in.
+
+The Ignition MCP module is EA-gated (no public download URL while in Early
+Access), so this profile scaffolds a ``modules/dropin/`` directory and adds
+a POST-SETUP entry pointing at the survey, per the resolved
+[q-mcp-delivery](02-design.md#q-mcp-delivery) decision. The user drops the
+``.modl`` file into that directory before ``docker compose up``; the
+bootstrap copies anything it finds in ``modules/cache`` AND in the drop-in
+dir into the gateway volume.
+
+Structurally this is a single-gateway stack plus the n8n service catalog
+entry; the ``mcp_dropin`` flag on ``ProjectConfig`` is what triggers the
+writer to lay down the drop-in README + a POST-SETUP stub.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ignition_stack.config import DatabaseConfig, GatewayConfig, ProjectConfig
+from ignition_stack.profiles.base import Profile, ProfileOptions, register
+
+
+@dataclass(frozen=True)
+class McpN8nProfile:
+    slug: str = "mcp-n8n"
+    summary: str = "One Ignition gateway + n8n + manual MCP (EA) module drop-in."
+
+    def build(self, name: str, options: ProfileOptions) -> ProjectConfig:
+        gateway = GatewayConfig()
+        if options.edge_role in {"gateway", "standalone"}:
+            gateway = gateway.model_copy(update={"ignition_edition": "edge"})
+
+        services = list(options.services)
+        if "n8n" not in services:
+            services.insert(0, "n8n")
+
+        return ProjectConfig(
+            name=name,
+            profile=self.slug,
+            gateways=[gateway],
+            database=_database(options),
+            services=services,
+            mcp_dropin=True,
+            reverse_proxy=options.reverse_proxy,
+        )
+
+
+def _database(options: ProfileOptions) -> DatabaseConfig | None:
+    if options.database_kind is None:
+        return None
+    return DatabaseConfig(kind=options.database_kind)
+
+
+profile: Profile = register(McpN8nProfile())

ignition_stack/profiles/scaleout.py

@@ -0,0 +1,65 @@
+"""Scaleout profile: frontend + backend Ignition gateways networked together.
+
+Two roles: ``frontend`` (user-facing UI / OPC-UA aggregation) defaults to
+the Edge edition because that's the canonical scaleout shape in the field;
+``backend`` runs the standard edition with the database connection. Both
+gateways join the frontend AND backend networks so the frontend can reach
+the DB the backend owns. The network split is on by default - that's the
+whole point of the scaleout demo.
+
+The plan's validation calls for "two networked gateways (frontend + backend)
++ a DB; the gateway-network link config is present per the Phase-1 matrix";
+the gateway-network link itself is a follow-up resource set the seeding
+matrix marks ``file-seedable-config: yes``, so it travels with the
+``gateway-resources/`` overlay once that catalog grows. Today the
+``services`` list is empty by default; users add brokers/IDPs on top.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ignition_stack.config import DatabaseConfig, GatewayConfig, ProjectConfig
+from ignition_stack.profiles.base import Profile, ProfileOptions, register
+
+
+@dataclass(frozen=True)
+class ScaleoutProfile:
+    slug: str = "scaleout"
+    summary: str = "Frontend + backend Ignition gateways via gateway network + Postgres."
+
+    def build(self, name: str, options: ProfileOptions) -> ProjectConfig:
+        edge_role = options.edge_role if options.edge_role is not None else "frontend"
+        gateways = [
+            GatewayConfig(
+                name="frontend",
+                role="frontend",
+                ignition_edition="edge" if edge_role == "frontend" else "standard",
+                http_port=9088,
+            ),
+            GatewayConfig(
+                name="backend",
+                role="backend",
+                ignition_edition="edge" if edge_role == "backend" else "standard",
+                http_port=9089,
+            ),
+        ]
+
+        return ProjectConfig(
+            name=name,
+            profile=self.slug,
+            network_split=True,
+            gateways=gateways,
+            database=_database(options),
+            services=list(options.services),
+            reverse_proxy=options.reverse_proxy,
+        )
+
+
+def _database(options: ProfileOptions) -> DatabaseConfig | None:
+    if options.database_kind is None:
+        return None
+    return DatabaseConfig(kind=options.database_kind)
+
+
+profile: Profile = register(ScaleoutProfile())