licos-platform-cli 0.2.7__tar.gz → 0.2.9__tar.gz

{licos_platform_cli-0.2.7 → licos_platform_cli-0.2.9}/.gitignore

@@ -17,9 +17,10 @@ packages/*/dist/
 .DS_Store
 Thumbs.db
 
-# Environment
-.env
-.env.local
+# Environment
+.env
+.env.local
+crates/industrial/industrial-stack.env
 
 # Workspace
 /workspace/

{licos_platform_cli-0.2.7 → licos_platform_cli-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-platform-cli
-Version: 0.2.7
+Version: 0.2.9
 Summary: LICOS platform CLI
 Requires-Python: >=3.10
-Requires-Dist: licos-platform-sdk>=0.2.6
+Requires-Dist: licos-platform-sdk>=0.2.8

{licos_platform_cli-0.2.7 → licos_platform_cli-0.2.9}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-platform-cli"
-version = "0.2.7"
+version = "0.2.9"
 description = "LICOS platform CLI"
 requires-python = ">=3.10"
 dependencies = [
-    "licos-platform-sdk>=0.2.6",
+    "licos-platform-sdk>=0.2.8",
 ]
 
 [project.scripts]

licos_platform_cli-0.2.9/src/licos_platform_cli/database_commands.py

@@ -0,0 +1,630 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Any, Callable
+
+from licos_platform_sdk import database, studio_database
+
+
+Handler = Callable[[argparse.Namespace], Any]
+
+
+def _set_handler(parser: argparse.ArgumentParser, handler: Handler) -> None:
+    parser.set_defaults(handler=handler)
+
+
+def _json_value(value: str) -> Any:
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:
+        return value
+
+
+def _json_object(value: str | None) -> dict[str, Any] | None:
+    if not value:
+        return None
+    parsed = _json_value(value)
+    if not isinstance(parsed, dict):
+        raise argparse.ArgumentTypeError("value must be a JSON object")
+    return parsed
+
+
+def _json_list(value: str | None) -> list[Any] | None:
+    if not value:
+        return None
+    parsed = _json_value(value)
+    if not isinstance(parsed, list):
+        raise argparse.ArgumentTypeError("value must be a JSON array")
+    return parsed
+
+
+def _json_array(value: str | None) -> list[dict[str, Any]] | None:
+    parsed = _json_list(value)
+    if parsed is None:
+        return None
+    if not all(isinstance(item, dict) for item in parsed):
+        raise argparse.ArgumentTypeError("value must be a JSON array of objects")
+    return parsed
+
+
+def _filters(args: argparse.Namespace) -> list[dict[str, Any]] | None:
+    raw_filters = getattr(args, "filter", None) or []
+    filters = []
+    for item in raw_filters:
+        field, op, raw_value = item
+        filters.append({"field": field, "op": op, "value": _json_value(raw_value)})
+    return filters or None
+
+
+def _order_by(args: argparse.Namespace) -> list[dict[str, str]] | None:
+    raw_orders = getattr(args, "order", None) or []
+    orders = []
+    for item in raw_orders:
+        if ":" in item:
+            field, direction = item.rsplit(":", 1)
+        else:
+            field, direction = item, "asc"
+        orders.append({"field": field, "direction": direction})
+    return orders or None
+
+
+def _range(args: argparse.Namespace) -> dict[str, int] | None:
+    if not getattr(args, "range", None):
+        return None
+    start, end = args.range
+    return {"from": start, "to": end}
+
+
+def _query_options(args: argparse.Namespace) -> dict[str, Any]:
+    return {
+        "select": args.select,
+        "filters": _filters(args),
+        "order_by": _order_by(args),
+        "range": _range(args),
+        "limit": args.limit,
+        "offset": args.offset,
+        "count": args.count,
+        "head": args.head,
+    }
+
+
+def _cmd_query(args: argparse.Namespace) -> Any:
+    return database.query(args.table, **_query_options(args))
+
+
+def _cmd_single(args: argparse.Namespace) -> Any:
+    return database.single(
+        args.table,
+        maybe=args.maybe,
+        select=args.select,
+        filters=_filters(args),
+        order_by=_order_by(args),
+    )
+
+
+def _cmd_aggregate(args: argparse.Namespace) -> Any:
+    return database.aggregate(
+        args.table,
+        args.aggregate,
+        field=args.field,
+        group_by=args.group_by,
+        filters=_filters(args),
+    )
+
+
+def _cmd_insert(args: argparse.Namespace) -> Any:
+    if not args.row and not args.rows:
+        raise argparse.ArgumentTypeError("--row or --rows is required")
+    return database.insert(
+        args.table,
+        row=_json_object(args.row),
+        rows=_json_list(args.rows),
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_update(args: argparse.Namespace) -> Any:
+    if not args.values and not args.updates:
+        raise argparse.ArgumentTypeError("--values or --updates is required")
+    return database.update(
+        args.table,
+        values=_json_object(args.values),
+        filters=_filters(args),
+        updates=_json_list(args.updates),
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_delete_rows(args: argparse.Namespace) -> Any:
+    filters = _filters(args)
+    if not filters and not args.deletes:
+        raise argparse.ArgumentTypeError("--filter or --deletes is required")
+    return database.delete(
+        args.table,
+        filters=filters,
+        deletes=_json_list(args.deletes),
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_upsert(args: argparse.Namespace) -> Any:
+    if not args.row and not args.rows:
+        raise argparse.ArgumentTypeError("--row or --rows is required")
+    return database.upsert(
+        args.table,
+        row=_json_object(args.row),
+        rows=_json_list(args.rows),
+        conflict_keys=args.conflict_keys,
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_transaction(args: argparse.Namespace) -> Any:
+    operations = _json_list(args.operations)
+    if operations is None:
+        raise argparse.ArgumentTypeError("--operations is required")
+    return database.transaction(operations)
+
+
+def _cmd_rpc(args: argparse.Namespace) -> Any:
+    return database.rpc(args.function_name, args=_json_object(args.args) or {})
+
+
+def _cmd_schema(args: argparse.Namespace) -> Any:
+    return database.get_schema()
+
+
+def _cmd_export_orm(args: argparse.Namespace) -> Any:
+    try:
+        content = database.export_orm(language=args.language, orm=args.orm)
+        resolved_orm = args.orm or database.default_orm(args.language)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError(str(exc)) from exc
+
+    output_path = _resolve_project_output(args.out)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(content, encoding="utf-8")
+    return {
+        "language": args.language,
+        "orm": resolved_orm,
+        "path": str(output_path),
+        "bytes": len(content.encode("utf-8")),
+    }
+
+
+def _cmd_studio_info(args: argparse.Namespace) -> Any:
+    return studio_database.get_database(env_scope=args.env_scope)
+
+
+def _cmd_studio_ensure(args: argparse.Namespace) -> Any:
+    return studio_database.ensure_database(environment=args.env_scope)
+
+
+def _cmd_studio_schema(args: argparse.Namespace) -> Any:
+    return studio_database.get_schema(environment=args.env_scope)
+
+
+def _cmd_studio_config(args: argparse.Namespace) -> Any:
+    return studio_database.get_config(environment=args.env_scope)
+
+
+def _cmd_studio_tables(args: argparse.Namespace) -> Any:
+    return studio_database.list_tables(env_scope=args.env_scope, keyword=args.keyword)
+
+
+def _cmd_studio_create_table(args: argparse.Namespace) -> Any:
+    return studio_database.create_table(
+        args.table_name,
+        description=args.description,
+        columns=_json_array(args.columns),
+        env_scope=args.env_scope,
+    )
+
+
+def _cmd_studio_update_table(args: argparse.Namespace) -> Any:
+    return studio_database.update_table(
+        args.table_name,
+        new_table_name=args.new_table_name,
+        description=args.description,
+        columns=_json_array(args.columns),
+        env_scope=args.env_scope,
+        schema=args.schema,
+    )
+
+
+def _cmd_studio_delete_table(args: argparse.Namespace) -> Any:
+    return studio_database.delete_table(args.table_name, env_scope=args.env_scope, schema=args.schema)
+
+
+def _cmd_studio_add_column(args: argparse.Namespace) -> Any:
+    return studio_database.add_column(
+        args.table_name,
+        name=args.name,
+        type=args.type,
+        description=args.description,
+        default_value=args.default_value,
+        array=args.array,
+        primary_key=args.primary_key,
+        nullable=args.nullable,
+        unique=args.unique,
+        check_expression=args.check_expression,
+        env_scope=args.env_scope,
+        schema=args.schema,
+    )
+
+
+def _cmd_studio_table_data(args: argparse.Namespace) -> Any:
+    return studio_database.get_table_data(args.table_name, env_scope=args.env_scope, schema=args.schema)
+
+
+def _cmd_studio_insert_row(args: argparse.Namespace) -> Any:
+    values = _json_object(args.values)
+    if values is None:
+        raise argparse.ArgumentTypeError("--values is required")
+    return studio_database.insert_row(args.table_name, values, env_scope=args.env_scope, schema=args.schema)
+
+
+def _cmd_studio_update_row(args: argparse.Namespace) -> Any:
+    values = _json_object(args.values)
+    if values is None:
+        raise argparse.ArgumentTypeError("--values is required")
+    if not args.row_id and args.row_index is None:
+        raise argparse.ArgumentTypeError("--row-id or --row-index is required")
+    return studio_database.update_row(
+        args.table_name,
+        values,
+        row_id=args.row_id,
+        row_index=args.row_index,
+        env_scope=args.env_scope,
+        schema=args.schema,
+    )
+
+
+def _cmd_studio_delete_rows(args: argparse.Namespace) -> Any:
+    if not args.row_id and args.row_index is None:
+        raise argparse.ArgumentTypeError("--row-id or --row-index is required")
+    return studio_database.delete_rows(
+        args.table_name,
+        row_ids=args.row_id,
+        row_indexes=args.row_index,
+        env_scope=args.env_scope,
+        schema=args.schema,
+    )
+
+
+def _cmd_studio_sql(args: argparse.Namespace) -> Any:
+    return studio_database.execute_sql(args.sql_text, env_scope=args.env_scope)
+
+
+def _cmd_studio_control_sql(args: argparse.Namespace) -> Any:
+    return studio_database.control_sql(args.sql_text, environment=args.env_scope)
+
+
+def _cmd_studio_explain_sql(args: argparse.Namespace) -> Any:
+    return studio_database.explain_sql(args.sql_text, environment=args.env_scope)
+
+
+def _cmd_studio_sql_history(args: argparse.Namespace) -> Any:
+    return studio_database.sql_history(env_scope=args.env_scope)
+
+
+def _cmd_studio_migrations(args: argparse.Namespace) -> Any:
+    return studio_database.list_migrations(environment=args.env_scope)
+
+
+def _cmd_studio_migration(args: argparse.Namespace) -> Any:
+    return studio_database.get_migration(args.migration_id)
+
+
+def _cmd_studio_create_migration(args: argparse.Namespace) -> Any:
+    schema = _json_object(args.schema) if args.schema else None
+    return studio_database.create_migration(
+        title=args.title,
+        statements=args.statement or [],
+        schema=schema,
+        dry_run=not args.execute,
+        environment=args.env_scope,
+    )
+
+
+def _cmd_studio_sync(args: argparse.Namespace) -> Any:
+    return studio_database.sync(
+        source_scope=args.source_scope,
+        target_scope=args.target_scope,
+        tables=args.table,
+        source_project_id=args.source_project_id,
+        target_project_id=args.target_project_id,
+    )
+
+
+def _cmd_studio_sync_project(args: argparse.Namespace) -> Any:
+    return studio_database.sync_project(
+        args.source_project_id,
+        args.target_project_id,
+        source_scope=args.source_scope,
+        target_scope=args.target_scope,
+        tables=args.table,
+    )
+
+
+def _cmd_studio_backup_export(args: argparse.Namespace) -> Any:
+    return studio_database.export_backup(env_scope=args.env_scope)
+
+
+def _cmd_studio_backup_import(args: argparse.Namespace) -> Any:
+    if args.backup_file:
+        backup = json.loads(Path(args.backup_file).read_text(encoding="utf-8"))
+    else:
+        backup = _json_object(args.backup)
+    if backup is None:
+        raise argparse.ArgumentTypeError("--backup or --backup-file is required")
+    return studio_database.import_backup(backup, env_scope=args.env_scope)
+
+
+def _resolve_project_output(value: str) -> Path:
+    output_path = Path(value)
+    project_root = os.environ.get("LICOS_PROJECT_PATH")
+    if not project_root:
+        return output_path
+    root = Path(project_root).resolve()
+    resolved = (output_path if output_path.is_absolute() else Path.cwd() / output_path).resolve()
+    try:
+        resolved.relative_to(root)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("--out must stay inside LICOS_PROJECT_PATH") from exc
+    return resolved
+
+
+def _add_filter_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--filter",
+        nargs=3,
+        action="append",
+        metavar=("FIELD", "OP", "VALUE"),
+        help="Add a filter. VALUE is parsed as JSON when possible.",
+    )
+
+
+def _add_query_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--select", default=None, help="Comma-separated fields")
+    _add_filter_args(parser)
+    parser.add_argument("--order", action="append", default=[], help="Order by field or field:desc")
+    parser.add_argument("--range", nargs=2, type=int, metavar=("FROM", "TO"))
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--offset", type=int, default=None)
+    parser.add_argument("--count", action="store_true")
+    parser.add_argument("--head", action="store_true")
+
+
+def _add_env_scope_arg(parser: argparse.ArgumentParser, *, default: str | None = None) -> None:
+    parser.add_argument("--env-scope", choices=["dev", "prod"], default=default, help="Studio database environment scope")
+
+
+def _add_schema_arg(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--schema", default=None, help="Schema name, defaults to public")
+
+
+def add_database_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    database_parser = subparsers.add_parser("database", help="Call LICOS runtime database APIs")
+    database_subparsers = database_parser.add_subparsers(dest="database_command", required=True)
+
+    query = database_subparsers.add_parser("query", help="Query rows")
+    query.add_argument("table")
+    _add_query_args(query)
+    _set_handler(query, _cmd_query)
+
+    single = database_subparsers.add_parser("single", help="Query a single row")
+    single.add_argument("table")
+    single.add_argument("--maybe", action="store_true", help="Allow zero rows")
+    single.add_argument("--select", default=None, help="Comma-separated fields")
+    _add_filter_args(single)
+    single.add_argument("--order", action="append", default=[], help="Order by field or field:desc")
+    _set_handler(single, _cmd_single)
+
+    aggregate = database_subparsers.add_parser("aggregate", help="Run aggregate query")
+    aggregate.add_argument("table")
+    aggregate.add_argument("aggregate")
+    aggregate.add_argument("--field", default=None)
+    aggregate.add_argument("--group-by", action="append", default=None)
+    _add_filter_args(aggregate)
+    _set_handler(aggregate, _cmd_aggregate)
+
+    insert = database_subparsers.add_parser("insert", help="Insert row(s)")
+    insert.add_argument("table")
+    insert.add_argument("--row", default=None, help="JSON object")
+    insert.add_argument("--rows", default=None, help="JSON array")
+    insert.add_argument("--no-returning", action="store_true")
+    _set_handler(insert, _cmd_insert)
+
+    update = database_subparsers.add_parser("update", help="Update row(s)")
+    update.add_argument("table")
+    update.add_argument("--values", default=None, help="JSON object")
+    update.add_argument("--updates", default=None, help="JSON array of mutation batches")
+    update.add_argument("--no-returning", action="store_true")
+    _add_filter_args(update)
+    _set_handler(update, _cmd_update)
+
+    delete_rows = database_subparsers.add_parser("delete-rows", help="Delete row(s)")
+    delete_rows.add_argument("table")
+    delete_rows.add_argument("--deletes", default=None, help="JSON array of mutation batches")
+    delete_rows.add_argument("--no-returning", action="store_true")
+    _add_filter_args(delete_rows)
+    _set_handler(delete_rows, _cmd_delete_rows)
+
+    upsert = database_subparsers.add_parser("upsert", help="Upsert row(s)")
+    upsert.add_argument("table")
+    upsert.add_argument("--row", default=None, help="JSON object")
+    upsert.add_argument("--rows", default=None, help="JSON array")
+    upsert.add_argument("--conflict-keys", action="append", default=None)
+    upsert.add_argument("--no-returning", action="store_true")
+    _set_handler(upsert, _cmd_upsert)
+
+    transaction = database_subparsers.add_parser("transaction", help="Run transaction")
+    transaction.add_argument("--operations", required=True, help="JSON array")
+    _set_handler(transaction, _cmd_transaction)
+
+    rpc = database_subparsers.add_parser("rpc", help="Call database function")
+    rpc.add_argument("function_name")
+    rpc.add_argument("--args", default=None, help="JSON object")
+    _set_handler(rpc, _cmd_rpc)
+
+    schema = database_subparsers.add_parser("schema", help="Fetch database schema metadata")
+    _set_handler(schema, _cmd_schema)
+
+    export_orm = database_subparsers.add_parser("export-orm", help="Export ORM source from database schema metadata")
+    export_orm.add_argument("--language", required=True, choices=["typescript", "python"])
+    export_orm.add_argument("--orm", choices=["drizzle", "sqlalchemy"], default=None)
+    export_orm.add_argument("--out", required=True, help="Output source file path")
+    _set_handler(export_orm, _cmd_export_orm)
+
+    studio_info = database_subparsers.add_parser("studio-info", help="Fetch Studio project database metadata")
+    _add_env_scope_arg(studio_info)
+    _set_handler(studio_info, _cmd_studio_info)
+
+    studio_ensure = database_subparsers.add_parser("studio-ensure", help="Open or confirm the Studio project database")
+    _add_env_scope_arg(studio_ensure)
+    _set_handler(studio_ensure, _cmd_studio_ensure)
+
+    studio_schema = database_subparsers.add_parser("studio-schema", help="Fetch complete Studio database schema")
+    _add_env_scope_arg(studio_schema)
+    _set_handler(studio_schema, _cmd_studio_schema)
+
+    studio_config = database_subparsers.add_parser("studio-config", help="Fetch Studio database capability config")
+    _add_env_scope_arg(studio_config)
+    _set_handler(studio_config, _cmd_studio_config)
+
+    studio_tables = database_subparsers.add_parser("studio-tables", help="List Studio database tables")
+    _add_env_scope_arg(studio_tables)
+    studio_tables.add_argument("--keyword", default=None, help="Filter by table name keyword")
+    _set_handler(studio_tables, _cmd_studio_tables)
+
+    studio_create_table = database_subparsers.add_parser("studio-create-table", help="Create a Studio database table")
+    studio_create_table.add_argument("table_name")
+    studio_create_table.add_argument("--description", default=None)
+    studio_create_table.add_argument("--columns", default=None, help="JSON array of column definitions")
+    _add_env_scope_arg(studio_create_table)
+    _set_handler(studio_create_table, _cmd_studio_create_table)
+
+    studio_update_table = database_subparsers.add_parser("studio-update-table", help="Update a Studio database table")
+    studio_update_table.add_argument("table_name")
+    studio_update_table.add_argument("--new-table-name", default=None)
+    studio_update_table.add_argument("--description", default=None)
+    studio_update_table.add_argument("--columns", default=None, help="JSON array of final column definitions")
+    _add_env_scope_arg(studio_update_table)
+    _add_schema_arg(studio_update_table)
+    _set_handler(studio_update_table, _cmd_studio_update_table)
+
+    studio_delete_table = database_subparsers.add_parser("studio-delete-table", help="Delete a Studio database table")
+    studio_delete_table.add_argument("table_name")
+    _add_env_scope_arg(studio_delete_table)
+    _add_schema_arg(studio_delete_table)
+    _set_handler(studio_delete_table, _cmd_studio_delete_table)
+
+    studio_add_column = database_subparsers.add_parser("studio-add-column", help="Add a column to a Studio database table")
+    studio_add_column.add_argument("table_name")
+    studio_add_column.add_argument("name")
+    studio_add_column.add_argument("type")
+    studio_add_column.add_argument("--description", default=None)
+    studio_add_column.add_argument("--default-value", default=None)
+    studio_add_column.add_argument("--array", action="store_true", default=None)
+    studio_add_column.add_argument("--primary-key", action="store_true", default=None)
+    studio_add_column.add_argument("--nullable", action="store_true", default=None)
+    studio_add_column.add_argument("--unique", action="store_true", default=None)
+    studio_add_column.add_argument("--check-expression", default=None)
+    _add_env_scope_arg(studio_add_column)
+    _add_schema_arg(studio_add_column)
+    _set_handler(studio_add_column, _cmd_studio_add_column)
+
+    studio_table_data = database_subparsers.add_parser("studio-table-data", help="Fetch Studio database table data")
+    studio_table_data.add_argument("table_name")
+    _add_env_scope_arg(studio_table_data)
+    _add_schema_arg(studio_table_data)
+    _set_handler(studio_table_data, _cmd_studio_table_data)
+
+    studio_insert_row = database_subparsers.add_parser("studio-insert-row", help="Insert a Studio database table row")
+    studio_insert_row.add_argument("table_name")
+    studio_insert_row.add_argument("--values", required=True, help="JSON object of column values")
+    _add_env_scope_arg(studio_insert_row)
+    _add_schema_arg(studio_insert_row)
+    _set_handler(studio_insert_row, _cmd_studio_insert_row)
+
+    studio_update_row = database_subparsers.add_parser("studio-update-row", help="Update a Studio database table row")
+    studio_update_row.add_argument("table_name")
+    studio_update_row.add_argument("--values", required=True, help="JSON object of column values")
+    studio_update_row.add_argument("--row-id", default=None)
+    studio_update_row.add_argument("--row-index", type=int, default=None)
+    _add_env_scope_arg(studio_update_row)
+    _add_schema_arg(studio_update_row)
+    _set_handler(studio_update_row, _cmd_studio_update_row)
+
+    studio_delete_rows = database_subparsers.add_parser("studio-delete-rows", help="Delete Studio database table rows")
+    studio_delete_rows.add_argument("table_name")
+    studio_delete_rows.add_argument("--row-id", action="append", default=None)
+    studio_delete_rows.add_argument("--row-index", action="append", type=int, default=None)
+    _add_env_scope_arg(studio_delete_rows)
+    _add_schema_arg(studio_delete_rows)
+    _set_handler(studio_delete_rows, _cmd_studio_delete_rows)
+
+    studio_sql = database_subparsers.add_parser("studio-sql", help="Execute Studio database SQL through the managed Studio endpoint")
+    studio_sql.add_argument("sql_text")
+    _add_env_scope_arg(studio_sql)
+    _set_handler(studio_sql, _cmd_studio_sql)
+
+    studio_control_sql = database_subparsers.add_parser("studio-control-sql", help="Execute controlled Studio database SQL")
+    studio_control_sql.add_argument("sql_text")
+    _add_env_scope_arg(studio_control_sql)
+    _set_handler(studio_control_sql, _cmd_studio_control_sql)
+
+    studio_explain_sql = database_subparsers.add_parser("studio-explain-sql", help="Explain a Studio database SQL query")
+    studio_explain_sql.add_argument("sql_text")
+    _add_env_scope_arg(studio_explain_sql)
+    _set_handler(studio_explain_sql, _cmd_studio_explain_sql)
+
+    studio_sql_history = database_subparsers.add_parser("studio-sql-history", help="List Studio database SQL history")
+    _add_env_scope_arg(studio_sql_history)
+    _set_handler(studio_sql_history, _cmd_studio_sql_history)
+
+    studio_migrations = database_subparsers.add_parser("studio-migrations", help="List Studio database migration history")
+    _add_env_scope_arg(studio_migrations)
+    _set_handler(studio_migrations, _cmd_studio_migrations)
+
+    studio_migration = database_subparsers.add_parser("studio-migration", help="Fetch a Studio database migration")
+    studio_migration.add_argument("migration_id")
+    _set_handler(studio_migration, _cmd_studio_migration)
+
+    studio_create_migration = database_subparsers.add_parser("studio-create-migration", help="Create a Studio database migration task")
+    studio_create_migration.add_argument("--title", required=True)
+    studio_create_migration.add_argument("--statement", action="append", default=None, help="SQL statement. Can be repeated.")
+    studio_create_migration.add_argument("--schema", default=None, help="Target schema JSON object")
+    studio_create_migration.add_argument("--execute", action="store_true", help="Run migration instead of dry-run")
+    _add_env_scope_arg(studio_create_migration)
+    _set_handler(studio_create_migration, _cmd_studio_create_migration)
+
+    studio_sync = database_subparsers.add_parser("studio-sync", help="Sync current Studio project database between environments")
+    studio_sync.add_argument("--source-scope", choices=["dev", "prod"], default="dev")
+    studio_sync.add_argument("--target-scope", choices=["dev", "prod"], default="prod")
+    studio_sync.add_argument("--table", action="append", default=None, help="schema.table to sync. Can be repeated.")
+    studio_sync.add_argument("--source-project-id", default=None)
+    studio_sync.add_argument("--target-project-id", default=None)
+    _set_handler(studio_sync, _cmd_studio_sync)
+
+    studio_sync_project = database_subparsers.add_parser("studio-sync-project", help="Sync Studio database across projects")
+    studio_sync_project.add_argument("source_project_id")
+    studio_sync_project.add_argument("target_project_id")
+    studio_sync_project.add_argument("--source-scope", choices=["dev", "prod"], default="dev")
+    studio_sync_project.add_argument("--target-scope", choices=["dev", "prod"], default="prod")
+    studio_sync_project.add_argument("--table", action="append", default=None, help="schema.table to sync. Can be repeated.")
+    _set_handler(studio_sync_project, _cmd_studio_sync_project)
+
+    studio_backup_export = database_subparsers.add_parser("studio-backup-export", help="Export Studio production database backup")
+    _add_env_scope_arg(studio_backup_export, default="prod")
+    _set_handler(studio_backup_export, _cmd_studio_backup_export)
+
+    studio_backup_import = database_subparsers.add_parser("studio-backup-import", help="Import Studio production database backup")
+    studio_backup_import.add_argument("--backup", default=None, help="Backup JSON object")
+    studio_backup_import.add_argument("--backup-file", default=None, help="Path to backup JSON file")
+    _add_env_scope_arg(studio_backup_import, default="prod")
+    _set_handler(studio_backup_import, _cmd_studio_backup_import)