sovaria-cli 0.2.0__py3-none-any.whl

apps/cli/src/commands/db.py

@@ -0,0 +1,528 @@
+"""
+apps.cli.src.commands.db — Database management commands.
+
+Commands:
+    sov db tables       List migration log / tables
+    sov db create-table Create a new table
+    sov db sql          Execute SQL (supports --interactive)
+"""
+
+from __future__ import annotations
+
+import json
+
+import typer
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api, parse_json_arg
+from apps.cli.src.utils.display import print_json, print_sql_result
+
+app = typer.Typer(help="Database (SQL) management")
+
+
+@app.command("tables")
+def list_tables(
+    org_id: str | None = typer.Option(None, "--org", help="Organization ID"),
+    project_id: str | None = typer.Option(None, "--project", help="Project ID"),
+    env_id: str | None = typer.Option(None, "--env"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List relational tables / migration log for the linked project."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/data/rel/migrations",
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("sql")
+def run_sql(
+    query: str | None = typer.Argument(None, help="SQL query to execute"),
+    interactive: bool = typer.Option(False, "--interactive", "-i", help="Interactive SQL REPL"),
+    org_id: str | None = typer.Option(None, "--org", help="Organization ID"),
+    project_id: str | None = typer.Option(None, "--project", help="Project ID"),
+    env_id: str | None = typer.Option(None, "--env"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Execute SQL against Atlas-Rel. Use --interactive for a mini psql-style loop."""
+    if interactive:
+        typer.echo("Interactive SQL (\\q or exit to quit)")
+        while True:
+            try:
+                line = typer.prompt("sql", prompt_suffix="> ")
+            except (EOFError, KeyboardInterrupt):
+                typer.echo("")
+                break
+            stripped = line.strip()
+            if not stripped:
+                continue
+            if stripped.lower() in {"\\q", "exit", "quit"}:
+                break
+            _execute_sql(
+                stripped,
+                profile=profile,
+                org_id=org_id,
+                project_id=project_id,
+                env_id=env_id,
+            )
+        return
+
+    if not query:
+        typer.echo("Provide a SQL query or use --interactive", err=True)
+        raise typer.Exit(1)
+
+    _execute_sql(
+        query,
+        profile=profile,
+        org_id=org_id,
+        project_id=project_id,
+        env_id=env_id,
+    )
+
+
+def _execute_sql(
+    sql: str,
+    *,
+    profile: str | None,
+    org_id: str | None,
+    project_id: str | None,
+    env_id: str | None,
+) -> None:
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/sql/query",
+            profile=profile,
+            body={"sql": sql, "txid": 0},
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_sql_result(result)
+
+
+@app.command("create-table")
+def create_table(
+    name: str = typer.Argument(..., help="Table name"),
+    columns_json: str = typer.Argument(
+        ...,
+        help='Columns as JSON array, e.g. \'[{"name":"id","type":"SERIAL","primary_key":true}]\'',
+    ),
+    foreign_keys: str | None = typer.Option(None, "--foreign-keys", help="JSON array of FK defs"),
+    org_id: str | None = typer.Option(None, "--org", help="Organization ID"),
+    project_id: str | None = typer.Option(None, "--project", help="Project ID"),
+    env_id: str | None = typer.Option(None, "--env"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Create a new relational table."""
+    try:
+        columns = parse_json_arg(columns_json, label="columns")
+        parsed_fk = parse_json_arg(foreign_keys, label="--foreign-keys") if foreign_keys else []
+        if not isinstance(columns, list):
+            raise CLIRequestError("columns must be a JSON array")
+        if parsed_fk is not None and not isinstance(parsed_fk, list):
+            raise CLIRequestError("--foreign-keys must be a JSON array")
+        result = call_api(
+            method="POST",
+            path="/api/v1/data/rel/create",
+            profile=profile,
+            body={
+                "table_name": name,
+                "columns": columns,
+                "foreign_keys": parsed_fk or [],
+            },
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+    typer.echo(f"Table '{name}' created successfully")
+
+
+# ── Transaction subcommands ───────────────────────────────────────────────────
+
+tx_app = typer.Typer(help="SQL transaction control")
+app.add_typer(tx_app, name="tx")
+
+
+def _scope_opts(
+    profile: str | None,
+    org_id: str | None,
+    project_id: str | None,
+    env_id: str | None,
+) -> dict[str, str | None]:
+    return {
+        "profile": profile,
+        "org_id": org_id,
+        "project_id": project_id,
+        "env_id": env_id,
+    }
+
+
+@tx_app.command("begin")
+def tx_begin(
+    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:
+    """Begin a relational transaction and return txid."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/data/rel/transaction/begin",
+            require_scope=True,
+            **_scope_opts(profile, org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@tx_app.command("commit")
+def tx_commit(
+    txid: int = typer.Option(..., "--txid", help="Transaction id from `sov db tx begin`"),
+    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:
+    """Commit an open transaction."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/data/rel/transaction/commit",
+            body={"txid": txid},
+            require_scope=True,
+            **_scope_opts(profile, org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@tx_app.command("rollback")
+def tx_rollback(
+    txid: int = typer.Option(..., "--txid", help="Transaction id from `sov db tx begin`"),
+    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:
+    """Rollback an open transaction."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/data/rel/transaction/rollback",
+            body={"txid": txid},
+            require_scope=True,
+            **_scope_opts(profile, org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+# ── Column / FK DDL ───────────────────────────────────────────────────────────
+
+column_app = typer.Typer(help="Column DDL operations")
+app.add_typer(column_app, name="column")
+
+
+@column_app.command("add")
+def column_add(
+    table: str = typer.Argument(..., help="Table name"),
+    name: str = typer.Argument(..., help="Column name"),
+    data_type: str = typer.Option(..., "--type", help="SQL data type, e.g. TEXT or INTEGER"),
+    nullable: bool = typer.Option(True, "--nullable/--not-null"),
+    unique: bool = typer.Option(False, "--unique"),
+    default: str | None = typer.Option(None, "--default"),
+    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:
+    """Add a column to an existing table."""
+    body: dict[str, object] = {
+        "table_name": table,
+        "column_name": name,
+        "data_type": data_type,
+        "is_nullable": nullable,
+        "is_unique": unique,
+    }
+    if default is not None:
+        body["default_value"] = default
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/data/rel/column/add",
+            body=body,
+            require_scope=True,
+            **_scope_opts(profile, org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@column_app.command("drop")
+def column_drop(
+    table: str = typer.Argument(...),
+    name: str = typer.Argument(..., help="Column name"),
+    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:
+    """Drop a column from a table."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/data/rel/column/drop",
+            body={"table_name": table, "column_name": name},
+            require_scope=True,
+            **_scope_opts(profile, org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+fk_app = typer.Typer(help="Foreign key DDL operations")
+app.add_typer(fk_app, name="fk")
+
+
+@fk_app.command("add")
+def fk_add(
+    table: str = typer.Argument(...),
+    column: str = typer.Argument(...),
+    ref_table: str = typer.Option(..., "--ref-table"),
+    ref_column: str = typer.Option(..., "--ref-column"),
+    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:
+    """Add a foreign key between tables."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/data/rel/foreign-key/add",
+            body={
+                "table_name": table,
+                "column_name": column,
+                "referenced_table": ref_table,
+                "referenced_column": ref_column,
+            },
+            require_scope=True,
+            **_scope_opts(profile, org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@fk_app.command("drop")
+def fk_drop(
+    table: str = typer.Argument(...),
+    column: str = typer.Argument(...),
+    ref_table: str = typer.Option(..., "--ref-table"),
+    ref_column: str = typer.Option(..., "--ref-column"),
+    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:
+    """Drop a foreign key."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/data/rel/foreign-key/drop",
+            body={
+                "table_name": table,
+                "column_name": column,
+                "referenced_table": ref_table,
+                "referenced_column": ref_column,
+            },
+            require_scope=True,
+            **_scope_opts(profile, org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+# ── Migrations push / pull ────────────────────────────────────────────────────
+
+migrations_app = typer.Typer(help="Local SQL migration files")
+app.add_typer(migrations_app, name="migrations")
+
+
+@migrations_app.command("list")
+def migrations_list(
+    table: str | None = typer.Option(None, "--table"),
+    limit: int = typer.Option(100, "--limit"),
+    offset: int = typer.Option(0, "--offset"),
+    local: bool = typer.Option(False, "--local", help="List local .sql files only"),
+    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 remote migration log entries or local migration files."""
+    from apps.cli.src.utils.migrations import list_local_migrations, load_applied_state
+
+    if local:
+        files = list_local_migrations()
+        applied = load_applied_state()
+        for path in files:
+            marker = "✓" if path.name in applied else " "
+            typer.echo(f"  [{marker}] {path.name}")
+        typer.echo(f"\n{len(files)} local file(s), {len(applied)} applied locally")
+        return
+
+    params: dict[str, str] = {"limit": str(limit), "offset": str(offset)}
+    if table:
+        params["table_name"] = table
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/data/rel/migrations",
+            params=params,
+            require_scope=True,
+            **_scope_opts(profile, org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@migrations_app.command("push")
+def migrations_push(
+    directory: str | None = typer.Option(
+        None,
+        "--dir",
+        help="Migration directory (default: sovaria/migrations under linked project)",
+    ),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show pending files without executing"),
+    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:
+    """Apply pending local .sql migration files in sorted order."""
+    from pathlib import Path
+
+    from apps.cli.src.utils.display import print_success, print_warning
+    from apps.cli.src.utils.migrations import (
+        list_local_migrations,
+        load_applied_state,
+        migration_name,
+        migrations_dir,
+        save_applied_state,
+    )
+
+    folder = Path(directory) if directory else migrations_dir()
+    files = list_local_migrations(folder)
+    if not files:
+        print_warning(f"No .sql files in {folder}. Create migrations there first.")
+        raise typer.Exit(0)
+
+    applied = load_applied_state()
+    pending = [path for path in files if migration_name(path) not in applied]
+    if not pending:
+        print_success("All local migrations already applied.")
+        raise typer.Exit(0)
+
+    typer.echo(f"Pending migrations ({len(pending)}):")
+    for path in pending:
+        typer.echo(f"  • {path.name}")
+
+    if dry_run:
+        raise typer.Exit(0)
+
+    for path in pending:
+        sql = path.read_text(encoding="utf-8").strip()
+        if not sql:
+            print_warning(f"Skipping empty file: {path.name}")
+            applied.add(migration_name(path))
+            continue
+        typer.echo(f"Applying {path.name} …")
+        try:
+            call_api(
+                method="POST",
+                path="/api/v1/sql/query",
+                body={"sql": sql, "txid": 0},
+                require_scope=True,
+                **_scope_opts(profile, org_id, project_id, env_id),
+            )
+        except CLIRequestError as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(1) from exc
+        applied.add(migration_name(path))
+
+    state_file = save_applied_state(applied)
+    print_success(f"Applied {len(pending)} migration(s). State: {state_file}")
+
+
+@migrations_app.command("pull")
+def migrations_pull(
+    output: str | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Write remote migration log JSON to this path",
+    ),
+    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:
+    """Fetch remote migration log (schema change history) as JSON."""
+    from pathlib import Path
+
+    from apps.cli.src.utils.migrations import migrations_dir
+
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/data/rel/migrations",
+            params={"limit": "500", "offset": "0"},
+            require_scope=True,
+            **_scope_opts(profile, org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+
+    if output:
+        out_path = Path(output)
+    else:
+        out_path = migrations_dir() / "remote_migrations.json"
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(json.dumps(result, indent=2, sort_keys=True, default=str) + "\n")
+    typer.echo(f"Wrote migration log to {out_path}")