sovaria-cli 0.2.0__py3-none-any.whl

apps/cli/src/commands/auth_product.py

@@ -0,0 +1,187 @@
+"""Project-scoped product auth admin commands."""
+
+from __future__ import annotations
+
+from typing import TypedDict
+from urllib.parse import quote
+
+import typer
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api, print_json
+from apps.cli.src.utils.config import get_scope
+
+app = typer.Typer(help="Manage product users within an org/project scope")
+
+
+class ScopeArgs(TypedDict):
+    org_id: str | None
+    project_id: str | None
+    env_id: str | None
+
+
+def _scope_args(
+    org_id: str | None,
+    project_id: str | None,
+    env_id: str | None,
+) -> ScopeArgs:
+    return {
+        "org_id": org_id,
+        "project_id": project_id,
+        "env_id": env_id,
+    }
+
+
+def _project_auth_path(profile: str | None, project_id: str | None, suffix: str) -> str:
+    resolved_project = (project_id or get_scope(profile).get("project_id") or "").strip()
+    if not resolved_project:
+        raise CLIRequestError(
+            "Missing required project scope. Set --project or run: sov scope set <org_id> <project_id>"
+        )
+    return f"/api/v1/projects/{quote(resolved_project, safe='')}/auth{suffix}"
+
+
+@app.command("users")
+def list_users(
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """List product users for the resolved org/project scope."""
+    try:
+        result = call_api(
+            method="GET",
+            path=_project_auth_path(profile, project_id, "/users"),
+            profile=profile,
+            require_scope=True,
+            **_scope_args(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("ban")
+def ban_user(
+    user_id: str = typer.Argument(..., help="Product user id to ban/unban"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Toggle a product user's active state in scope."""
+    safe_user_id = quote(user_id, safe="")
+    try:
+        result = call_api(
+            method="POST",
+            path=_project_auth_path(profile, project_id, f"/users/{safe_user_id}/ban"),
+            profile=profile,
+            require_scope=True,
+            **_scope_args(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("delete")
+def delete_user(
+    user_id: str = typer.Argument(..., help="Product user id to delete"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Delete a product user credential in scope."""
+    safe_user_id = quote(user_id, safe="")
+    try:
+        result = call_api(
+            method="DELETE",
+            path=_project_auth_path(profile, project_id, f"/users/{safe_user_id}"),
+            profile=profile,
+            require_scope=True,
+            **_scope_args(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("roles")
+def get_roles(
+    user_id: str = typer.Argument(..., help="Product user id"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Show a product user's app roles in scope."""
+    safe_user_id = quote(user_id, safe="")
+    try:
+        result = call_api(
+            method="GET",
+            path=_project_auth_path(profile, project_id, f"/users/{safe_user_id}/roles"),
+            profile=profile,
+            require_scope=True,
+            **_scope_args(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("roles-set")
+def set_roles(
+    user_id: str = typer.Argument(..., help="Product user id"),
+    roles: list[str] = typer.Argument(..., help="Roles to assign"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Replace a product user's app roles in scope."""
+    safe_user_id = quote(user_id, safe="")
+    try:
+        result = call_api(
+            method="PUT",
+            path=_project_auth_path(profile, project_id, f"/users/{safe_user_id}/roles"),
+            profile=profile,
+            body={"roles": roles},
+            require_scope=True,
+            **_scope_args(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("create")
+def create_user(
+    email: str = typer.Option(..., "--email"),
+    password: str = typer.Option(..., "--password"),
+    name: str | None = typer.Option(None, "--name", help="Display name (defaults to email local-part)"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Create a product user in the current project scope."""
+    display_name = name or email.split("@", maxsplit=1)[0]
+    try:
+        result = call_api(
+            method="POST",
+            path=_project_auth_path(profile, project_id, "/users"),
+            profile=profile,
+            require_scope=True,
+            **_scope_args(org_id, project_id, env_id),
+            body={"name": display_name, "email": email, "password": password},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))

apps/cli/src/commands/billing.py

@@ -0,0 +1,513 @@
+"""Ledger billing commands."""
+
+from __future__ import annotations
+
+import typer
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api, print_json
+
+app = typer.Typer(help="Billing and subscription commands (Ledger engine)")
+
+
+@app.command("plans")
+def list_plans(
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List public billing plans."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/plans",
+            profile=profile,
+            require_auth=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("plan")
+def get_plan(
+    name: str = typer.Argument(..., help="Plan name"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch one billing plan by name."""
+    from urllib.parse import quote
+
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/plans/{quote(name, safe='')}",
+            profile=profile,
+            require_auth=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("subscription")
+def get_subscription(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch the active subscription for an organisation."""
+    from urllib.parse import quote
+
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/subscriptions/{quote(org_id, safe='')}",
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("set-subscription")
+def set_subscription(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    plan: str = typer.Option(..., "--plan", help="Plan name"),
+    billing_cycle: str = typer.Option("monthly", "--cycle", help="monthly or annual"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Create or update an organisation subscription."""
+    from urllib.parse import quote
+
+    try:
+        result = call_api(
+            method="PUT",
+            path=f"/api/v1/subscriptions/{quote(org_id, safe='')}",
+            profile=profile,
+            require_scope=False,
+            body={"plan": plan, "billing_cycle": billing_cycle, "metadata": {}},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("cancel-subscription")
+def cancel_subscription(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    immediate: bool = typer.Option(False, "--immediate", help="Cancel immediately"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Cancel an organisation subscription."""
+    from urllib.parse import quote
+
+    params = {"immediate": "true"} if immediate else None
+    try:
+        result = call_api(
+            method="DELETE",
+            path=f"/api/v1/subscriptions/{quote(org_id, safe='')}",
+            profile=profile,
+            require_scope=False,
+            params=params,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("usage")
+def get_usage(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    period: str | None = typer.Option(None, "--period", help="Usage period"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch usage counters for an organisation."""
+    from urllib.parse import quote
+
+    params = {"period": period} if period else None
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/usage/{quote(org_id, safe='')}",
+            profile=profile,
+            require_scope=False,
+            params=params,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("usage-history")
+def usage_history(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    months: int = typer.Option(6, "--months", min=1, max=24),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch historical usage for an organisation."""
+    from urllib.parse import quote
+
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/usage/{quote(org_id, safe='')}/history",
+            profile=profile,
+            require_scope=False,
+            params={"months": str(months)},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("subscriptions")
+def list_subscriptions(
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List all subscriptions (platform admin)."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/subscriptions",
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("invoices")
+def list_invoices(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List invoices for an organisation."""
+    from urllib.parse import quote
+
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/invoices/{quote(org_id, safe='')}",
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("compute")
+def get_compute(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    period: str | None = typer.Option(None, "--period", help="Billing period YYYY-MM"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch compute usage breakdown for an organisation."""
+    from urllib.parse import quote
+
+    params = {"period": period} if period else None
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/compute/{quote(org_id, safe='')}",
+            profile=profile,
+            require_scope=False,
+            params=params,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("build-invoice")
+def build_invoice(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    period: str | None = typer.Option(None, "--period", help="Billing period YYYY-MM"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Build an invoice for an organisation billing period."""
+    from urllib.parse import quote
+
+    params = {"period": period} if period else None
+    try:
+        result = call_api(
+            method="POST",
+            path=f"/api/v1/invoices/{quote(org_id, safe='')}/build",
+            profile=profile,
+            require_scope=False,
+            params=params,
+            body={},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("checkout")
+def checkout(
+    plan: str = typer.Option(..., "--plan", help="Plan name (pro|ultra)"),
+    billing_cycle: str = typer.Option("monthly", "--cycle", help="monthly or annual"),
+    customer_email: str | None = typer.Option(None, "--email"),
+    provider: str | None = typer.Option(None, "--provider", help="stripe or razorpay"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+) -> None:
+    """Create a hosted billing checkout session."""
+    body: dict[str, object] = {"plan": plan, "billing_cycle": billing_cycle}
+    if customer_email:
+        body["customer_email"] = customer_email
+    if provider:
+        body["provider"] = provider
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/billing/checkout",
+            profile=profile,
+            org_id=org_id,
+            require_scope=False,
+            body=body,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("provider")
+def billing_provider(
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Show the active billing payment provider."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/billing/provider",
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("fx")
+def billing_fx(
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch billing FX rates."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/billing/fx",
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("overage")
+def billing_overage(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch overage billing details for an organisation."""
+    from urllib.parse import quote
+
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/billing/overage/{quote(org_id, safe='')}",
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("open-invoice")
+def open_invoice(
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+) -> None:
+    """Fetch the caller's open invoice for the scoped organisation."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/billing/invoices/open",
+            profile=profile,
+            org_id=org_id,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("pay-invoice")
+def pay_invoice(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    period: str = typer.Argument(..., help="Invoice period YYYY-MM"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Pay an invoice for an organisation billing period."""
+    from urllib.parse import quote
+
+    try:
+        result = call_api(
+            method="POST",
+            path=f"/api/v1/billing/invoices/{quote(org_id, safe='')}/{quote(period, safe='')}/pay",
+            profile=profile,
+            require_scope=False,
+            body={},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+razorpay_app = typer.Typer(help="Razorpay checkout helpers")
+app.add_typer(razorpay_app, name="razorpay")
+
+
+@razorpay_app.command("create-order")
+def razorpay_create_order(
+    plan: str = typer.Option(..., "--plan", help="Plan name (pro|ultra)"),
+    billing_cycle: str = typer.Option("monthly", "--cycle", help="monthly or annual"),
+    customer_email: str | None = typer.Option(None, "--email"),
+    account_id: str | None = typer.Option(None, "--account"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+) -> None:
+    """Create a Razorpay order for self-serve checkout."""
+    body: dict[str, object] = {"plan": plan, "billing_cycle": billing_cycle}
+    if customer_email:
+        body["customer_email"] = customer_email
+    if account_id:
+        body["account_id"] = account_id
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/billing/razorpay/create-order",
+            profile=profile,
+            org_id=org_id,
+            require_scope=False,
+            body=body,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@razorpay_app.command("verify")
+def razorpay_verify(
+    order_id: str = typer.Option(..., "--order-id"),
+    payment_id: str = typer.Option(..., "--payment-id"),
+    signature: str = typer.Option(..., "--signature"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+) -> None:
+    """Verify a Razorpay payment signature and activate the plan."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/billing/razorpay/verify-payment",
+            profile=profile,
+            org_id=org_id,
+            require_scope=False,
+            body={
+                "razorpay_order_id": order_id,
+                "razorpay_payment_id": payment_id,
+                "razorpay_signature": signature,
+            },
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+account_app = typer.Typer(help="Billing account lifecycle")
+app.add_typer(account_app, name="account")
+
+
+@account_app.command("get")
+def account_get(
+    account_id: str = typer.Argument(..., help="Billing account ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch a billing account."""
+    from urllib.parse import quote
+
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/accounts/{quote(account_id, safe='')}",
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@account_app.command("cancel")
+def account_cancel(
+    account_id: str = typer.Argument(..., help="Billing account ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Cancel a billing account subscription."""
+    from urllib.parse import quote
+
+    try:
+        result = call_api(
+            method="POST",
+            path=f"/api/v1/accounts/{quote(account_id, safe='')}/cancel",
+            profile=profile,
+            require_scope=False,
+            body={},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@account_app.command("resume")
+def account_resume(
+    account_id: str = typer.Argument(..., help="Billing account ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Resume a cancelled billing account."""
+    from urllib.parse import quote
+
+    try:
+        result = call_api(
+            method="POST",
+            path=f"/api/v1/accounts/{quote(account_id, safe='')}/resume",
+            profile=profile,
+            require_scope=False,
+            body={},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))