svc-infra 0.1.600__py3-none-any.whl → 0.1.640__py3-none-any.whl

svc_infra/cli/cmds/db/sql/sql_export_cmds.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Optional
+
+import typer
+from sqlalchemy import text
+
+from svc_infra.db.sql.utils import build_engine
+
+try:  # SQLAlchemy async extras are optional
+    from sqlalchemy.ext.asyncio import AsyncEngine
+except Exception:  # pragma: no cover - fallback when async extras unavailable
+    AsyncEngine = None  # type: ignore[assignment]
+
+
+def export_tenant(
+    table: str = typer.Argument(..., help="Qualified table name to export (e.g., public.items)"),
+    tenant_id: str = typer.Option(..., "--tenant-id", help="Tenant id value to filter by."),
+    tenant_field: str = typer.Option("tenant_id", help="Column name for tenant id filter."),
+    output: Optional[Path] = typer.Option(
+        None, "--output", help="Output file; defaults to stdout."
+    ),
+    limit: Optional[int] = typer.Option(None, help="Max rows to export."),
+    database_url: Optional[str] = typer.Option(
+        None, "--database-url", help="Overrides env SQL_URL for this command."
+    ),
+):
+    """Export rows for a tenant from a given SQL table as JSON array."""
+    if database_url:
+        os.environ["SQL_URL"] = database_url
+
+    url = os.getenv("SQL_URL")
+    if not url:
+        typer.echo("SQL_URL is required (or pass --database-url)", err=True)
+        raise typer.Exit(code=2)
+
+    engine = build_engine(url)
+    rows: list[dict[str, Any]]
+    query = f"SELECT * FROM {table} WHERE {tenant_field} = :tenant_id"
+    if limit and limit > 0:
+        query += " LIMIT :limit"
+
+    params: dict[str, Any] = {"tenant_id": tenant_id}
+    if limit and limit > 0:
+        params["limit"] = int(limit)
+
+    stmt = text(query)
+
+    is_async_engine = AsyncEngine is not None and isinstance(engine, AsyncEngine)
+
+    if is_async_engine:
+        assert AsyncEngine is not None  # for type checkers
+
+        async def _fetch() -> list[dict[str, Any]]:
+            async with engine.connect() as conn:  # type: ignore[call-arg]
+                result = await conn.execute(stmt, params)
+                return [dict(row) for row in result.mappings()]
+
+        rows = asyncio.run(_fetch())
+    else:
+        with engine.connect() as conn:  # type: ignore[attr-defined]
+            result = conn.execute(stmt, params)
+            rows = [dict(row) for row in result.mappings()]
+
+    data = json.dumps(rows, indent=2)
+    if output:
+        output.write_text(data)
+        typer.echo(str(output))
+    else:
+        sys.stdout.write(data)
+
+
+def register(app_root: typer.Typer) -> None:
+    # Attach directly to the provided 'sql' group app
+    app_root.command("export-tenant")(export_tenant)

svc_infra/cli/cmds/db/sql/sql_scaffold_cmds.py

@@ -134,6 +134,6 @@ def cmd_scaffold_schemas(
 
 
 def register(app: typer.Typer) -> None:
-    app.command("sql-scaffold")(cmd_scaffold)
-    app.command("sql-scaffold-models")(cmd_scaffold_models)
-    app.command("sql-scaffold-schemas")(cmd_scaffold_schemas)
+    app.command("scaffold")(cmd_scaffold)
+    app.command("scaffold-models")(cmd_scaffold_models)
+    app.command("scaffold-schemas")(cmd_scaffold_schemas)

svc_infra/cli/cmds/docs/docs_cmds.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import os
+from importlib.resources import as_file
+from importlib.resources import files as pkg_files
+from pathlib import Path
+from typing import Dict, List
+
+import click
+import typer
+from typer.core import TyperGroup
+
+from svc_infra.app.root import resolve_project_root
+
+
+def _norm(name: str) -> str:
+    return name.strip().lower().replace(" ", "-").replace("_", "-")
+
+
+def _discover_fs_topics(docs_dir: Path) -> Dict[str, Path]:
+    topics: Dict[str, Path] = {}
+    if docs_dir.exists() and docs_dir.is_dir():
+        for p in sorted(docs_dir.glob("*.md")):
+            if p.is_file():
+                topics[_norm(p.stem)] = p
+    return topics
+
+
+def _discover_pkg_topics() -> Dict[str, Path]:
+    """
+    Discover docs shipped inside the installed package at svc_infra/docs/*,
+    using importlib.resources so this works for wheels, sdists, and zipped wheels.
+    """
+    topics: Dict[str, Path] = {}
+    try:
+        docs_root = pkg_files("svc_infra").joinpath("docs")
+        # docs_root is a Traversable; it may be inside a zip. Iterate safely.
+        for entry in docs_root.iterdir():
+            if entry.name.endswith(".md"):
+                # materialize to a real tempfile path if needed
+                with as_file(entry) as concrete:
+                    p = Path(concrete)
+                    if p.exists() and p.is_file():
+                        topics[_norm(p.stem)] = p
+    except Exception:
+        # If the package has no docs directory, just return empty.
+        pass
+    return topics
+
+
+def _resolve_docs_dir(ctx: click.Context) -> Path | None:
+    """
+    Optional override precedence:
+      1) SVC_INFRA_DOCS_DIR env var
+      2) *Only when working inside the svc-infra repo itself*: repo-root /docs
+    """
+    # 1) Env var
+    env_dir = os.getenv("SVC_INFRA_DOCS_DIR")
+    if env_dir:
+        p = Path(env_dir).expanduser()
+        if p.exists():
+            return p
+
+    # 2) In-repo convenience (so `svc-infra docs` works inside this repo)
+    try:
+        root = resolve_project_root()
+        proj_docs = root / "docs"
+        if proj_docs.exists():
+            return proj_docs
+    except Exception:
+        pass
+
+    return None
+
+
+class DocsGroup(TyperGroup):
+    def list_commands(self, ctx: click.Context) -> List[str]:
+        names: List[str] = list(super().list_commands(ctx) or [])
+        dir_to_use = _resolve_docs_dir(ctx)
+        fs = _discover_fs_topics(dir_to_use) if dir_to_use else {}
+        pkg = _discover_pkg_topics()
+        names.extend(fs.keys())
+        names.extend([k for k in pkg.keys() if k not in fs])
+        return sorted(set(names))
+
+    def get_command(self, ctx: click.Context, name: str) -> click.Command | None:
+        cmd = super().get_command(ctx, name)
+        if cmd is not None:
+            return cmd
+
+        key = _norm(name)
+
+        dir_to_use = _resolve_docs_dir(ctx)
+        fs = _discover_fs_topics(dir_to_use) if dir_to_use else {}
+        if key in fs:
+            file_path = fs[key]
+
+            @click.command(name=name)
+            def _show_fs() -> None:
+                click.echo(file_path.read_text(encoding="utf-8", errors="replace"))
+
+            return _show_fs
+
+        pkg = _discover_pkg_topics()
+        if key in pkg:
+            file_path = pkg[key]
+
+            @click.command(name=name)
+            def _show_pkg() -> None:
+                click.echo(file_path.read_text(encoding="utf-8", errors="replace"))
+
+            return _show_pkg
+
+        return None
+
+
+def register(app: typer.Typer) -> None:
+    docs_app = typer.Typer(no_args_is_help=True, add_completion=False, cls=DocsGroup)
+
+    @docs_app.callback(invoke_without_command=True)
+    def _docs_options() -> None:
+        # No group-level options; dynamic commands and 'show' handle topics.
+        return None
+
+    @docs_app.command("show", help="Show docs for a topic (alternative to dynamic subcommand)")
+    def show(topic: str) -> None:
+        key = _norm(topic)
+        ctx = click.get_current_context()
+        dir_to_use = _resolve_docs_dir(ctx)
+        fs = _discover_fs_topics(dir_to_use) if dir_to_use else {}
+        if key in fs:
+            typer.echo(fs[key].read_text(encoding="utf-8", errors="replace"))
+            return
+        pkg = _discover_pkg_topics()
+        if key in pkg:
+            typer.echo(pkg[key].read_text(encoding="utf-8", errors="replace"))
+            return
+        raise typer.BadParameter(f"Unknown topic: {topic}")
+
+    app.add_typer(docs_app, name="docs")

svc_infra/cli/cmds/dx/__init__.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import typer
+
+from .dx_cmds import app as dx_app
+
+
+def register_dx(root: typer.Typer) -> None:
+    root.add_typer(dx_app, name="dx")
+
+
+__all__ = ["register_dx"]

svc_infra/cli/cmds/dx/dx_cmds.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import typer
+
+from svc_infra.dx.changelog import Commit, generate_release_section
+from svc_infra.dx.checks import check_migrations_up_to_date, check_openapi_problem_schema
+
+app = typer.Typer(no_args_is_help=True, add_completion=False)
+
+
+@app.command("openapi")
+def cmd_openapi(path: str = typer.Argument(..., help="Path to OpenAPI JSON")):
+    try:
+        check_openapi_problem_schema(path=path)
+    except Exception as e:  # noqa: BLE001
+        typer.secho(f"OpenAPI check failed: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+    typer.secho("OpenAPI checks passed", fg=typer.colors.GREEN)
+
+
+@app.command("migrations")
+def cmd_migrations(project_root: str = typer.Option(".", help="Project root")):
+    try:
+        check_migrations_up_to_date(project_root=project_root)
+    except Exception as e:  # noqa: BLE001
+        typer.secho(f"Migrations check failed: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+    typer.secho("Migrations checks passed", fg=typer.colors.GREEN)
+
+
+@app.command("changelog")
+def cmd_changelog(
+    version: str = typer.Argument(..., help="Version (e.g., 0.1.604)"),
+    commits_file: str = typer.Option(None, help="Path to JSON lines of commits (sha,subject)"),
+):
+    """Generate a changelog section from commit messages.
+
+    Expects Conventional Commits style for best grouping; falls back to Other.
+    If commits_file is omitted, prints an example format.
+    """
+    import json
+    import sys
+
+    if not commits_file:
+        typer.echo(
+            '# Provide --commits-file with JSONL: {"sha": "<sha>", "subject": "feat: ..."}',
+            err=True,
+        )
+        raise typer.Exit(2)
+    rows = [
+        json.loads(line) for line in Path(commits_file).read_text().splitlines() if line.strip()
+    ]
+    commits = [Commit(sha=r["sha"], subject=r["subject"]) for r in rows]
+    out = generate_release_section(version=version, commits=commits)
+    sys.stdout.write(out)
+
+
+@app.command("ci")
+def cmd_ci(
+    run: bool = typer.Option(False, help="Execute the steps; default just prints a plan"),
+    openapi: str | None = typer.Option(None, help="Path to OpenAPI JSON to lint"),
+    project_root: str = typer.Option(".", help="Project root for migrations check"),
+):
+    """Print (or run) the CI steps locally to mirror the workflow."""
+    steps: list[list[str]] = []
+    # Lint, typecheck, tests
+    steps.append(["flake8", "--select=E,F"])  # mirrors CI
+    steps.append(["mypy", "src"])  # mirrors CI
+    if openapi:
+        steps.append([sys.executable, "-m", "svc_infra.cli", "dx", "openapi", openapi])
+    steps.append(
+        [sys.executable, "-m", "svc_infra.cli", "dx", "migrations", "--project-root", project_root]
+    )
+    steps.append(["pytest", "-q", "-W", "error"])  # mirrors CI
+
+    if not run:
+        typer.echo("CI dry-run plan:")
+        for cmd in steps:
+            typer.echo("  $ " + " ".join(cmd))
+        return
+
+    import subprocess
+
+    for cmd in steps:
+        typer.echo("Running: " + " ".join(cmd))
+        res = subprocess.run(cmd)
+        if res.returncode != 0:
+            raise typer.Exit(res.returncode)
+    typer.echo("All CI steps passed")
+
+
+def main():  # pragma: no cover - CLI entrypoint
+    app()
+
+
+__all__ = ["main", "app"]

svc_infra/cli/cmds/help.py

@@ -21,4 +21,8 @@ How to run (pick what fits your workflow):
 Notes:
 * Make sure you’re in the right virtual environment (or use `pipx`).
 * You can point `--project-root` at your Alembic root; if omitted we auto-detect.
+
+Learn more:
+* Explore available topics: `svc-infra docs --help`
+* Show a topic directly: `svc-infra docs <topic>` or `svc-infra docs show <topic>`
 """

svc_infra/cli/cmds/obs/obs_cmds.py

@@ -182,6 +182,7 @@ def scaffold(target: str = typer.Option(..., help="compose|railway|k8s|fly")):
 
 
 def register(app: typer.Typer) -> None:
-    app.command("obs-up")(up)
-    app.command("obs-down")(down)
-    app.command("obs-scaffold")(scaffold)
+    # Attach to 'obs' group app
+    app.command("up")(up)
+    app.command("down")(down)
+    app.command("scaffold")(scaffold)

svc_infra/cli/cmds/sdk/sdk_cmds.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import subprocess
+
+import typer
+
+app = typer.Typer(no_args_is_help=True, add_completion=False, help="Generate SDKs from OpenAPI.")
+
+
+def _echo(cmd: list[str]):
+    typer.echo("$ " + " ".join(cmd))
+
+
+def _parse_bool(val: str | bool | None, default: bool = True) -> bool:
+    if isinstance(val, bool):
+        return val
+    if val is None:
+        return default
+    s = str(val).strip().lower()
+    if s in {"1", "true", "yes", "y"}:
+        return True
+    if s in {"0", "false", "no", "n"}:
+        return False
+    return default
+
+
+@app.command("ts")
+def sdk_ts(
+    openapi: str = typer.Argument(..., help="Path to OpenAPI JSON"),
+    outdir: str = typer.Option("sdk-ts", help="Output directory"),
+    dry_run: str = typer.Option("true", help="Print commands instead of running (true/false)"),
+):
+    """Generate a TypeScript SDK (openapi-typescript-codegen as default)."""
+    cmd = [
+        "npx",
+        "openapi-typescript-codegen",
+        "--input",
+        openapi,
+        "--output",
+        outdir,
+    ]
+    if _parse_bool(dry_run, True):
+        _echo(cmd)
+        return
+    subprocess.check_call(cmd)
+    typer.secho(f"TS SDK generated → {outdir}", fg=typer.colors.GREEN)
+
+
+@app.command("py")
+def sdk_py(
+    openapi: str = typer.Argument(..., help="Path to OpenAPI JSON"),
+    outdir: str = typer.Option("sdk-py", help="Output directory"),
+    package_name: str = typer.Option("client_sdk", help="Python package name"),
+    dry_run: str = typer.Option("true", help="Print commands instead of running (true/false)"),
+):
+    """Generate a Python SDK via openapi-generator-cli with "python" generator."""
+    cmd = [
+        "npx",
+        "-y",
+        "@openapitools/openapi-generator-cli",
+        "generate",
+        "-i",
+        openapi,
+        "-g",
+        "python",
+        "-o",
+        outdir,
+        "--additional-properties",
+        f"packageName={package_name}",
+    ]
+    if _parse_bool(dry_run, True):
+        _echo(cmd)
+        return
+    subprocess.check_call(cmd)
+    typer.secho(f"Python SDK generated → {outdir}", fg=typer.colors.GREEN)
+
+
+@app.command("postman")
+def sdk_postman(
+    openapi: str = typer.Argument(..., help="Path to OpenAPI JSON"),
+    out: str = typer.Option("postman_collection.json", help="Output Postman collection"),
+    dry_run: str = typer.Option("true", help="Print commands instead of running (true/false)"),
+):
+    """Convert OpenAPI to a Postman collection via openapi-to-postmanv2."""
+    cmd = [
+        "npx",
+        "-y",
+        "openapi-to-postmanv2",
+        "-s",
+        openapi,
+        "-o",
+        out,
+    ]
+    if _parse_bool(dry_run, True):
+        _echo(cmd)
+        return
+    subprocess.check_call(cmd)
+    typer.secho(f"Postman collection generated → {out}", fg=typer.colors.GREEN)
+
+
+def register(root: typer.Typer):
+    root.add_typer(app, name="sdk")

svc_infra/data/add.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import inspect
+from typing import Callable, Iterable, Optional
+
+from fastapi import FastAPI
+
+from svc_infra.cli.cmds.db.sql.alembic_cmds import cmd_setup_and_migrate
+
+
+def add_data_lifecycle(
+    app: FastAPI,
+    *,
+    auto_migrate: bool = True,
+    database_url: str | None = None,
+    discover_packages: Optional[list[str]] = None,
+    with_payments: bool | None = None,
+    on_load_fixtures: Optional[Callable[[], None]] = None,
+    retention_jobs: Optional[Iterable[Callable[[], None]]] = None,
+    erasure_job: Optional[Callable[[str], None]] = None,
+) -> None:
+    """
+    Wire data lifecycle conveniences:
+
+    - auto_migrate: run end-to-end Alembic setup-and-migrate on startup (idempotent).
+    - on_load_fixtures: optional callback to load reference/fixture data once at startup.
+    - retention_jobs: optional list of callables to register purge tasks (scheduler integration is external).
+    - erasure_job: optional callable to trigger a GDPR erasure workflow for a given principal ID.
+
+    This helper is intentionally minimal: it coordinates existing building blocks
+    and offers extension points. Jobs should be scheduled using svc_infra.jobs helpers.
+    """
+
+    async def _run_lifecycle() -> None:
+        # Startup
+        if auto_migrate:
+            cmd_setup_and_migrate(
+                database_url=database_url,
+                overwrite_scaffold=False,
+                create_db_if_missing=True,
+                create_followup_revision=True,
+                initial_message="initial schema",
+                followup_message="autogen",
+                discover_packages=discover_packages,
+                with_payments=with_payments,
+            )
+        if on_load_fixtures:
+            res = on_load_fixtures()
+            if inspect.isawaitable(res):
+                await res  # type: ignore[misc]
+
+    app.add_event_handler("startup", _run_lifecycle)
+
+    # Store optional jobs on app.state for external schedulers to discover/register.
+    if retention_jobs is not None:
+        app.state.data_retention_jobs = list(retention_jobs)
+    if erasure_job is not None:
+        app.state.data_erasure_job = erasure_job
+
+
+__all__ = ["add_data_lifecycle"]

svc_infra/data/backup.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Callable, Optional
+
+
+@dataclass(frozen=True)
+class BackupHealthReport:
+    ok: bool
+    last_success: Optional[datetime]
+    retention_days: Optional[int]
+    message: str = ""
+
+
+def verify_backups(
+    *, last_success: Optional[datetime] = None, retention_days: Optional[int] = None
+) -> BackupHealthReport:
+    """Return a basic backup health report.
+
+    In production, callers should plug a provider-specific checker and translate into this report.
+    """
+    if last_success is None:
+        return BackupHealthReport(
+            ok=False, last_success=None, retention_days=retention_days, message="no_backup_seen"
+        )
+    now = datetime.now(timezone.utc)
+    age_days = (now - last_success).total_seconds() / 86400.0
+    ok = retention_days is None or age_days <= max(1, retention_days)
+    return BackupHealthReport(ok=ok, last_success=last_success, retention_days=retention_days)
+
+
+__all__ = ["BackupHealthReport", "verify_backups"]
+
+
+def make_backup_verification_job(
+    checker: Callable[[], BackupHealthReport],
+    *,
+    on_report: Optional[Callable[[BackupHealthReport], None]] = None,
+):
+    """Return a callable suitable for scheduling in a job runner.
+
+    The checker should perform provider-specific checks and return a BackupHealthReport.
+    If on_report is provided, it will be invoked with the report.
+    """
+
+    def _job() -> BackupHealthReport:
+        rep = checker()
+        if on_report:
+            on_report(rep)
+        return rep
+
+    return _job

svc_infra/data/erasure.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Iterable, Optional, Protocol
+
+
+class SqlSession(Protocol):  # minimal protocol for tests/integration
+    async def execute(self, stmt: Any) -> Any:
+        pass
+
+
+@dataclass(frozen=True)
+class ErasureStep:
+    name: str
+    run: Callable[[SqlSession, str], Awaitable[int] | int]
+
+
+@dataclass(frozen=True)
+class ErasurePlan:
+    steps: Iterable[ErasureStep]
+
+
+async def run_erasure(
+    session: SqlSession,
+    principal_id: str,
+    plan: ErasurePlan,
+    *,
+    on_audit: Optional[Callable[[str, dict[str, Any]], None]] = None,
+) -> int:
+    """Run an erasure plan and optionally emit an audit event.
+
+    Returns total affected rows across steps.
+    """
+    total = 0
+    for s in plan.steps:
+        res = s.run(session, principal_id)
+        if hasattr(res, "__await__"):
+            res = await res  # type: ignore[misc]
+        total += int(res or 0)
+    if on_audit:
+        on_audit("erasure.completed", {"principal_id": principal_id, "affected": total})
+    return total
+
+
+__all__ = ["ErasureStep", "ErasurePlan", "run_erasure"]

svc_infra/data/fixtures.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import inspect
+from pathlib import Path
+from typing import Awaitable, Callable, Iterable, Optional
+
+
+async def run_fixtures(
+    loaders: Iterable[Callable[[], None | Awaitable[None]]], *, run_once_file: Optional[str] = None
+) -> None:
+    """Run a sequence of fixture loaders (sync or async).
+
+    - If run_once_file is provided and exists, does nothing.
+    - On success, creates the run_once_file sentinel (parent dirs included).
+    """
+    if run_once_file:
+        sentinel = Path(run_once_file)
+        if sentinel.exists():
+            return
+    for fn in loaders:
+        res = fn()
+        if inspect.isawaitable(res):  # type: ignore[arg-type]
+            await res  # type: ignore[misc]
+    if run_once_file:
+        sentinel.parent.mkdir(parents=True, exist_ok=True)
+        Path(run_once_file).write_text("ok")
+
+
+def make_on_load_fixtures(
+    *loaders: Callable[[], None | Awaitable[None]], run_once_file: Optional[str] = None
+) -> Callable[[], Awaitable[None]]:
+    """Return an async callable suitable for add_data_lifecycle(on_load_fixtures=...)."""
+
+    async def _runner() -> None:
+        await run_fixtures(loaders, run_once_file=run_once_file)
+
+    return _runner
+
+
+__all__ = ["run_fixtures", "make_on_load_fixtures"]