dwf-platform-cli 0.2.0__py3-none-any.whl

dwf_cli/cli/datamodel.py

@@ -0,0 +1,2270 @@
+from __future__ import annotations
+
+import json as json_mod
+from enum import Enum
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from dwf_cli.api import datamodel as datamodel_api
+from dwf_cli.api.datamodel import ModelType
+from dwf_cli.cli._common import (
+    get_client,
+    get_console,
+    handle_error,
+    is_tty,
+    resolve_format,
+    validate_path,
+)
+from dwf_cli.core.errors import ConflictError, DWFError
+from dwf_cli.core.output import OutputFormat
+from dwf_cli.core.validator import validate_body
+from dwf_cli.schemas import lookup as lookup_schema
+
+_HELP_CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+app = typer.Typer(
+    help="Data model and object management.\n\n"
+    "Examples:\n"
+    "  dwf-cli datamodel list -t entity --search User\n"
+    "  dwf-cli datamodel show User\n"
+    '  dwf-cli datamodel create --data \'[{"className":"TestClass"}]\'\n'
+    "  dwf-cli datamodel create -t relation --data '[...]'\n"
+    "  dwf-cli datamodel create -t external --data '[...]'\n"
+    "  dwf-cli datamodel object list -c User -p 0 -s 10\n"
+    '  dwf-cli datamodel object create -c User --data \'{"name":"Alice"}\'\n'
+    '  dwf-cli datamodel attribute create --data \'{"attributeName":"age","valueType":"Integer"}\'',
+    context_settings=_HELP_CONTEXT_SETTINGS,
+)
+
+_object_sub = typer.Typer(
+    help="Object CRUD operations.", context_settings=_HELP_CONTEXT_SETTINGS
+)
+_attribute_sub = typer.Typer(
+    help="Attribute CRUD and binding operations.",
+    context_settings=_HELP_CONTEXT_SETTINGS,
+)
+
+app.add_typer(_object_sub, name="object")
+app.add_typer(_attribute_sub, name="attribute")
+
+
+DRY_RUN_EXIT_CODE = 10
+
+
+_DATAMODEL_COLUMNS: list[tuple[str, str]] = [
+    ("className", "ClassName"),
+    ("displayName", "DisplayName"),
+    ("classType", "ClassType"),
+    ("isSystem", "System"),
+    ("zoneName", "Zone"),
+    ("state", "State"),
+]
+
+
+def _extract_response(result: dict[str, Any]) -> tuple[list[dict], dict | None]:
+    payload = result.get("data", result)
+    if isinstance(payload, dict):
+        raw = payload.get("data", payload.get("items", []))
+        page_info = payload.get("pageInfo")
+        if isinstance(raw, dict):
+            items = list(raw.values())
+        elif isinstance(raw, list):
+            items = raw
+        else:
+            items = []
+    else:
+        items = payload if isinstance(payload, list) else []
+        page_info = result.get("pageInfo")
+    return items, page_info
+
+
+def _print_table(
+    items: list[dict[str, Any]],
+    page_info: dict[str, Any] | None,
+    console: Console,
+    columns: list[tuple[str, str]] | None = None,
+    title: str | None = None,
+) -> None:
+    cols = columns or _DATAMODEL_COLUMNS
+    table = Table(
+        title=title,
+        show_header=True,
+        header_style="bold cyan",
+        show_lines=False,
+    )
+    table.add_column("#", style="dim", width=4)
+    for _, header in cols:
+        table.add_column(header)
+
+    for idx, item in enumerate(items, 1):
+        row: list[str] = [str(idx)]
+        for key, _ in cols:
+            val = item.get(key, "")
+            if key == "isSystem":
+                val = "[green]Yes[/green]" if val else "[dim]No[/dim]"
+            elif key == "state":
+                val = "[green]Active[/green]" if val == 1 else "[yellow]Draft[/yellow]"
+            else:
+                val = str(val)
+            row.append(val)
+        table.add_row(*row)
+
+    console.print(table)
+
+    if page_info:
+        total = page_info.get("totalCount", "?")
+        page_idx = page_info.get("pageIndex", "?")
+        page_sz = page_info.get("pageSize", "?")
+        console.print(f"[dim]Page {page_idx}, Size {page_sz}, Total {total}[/dim]")
+
+
+def _read_payload(data: str, file: Path | None) -> Any:
+    if file:
+        file = validate_path(file)
+        return json_mod.loads(file.read_text(encoding="utf-8"))
+    if data:
+        return json_mod.loads(data)
+    raise DWFError("Provide --data or --file")
+
+
+def _do_validate(command_path: str, payload: Any) -> None:
+    schema = lookup_schema(command_path)
+    if schema is None:
+        typer.echo(
+            f"No schema found for '{command_path}', skipping validation.", err=True
+        )
+        return
+    errors = validate_body(schema, payload)
+    if errors:
+        error_json = json_mod.dumps(
+            {"error": "validation_failed", "errors": errors},
+            ensure_ascii=False,
+            indent=2,
+        )
+        typer.echo(error_json, err=True)
+        raise typer.Exit(code=2)
+
+
+def _empty_ok(ctx: typer.Context, msg: str = "No results.") -> None:
+    if is_tty():
+        get_console().print(f"[dim]{msg}[/dim]")
+    else:
+        typer.echo("[]")
+
+
+@app.command(name="list")
+def list_models(
+    ctx: typer.Context,
+    model_type: Annotated[
+        ModelType,
+        typer.Option(
+            "--type",
+            "-t",
+            help="Model type: entity(e), relation(r), external(x)",
+            case_sensitive=False,
+        ),
+    ] = ModelType.entity,
+    page: Annotated[int, typer.Option("--page", "-p", help="Page index (0-based)")] = 0,
+    page_size: Annotated[
+        int, typer.Option("--page-size", "-s", help="Items per page")
+    ] = 25,
+    page_all: Annotated[
+        bool,
+        typer.Option("--page-all", help="Fetch all pages automatically"),
+    ] = False,
+    system: Annotated[
+        bool,
+        typer.Option("--system", help="Include system models (entity only)"),
+    ] = False,
+    search: Annotated[
+        str | None,
+        typer.Option("--search", help="Fuzzy search keyword"),
+    ] = None,
+    search_fields: Annotated[
+        str | None,
+        typer.Option(
+            "--search-fields",
+            help="Comma-separated fields to search (default: className,displayName,zoneName,note)",
+        ),
+    ] = None,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        sf = [s.strip() for s in search_fields.split(",")] if search_fields else None
+        if page_all:
+            all_items: list[dict[str, Any]] = []
+            page_idx = 0
+            while True:
+                r = datamodel_api.list_models(
+                    client,
+                    model_type,
+                    page=page_idx,
+                    page_size=page_size,
+                    with_page_info=True,
+                    is_system=system,
+                    search=search,
+                    search_fields=sf,
+                )
+                p_items, p_info = _extract_response(r)
+                all_items.extend(p_items)
+                total = p_info.get("totalCount", 0) if p_info else 0
+                if not p_items or (total > 0 and len(all_items) >= total):
+                    break
+                page_idx += 1
+            result = {
+                "data": {
+                    "data": all_items,
+                    "pageInfo": {"totalCount": len(all_items)},
+                }
+            }
+        else:
+            result = datamodel_api.list_models(
+                client,
+                model_type,
+                page=page,
+                page_size=page_size,
+                with_page_info=True,
+                is_system=system,
+                search=search,
+                search_fields=sf,
+            )
+        items, page_info = _extract_response(result)
+
+        if not items:
+            _empty_ok(ctx, "No data models found.")
+            return
+
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+
+        _print_table(items, page_info, get_console())
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command()
+def show(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Argument(help="Class name (e.g. User, Quartz)")],
+    with_sys_attr: Annotated[
+        bool,
+        typer.Option("--with-sys-attr", help="Include system attributes"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = datamodel_api.get_attributes(
+            client,
+            class_name,
+            need_sys_attr=with_sys_attr,
+        )
+
+        if isinstance(result, dict):
+            payload = result.get("data", result)
+            items = payload if isinstance(payload, list) else [payload]
+        elif isinstance(result, list):
+            items = result
+        else:
+            items = []
+
+        if not items:
+            _empty_ok(ctx, f"No attributes found for '{class_name}'.")
+            return
+
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+
+        _ATTR_COLUMNS: list[tuple[str, str]] = [
+            ("attributeName", "Name"),
+            ("displayName", "DisplayName"),
+            ("valueType", "DataType"),
+            ("valueLength", "Length"),
+            ("nullable", "Nullable"),
+            ("visible", "Visible"),
+            ("editable", "Editable"),
+        ]
+        table = Table(
+            title=f"Attributes of [bold]{class_name}[/bold]",
+            show_header=True,
+            header_style="bold cyan",
+            show_lines=False,
+        )
+        table.add_column("#", style="dim", width=4)
+        for _, header in _ATTR_COLUMNS:
+            table.add_column(header)
+
+        for idx, item in enumerate(items, 1):
+            row: list[str] = [str(idx)]
+            for key, _ in _ATTR_COLUMNS:
+                val = item.get(key, "")
+                if key in ("nullable", "visible", "editable"):
+                    val = "[green]Yes[/green]" if val else "[dim]No[/dim]"
+                elif key == "valueLength":
+                    val = str(val) if val else "-"
+                else:
+                    val = str(val)
+                row.append(val)
+            table.add_row(*row)
+
+        get_console().print(table)
+        get_console().print(f"[dim]Total {len(items)} attributes[/dim]")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Argument(help="Class name")],
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = datamodel_api.get_class(client, class_name)
+
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+
+        console = get_console()
+        data = result.get("data", result) if isinstance(result, dict) else result
+        if isinstance(data, dict):
+            for key, value in data.items():
+                console.print(f"[bold]{key}[/bold]: {value}")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+class ExternalMode(str, Enum):
+    sql = "sql"
+    view = "view"
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    data: Annotated[str, typer.Option("--data", "-d", help="JSON data string")] = "",
+    file: Annotated[
+        Path | None, typer.Option("--file", help="Path to JSON data file")
+    ] = None,
+    model_type: Annotated[
+        ModelType,
+        typer.Option(
+            "--type",
+            "-t",
+            help="Create type: entity(e), relation(r), external(x)",
+            case_sensitive=False,
+        ),
+    ] = ModelType.entity,
+    with_parent_oid: Annotated[
+        bool,
+        typer.Option("--with-parent-oid", help="Append withParentOid query param"),
+    ] = False,
+    external_mode: Annotated[
+        ExternalMode,
+        typer.Option(
+            "--external-mode",
+            help="External create mode: view (default) or sql",
+            case_sensitive=False,
+        ),
+    ] = ExternalMode.view,
+    if_not_exists: Annotated[
+        bool,
+        typer.Option("--if-not-exists", help="Skip if class already exists"),
+    ] = False,
+    validate: Annotated[
+        bool,
+        typer.Option(
+            "--validate", help="Validate input against schema before executing"
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        raw_payload = _read_payload(data, file)
+
+        resolved_type = model_type.value
+        if resolved_type in ("e",):
+            resolved_type = "entity"
+        elif resolved_type in ("r",):
+            resolved_type = "relation"
+        elif resolved_type in ("x",):
+            resolved_type = "external"
+
+        if resolved_type == "entity":
+            payload = raw_payload if isinstance(raw_payload, list) else [raw_payload]
+
+            if validate:
+                _do_validate("datamodel create", payload)
+
+            if dry_run:
+                typer.echo(
+                    json_mod.dumps(
+                        {
+                            "action": "create",
+                            "resource": "entity",
+                            "data": payload,
+                            "with_parent_oid": with_parent_oid,
+                            "if_not_exists": if_not_exists,
+                            "reversible": False,
+                        },
+                        ensure_ascii=False,
+                        indent=2,
+                    )
+                )
+                raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+            client = get_client(ctx)
+            try:
+                result = datamodel_api.create_entity(
+                    client, payload, with_parent_oid=with_parent_oid
+                )
+                if fmt == OutputFormat.json:
+                    typer.echo(
+                        json_mod.dumps(
+                            {
+                                "success": True,
+                                "action": "create",
+                                "resource": "entity",
+                                "data": result,
+                            },
+                            ensure_ascii=False,
+                            indent=2,
+                        )
+                    )
+                else:
+                    typer.echo(f"Created: {result}", err=True)
+            except ConflictError:
+                if if_not_exists:
+                    typer.echo(
+                        "Entity already exists, skipped (--if-not-exists).", err=True
+                    )
+                else:
+                    raise
+
+        elif resolved_type == "relation":
+            payload = raw_payload if isinstance(raw_payload, list) else [raw_payload]
+
+            if validate:
+                _do_validate("datamodel relation create", payload)
+
+            if dry_run:
+                typer.echo(
+                    json_mod.dumps(
+                        {
+                            "action": "create",
+                            "resource": "relation",
+                            "data": payload,
+                            "if_not_exists": if_not_exists,
+                            "reversible": False,
+                        },
+                        ensure_ascii=False,
+                        indent=2,
+                    )
+                )
+                raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+            client = get_client(ctx)
+            try:
+                result = datamodel_api.create_relations(client, payload)
+                if fmt == OutputFormat.json:
+                    typer.echo(
+                        json_mod.dumps(
+                            {
+                                "success": True,
+                                "action": "create",
+                                "resource": "relation",
+                                "data": result,
+                            },
+                            ensure_ascii=False,
+                            indent=2,
+                        )
+                    )
+                else:
+                    typer.echo(f"Created: {result}", err=True)
+            except ConflictError:
+                if if_not_exists:
+                    typer.echo(
+                        "Relation already exists, skipped (--if-not-exists).", err=True
+                    )
+                else:
+                    raise
+
+        elif resolved_type == "external":
+            if external_mode == ExternalMode.view:
+                class_list = (
+                    raw_payload if isinstance(raw_payload, list) else [raw_payload]
+                )
+
+                if validate:
+                    _do_validate("datamodel create", class_list)
+
+                if dry_run:
+                    typer.echo(
+                        json_mod.dumps(
+                            {
+                                "action": "create",
+                                "resource": "external-class",
+                                "external_mode": "view",
+                                "data": class_list,
+                                "with_parent_oid": with_parent_oid,
+                                "if_not_exists": if_not_exists,
+                            },
+                            ensure_ascii=False,
+                            indent=2,
+                        )
+                    )
+                    raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+                client = get_client(ctx)
+                try:
+                    result = datamodel_api.create_entity(
+                        client, class_list, with_parent_oid=with_parent_oid
+                    )
+                    if fmt == OutputFormat.json:
+                        typer.echo(
+                            json_mod.dumps(
+                                {
+                                    "success": True,
+                                    "action": "create",
+                                    "resource": "external-class",
+                                    "external_mode": "view",
+                                    "data": result,
+                                },
+                                ensure_ascii=False,
+                                indent=2,
+                            )
+                        )
+                    else:
+                        typer.echo(f"Created: {result}", err=True)
+                except ConflictError:
+                    if if_not_exists:
+                        typer.echo(
+                            "External class already exists, skipped (--if-not-exists).",
+                            err=True,
+                        )
+                    else:
+                        raise
+            else:
+                if not isinstance(raw_payload, dict):
+                    raise DWFError(
+                        "External SQL mode requires a JSON object with 'classList' and optional 'customSqlMap'"
+                    )
+
+                class_list = raw_payload.get("classList", [])
+                sql_map = raw_payload.get("customSqlMap")
+
+                if validate:
+                    _do_validate("datamodel external create", raw_payload)
+
+                if dry_run:
+                    typer.echo(
+                        json_mod.dumps(
+                            {
+                                "action": "create",
+                                "resource": "external-class",
+                                "external_mode": "sql",
+                                "classList": class_list,
+                                "customSqlMap": sql_map,
+                                "if_not_exists": if_not_exists,
+                            },
+                            ensure_ascii=False,
+                            indent=2,
+                        )
+                    )
+                    raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+                client = get_client(ctx)
+                try:
+                    result = datamodel_api.create_external_class(
+                        client, class_list, custom_sql_map=sql_map
+                    )
+                    if fmt == OutputFormat.json:
+                        typer.echo(
+                            json_mod.dumps(
+                                {
+                                    "success": True,
+                                    "action": "create",
+                                    "resource": "external-class",
+                                    "external_mode": "sql",
+                                    "data": result,
+                                },
+                                ensure_ascii=False,
+                                indent=2,
+                            )
+                        )
+                    else:
+                        typer.echo(f"Created: {result}", err=True)
+                except ConflictError:
+                    if if_not_exists:
+                        typer.echo(
+                            "External class already exists, skipped (--if-not-exists).",
+                            err=True,
+                        )
+                    else:
+                        raise
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command()
+def update(
+    ctx: typer.Context,
+    data: Annotated[str, typer.Option("--data", "-d", help="JSON data string")] = "",
+    file: Annotated[
+        Path | None, typer.Option("--file", help="Path to JSON data file")
+    ] = None,
+    model_type: Annotated[
+        ModelType,
+        typer.Option(
+            "--type",
+            "-t",
+            help="Update type: entity(e), relation(r), external(x)",
+            case_sensitive=False,
+        ),
+    ] = ModelType.entity,
+    external_mode: Annotated[
+        ExternalMode,
+        typer.Option(
+            "--external-mode",
+            help="External update mode: view (default) or sql",
+            case_sensitive=False,
+        ),
+    ] = ExternalMode.view,
+    validate: Annotated[
+        bool,
+        typer.Option(
+            "--validate", help="Validate input against schema before executing"
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        raw_payload = _read_payload(data, file)
+
+        resolved_type = model_type.value
+        if resolved_type in ("e",):
+            resolved_type = "entity"
+        elif resolved_type in ("r",):
+            resolved_type = "relation"
+        elif resolved_type in ("x",):
+            resolved_type = "external"
+
+        if resolved_type == "external":
+            if external_mode == ExternalMode.view:
+                if validate:
+                    _do_validate("datamodel update", raw_payload)
+
+                if dry_run:
+                    typer.echo(
+                        json_mod.dumps(
+                            {
+                                "action": "update",
+                                "resource": "external-class",
+                                "external_mode": "view",
+                                "data": raw_payload,
+                            },
+                            ensure_ascii=False,
+                            indent=2,
+                        )
+                    )
+                    raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+                client = get_client(ctx)
+                result = datamodel_api.update_entity(client, raw_payload)
+                if fmt == OutputFormat.json:
+                    typer.echo(
+                        json_mod.dumps(
+                            {
+                                "success": True,
+                                "action": "update",
+                                "resource": "external-class",
+                                "external_mode": "view",
+                                "data": result,
+                            },
+                            ensure_ascii=False,
+                            indent=2,
+                        )
+                    )
+                else:
+                    typer.echo("Updated.", err=True)
+            else:
+                if not isinstance(raw_payload, dict):
+                    raise DWFError(
+                        "External SQL mode requires a JSON object with 'classList' and optional 'customSqlMap'"
+                    )
+
+                class_list = raw_payload.get("classList", [])
+                sql_map = raw_payload.get("customSqlMap")
+
+                if validate:
+                    _do_validate("datamodel update --type external", raw_payload)
+
+                if dry_run:
+                    typer.echo(
+                        json_mod.dumps(
+                            {
+                                "action": "update",
+                                "resource": "external-class",
+                                "external_mode": "sql",
+                                "classList": class_list,
+                                "customSqlMap": sql_map,
+                            },
+                            ensure_ascii=False,
+                            indent=2,
+                        )
+                    )
+                    raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+                client = get_client(ctx)
+                result = datamodel_api.update_external_class(
+                    client, class_list, custom_sql_map=sql_map
+                )
+                if fmt == OutputFormat.json:
+                    typer.echo(
+                        json_mod.dumps(
+                            {
+                                "success": True,
+                                "action": "update",
+                                "resource": "external-class",
+                                "external_mode": "sql",
+                                "data": result,
+                            },
+                            ensure_ascii=False,
+                            indent=2,
+                        )
+                    )
+                else:
+                    typer.echo(f"Updated: {result}", err=True)
+        else:
+            schema_key = (
+                "datamodel update"
+                if resolved_type == "entity"
+                else "datamodel relation update"
+            )
+            resource = "class" if resolved_type == "entity" else "relation"
+
+            if validate:
+                _do_validate(schema_key, raw_payload)
+
+            if dry_run:
+                typer.echo(
+                    json_mod.dumps(
+                        {
+                            "action": "update",
+                            "resource": resource,
+                            "data": raw_payload,
+                            "reversible": True,
+                        },
+                        ensure_ascii=False,
+                        indent=2,
+                    )
+                )
+                raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+            client = get_client(ctx)
+            if resolved_type == "relation":
+                result = datamodel_api.update_relation(client, raw_payload)
+            else:
+                result = datamodel_api.update_entity(client, raw_payload)
+            if fmt == OutputFormat.json:
+                typer.echo(
+                    json_mod.dumps(
+                        {
+                            "success": True,
+                            "action": "update",
+                            "resource": resolved_type,
+                            "data": result,
+                        },
+                        ensure_ascii=False,
+                        indent=2,
+                    )
+                )
+            else:
+                typer.echo("Updated.", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Argument(help="Class name to delete")],
+    cascade: Annotated[
+        bool,
+        typer.Option("--cascade", help="Cascade delete relations, operations, views"),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    yes: Annotated[
+        bool,
+        typer.Option("--force", help="Skip confirmation prompt"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete",
+                        "resource": "class",
+                        "target": class_name,
+                        "cascade": cascade,
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        if is_tty() and not yes:
+            confirm = typer.confirm(f"Delete class '{class_name}'?", default=False)
+            if not confirm:
+                typer.echo("Cancelled.", err=True)
+                raise typer.Exit(code=0)
+
+        client = get_client(ctx)
+        result = datamodel_api.delete_class(client, class_name, cascade=cascade)
+        if fmt == OutputFormat.json:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "success": True,
+                        "action": "delete",
+                        "resource": "class",
+                        "target": class_name,
+                        "data": result,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+        else:
+            typer.echo(f"Deleted: {class_name}", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_attribute_sub.command(name="list")
+def list_attributes(
+    ctx: typer.Context,
+    keyword: Annotated[
+        str | None,
+        typer.Option("--keyword", "-k", help="Search keyword"),
+    ] = None,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = datamodel_api.list_attributes(client, keyword=keyword)
+
+        if isinstance(result, dict):
+            payload = result.get("data", result)
+            items = payload if isinstance(payload, list) else [payload]
+        elif isinstance(result, list):
+            items = result
+        else:
+            items = []
+
+        if not items:
+            _empty_ok(ctx, "No attributes found.")
+            return
+
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+
+        _ATTR_COLUMNS: list[tuple[str, str]] = [
+            ("attributeName", "Name"),
+            ("displayName", "DisplayName"),
+            ("valueType", "DataType"),
+            ("valueLength", "Length"),
+            ("nullable", "Nullable"),
+        ]
+        table = Table(
+            title="All Attributes",
+            show_header=True,
+            header_style="bold cyan",
+            show_lines=False,
+        )
+        table.add_column("#", style="dim", width=4)
+        for _, header in _ATTR_COLUMNS:
+            table.add_column(header)
+        for idx, item in enumerate(items, 1):
+            row: list[str] = [str(idx)]
+            for key, _ in _ATTR_COLUMNS:
+                val = item.get(key, "")
+                if key == "nullable":
+                    val = "[green]Yes[/green]" if val else "[dim]No[/dim]"
+                elif key == "valueLength":
+                    val = str(val) if val else "-"
+                else:
+                    val = str(val)
+                row.append(val)
+            table.add_row(*row)
+        get_console().print(table)
+        get_console().print(f"[dim]Total {len(items)} attributes[/dim]")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+# ── Object CRUD subgroup ──────────────────────────────────────────
+
+
+@_object_sub.command(name="list")
+def list_objects(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    page: Annotated[int, typer.Option("--page", "-p", help="Page index (0-based)")] = 0,
+    page_size: Annotated[
+        int, typer.Option("--page-size", "-s", help="Items per page")
+    ] = 25,
+    page_all: Annotated[
+        bool,
+        typer.Option("--page-all", help="Fetch all pages automatically"),
+    ] = False,
+    condition: Annotated[
+        str | None,
+        typer.Option("--condition", help="SQL WHERE clause (simple mode only)"),
+    ] = None,
+    data: Annotated[
+        str, typer.Option("--data", "-d", help="Full QueryObjReq JSON (advanced mode)")
+    ] = "",
+    file: Annotated[
+        Path | None,
+        typer.Option("--file", help="Path to QueryObjReq JSON file (advanced mode)"),
+    ] = None,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if (data or file) and condition:
+            raise DWFError("--condition is incompatible with --data/--file")
+
+        client = get_client(ctx)
+
+        if data or file:
+            body = _read_payload(data, file)
+            if not isinstance(body, dict):
+                raise DWFError("--data/--file must contain a JSON object")
+
+            if page_all:
+                all_items: list[dict[str, Any]] = []
+                page_idx = 0
+                while True:
+                    r = datamodel_api.query_objects(
+                        client,
+                        class_name,
+                        body=dict(body),
+                        page=page_idx,
+                        page_size=page_size,
+                    )
+                    p_items, p_info = _extract_response(r)
+                    all_items.extend(p_items)
+                    total = p_info.get("totalCount", 0) if p_info else 0
+                    if not p_items or (total > 0 and len(all_items) >= total):
+                        break
+                    page_idx += 1
+                result = {
+                    "data": {
+                        "data": all_items,
+                        "pageInfo": {"totalCount": len(all_items)},
+                    }
+                }
+            else:
+                result = datamodel_api.query_objects(
+                    client,
+                    class_name,
+                    body=dict(body),
+                    page=page,
+                    page_size=page_size,
+                )
+        else:
+            if page_all:
+                all_items = []
+                page_idx = 0
+                while True:
+                    r = datamodel_api.list_objects(
+                        client,
+                        class_name,
+                        page=page_idx,
+                        page_size=page_size,
+                        condition=condition,
+                    )
+                    p_items, p_info = _extract_response(r)
+                    all_items.extend(p_items)
+                    total = p_info.get("totalCount", 0) if p_info else 0
+                    if not p_items or (total > 0 and len(all_items) >= total):
+                        break
+                    page_idx += 1
+                result = {
+                    "data": {
+                        "data": all_items,
+                        "pageInfo": {"totalCount": len(all_items)},
+                    }
+                }
+            else:
+                result = datamodel_api.list_objects(
+                    client,
+                    class_name,
+                    page=page,
+                    page_size=page_size,
+                    condition=condition,
+                )
+
+        items, page_info = _extract_response(result)
+
+        if not items:
+            _empty_ok(ctx, f"No objects found for '{class_name}'.")
+            return
+
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+
+        if items and not isinstance(items[0], dict):
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+
+        cols = list(items[0].keys()) if items else []
+        col_tuples = [(c, c) for c in cols]
+        _print_table(items, page_info, get_console(), columns=col_tuples)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_object_sub.command(name="get")
+def get_object(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="Object OID")],
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = datamodel_api.get_object(client, class_name, oid)
+
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+
+        console = get_console()
+        data = result.get("data", result) if isinstance(result, dict) else result
+        if isinstance(data, dict):
+            for key, value in data.items():
+                console.print(f"[bold]{key}[/bold]: {value}")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_object_sub.command(name="create")
+def create_objects(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    data: Annotated[str, typer.Option("--data", "-d", help="JSON data string")] = "",
+    file: Annotated[
+        Path | None, typer.Option("--file", help="Path to JSON data file")
+    ] = None,
+    if_not_exists: Annotated[
+        bool,
+        typer.Option("--if-not-exists", help="Skip if object already exists"),
+    ] = False,
+    validate: Annotated[
+        bool,
+        typer.Option(
+            "--validate", help="Validate input against schema before executing"
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        payload = _read_payload(data, file)
+        if isinstance(payload, dict):
+            payload = [payload]
+
+        if validate:
+            _do_validate("datamodel object create", payload)
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "create",
+                        "resource": class_name,
+                        "data": payload,
+                        "if_not_exists": if_not_exists,
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        try:
+            result = datamodel_api.create_objects(client, class_name, payload)
+            if fmt == OutputFormat.json:
+                typer.echo(
+                    json_mod.dumps(
+                        {
+                            "success": True,
+                            "action": "create",
+                            "resource": class_name,
+                            "count": len(payload),
+                            "data": result,
+                        },
+                        ensure_ascii=False,
+                        indent=2,
+                    )
+                )
+            else:
+                typer.echo(f"Created {len(payload)} object(s).", err=True)
+        except ConflictError:
+            if if_not_exists:
+                typer.echo(
+                    "Object already exists, skipped (--if-not-exists).", err=True
+                )
+            else:
+                raise
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_object_sub.command(name="update")
+def update_objects(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    data: Annotated[str, typer.Option("--data", "-d", help="JSON data string")] = "",
+    file: Annotated[
+        Path | None, typer.Option("--file", help="Path to JSON data file")
+    ] = None,
+    force_update: Annotated[
+        bool,
+        typer.Option("--force-update", help="Force update"),
+    ] = False,
+    validate: Annotated[
+        bool,
+        typer.Option(
+            "--validate", help="Validate input against schema before executing"
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        payload = _read_payload(data, file)
+        if isinstance(payload, dict):
+            payload = [payload]
+
+        if validate:
+            _do_validate("datamodel object update", payload)
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "update",
+                        "resource": class_name,
+                        "data": payload,
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        result = datamodel_api.update_objects(
+            client, class_name, payload, force_update=force_update
+        )
+        if fmt == OutputFormat.json:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "success": True,
+                        "action": "update",
+                        "resource": class_name,
+                        "count": len(payload),
+                        "data": result,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+        else:
+            typer.echo(f"Updated {len(payload)} object(s).", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_object_sub.command(name="delete")
+def delete_objects(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    oids: Annotated[
+        str | None,
+        typer.Option("--oids", help="Comma-separated OID list"),
+    ] = None,
+    file: Annotated[
+        Path | None,
+        typer.Option("--file", help="Path to JSON file containing OID array"),
+    ] = None,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    yes: Annotated[
+        bool,
+        typer.Option("--force", help="Skip confirmation prompt"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        oid_list: list[str] = []
+        if file:
+            file = validate_path(file)
+            oid_list = json_mod.loads(file.read_text(encoding="utf-8"))
+        elif oids:
+            oid_list = [o.strip() for o in oids.split(",") if o.strip()]
+        else:
+            typer.echo("Error: provide --oids or --file", err=True)
+            raise typer.Exit(code=1)
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete",
+                        "resource": class_name,
+                        "targets": oid_list,
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        if is_tty() and not yes:
+            confirm = typer.confirm(
+                f"Delete {len(oid_list)} object(s) from '{class_name}'?",
+                default=False,
+            )
+            if not confirm:
+                typer.echo("Cancelled.", err=True)
+                raise typer.Exit(code=0)
+
+        client = get_client(ctx)
+        result = datamodel_api.delete_objects(client, class_name, oid_list)
+        if fmt == OutputFormat.json:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "success": True,
+                        "action": "delete",
+                        "resource": class_name,
+                        "count": len(oid_list),
+                        "data": result,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+        else:
+            typer.echo(f"Deleted {len(oid_list)} object(s).", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_object_sub.command(name="count")
+def count_objects(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    condition: Annotated[
+        str | None,
+        typer.Option("--condition", help="SQL WHERE clause, e.g. \"and name='test'\""),
+    ] = None,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = datamodel_api.count_objects(client, class_name, condition=condition)
+
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+
+        data = result.get("data", result) if isinstance(result, dict) else result
+        get_console().print(f"Count for '{class_name}': {data}")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+# ── Import / Export ──────────────────────────────────────────────
+
+
+@app.command(name="import")
+def import_data_cmd(
+    ctx: typer.Context,
+    file: Annotated[Path, typer.Argument(help="Path to data file to import")],
+    update_if_exist: Annotated[
+        bool,
+        typer.Option("--update-if-exist", help="Update existing records on conflict"),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        file = validate_path(file)
+        if not file.exists():
+            raise DWFError(f"File not found: {file}")
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "import",
+                        "file": str(file),
+                        "update_if_exist": update_if_exist,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        uuid_result = datamodel_api.get_import_uuid(
+            client, update_if_exist=update_if_exist
+        )
+        uuid_val = (
+            uuid_result.get("data", uuid_result)
+            if isinstance(uuid_result, dict)
+            else uuid_result
+        )
+
+        result = datamodel_api.import_data(client, str(uuid_val), "", str(file))
+        typer.echo(f"Import started: {result}", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command(name="export")
+def export_data_cmd(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    attributes: Annotated[
+        str,
+        typer.Option("--attributes", "-a", help="Comma-separated attribute names"),
+    ],
+    output: Annotated[
+        Path | None,
+        typer.Option("--output", "-o", help="Output file path (default: stdout)"),
+    ] = None,
+    condition: Annotated[
+        str | None,
+        typer.Option("--condition", help="SQL WHERE condition"),
+    ] = None,
+    join_to_one: Annotated[
+        bool,
+        typer.Option("--join-to-one", help="Merge into one sheet (relation classes)"),
+    ] = False,
+    title_only: Annotated[
+        bool,
+        typer.Option("--title-only", help="Export headers only"),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        attr_list = [a.strip() for a in attributes.split(",") if a.strip()]
+        if not attr_list:
+            raise DWFError("--attributes cannot be empty")
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "export",
+                        "resource": class_name,
+                        "attributes": attr_list,
+                        "condition": condition,
+                        "join_to_one": join_to_one,
+                        "title_only": title_only,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        response = datamodel_api.export_data(
+            client,
+            class_name,
+            attr_list,
+            condition=condition,
+            join_to_one=join_to_one,
+            title_only=title_only,
+        )
+
+        if output:
+            output = validate_path(output)
+            output.write_bytes(response.content)
+            typer.echo(f"Exported to {output}", err=True)
+        else:
+            typer.echo(response.content, nl=False)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+# ── Excel Quick Start ────────────────────────────────────────────
+
+
+@app.command(name="excel-upload")
+def excel_upload_cmd(
+    ctx: typer.Context,
+    file: Annotated[Path, typer.Argument(help="Path to Excel file")],
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        file = validate_path(file)
+        if not file.exists():
+            raise DWFError(f"File not found: {file}")
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {"action": "excel-upload", "file": str(file)},
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        result = datamodel_api.upload_excel(client, str(file))
+        typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command(name="excel-confirm")
+def excel_confirm_cmd(
+    ctx: typer.Context,
+    data: Annotated[
+        str, typer.Option("--data", "-d", help="JSON from excel-upload output")
+    ] = "",
+    file: Annotated[
+        Path | None,
+        typer.Option("--file", help="Path to JSON file from excel-upload output"),
+    ] = None,
+    skip_validate: Annotated[
+        bool,
+        typer.Option("--skip-validate", help="Skip class/attribute validation"),
+    ] = False,
+    skip_cleanup: Annotated[
+        bool,
+        typer.Option("--skip-cleanup", help="Skip temp file deletion after confirm"),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Validate only, do not submit"),
+    ] = False,
+) -> None:
+    try:
+        payload = _read_payload(data, file)
+
+        upload_data = (
+            payload.get("data", payload) if isinstance(payload, dict) else payload
+        )
+        if not isinstance(upload_data, dict):
+            raise DWFError(
+                "Invalid payload: expected object with uuid and allSheetInfo"
+            )
+
+        uuid_val = upload_data.get("uuid")
+        if not uuid_val:
+            raise DWFError("Invalid payload: missing uuid")
+
+        all_sheet_info = upload_data.get("allSheetInfo", [])
+        if not all_sheet_info:
+            raise DWFError("Invalid payload: allSheetInfo is empty")
+
+        sheet = all_sheet_info[0]
+        if not sheet.get("useThisSheet", True):
+            raise DWFError(
+                f"First sheet '{sheet.get('sheetName', '?')}' is marked as unused"
+            )
+
+        class_name = sheet.get("className", "")
+        if not class_name:
+            raise DWFError("Sheet missing className")
+
+        client = get_client(ctx)
+        errors: list[str] = []
+
+        if not skip_validate:
+            typer.echo(f"Validating class '{class_name}'...", err=True)
+            valid = datamodel_api.check_class_name_valid(client, class_name)
+            if not valid:
+                errors.append(
+                    f"Class name '{class_name}' is not valid or already exists"
+                )
+
+            col_list = sheet.get("infoFromColumnList", [])
+            for col in col_list:
+                if not col.get("useThisColumn", True):
+                    continue
+                attr_name = col.get("firstRowData", "")
+                data_type = col.get("dataType", "")
+                if not attr_name or not data_type:
+                    continue
+                typer.echo(
+                    f"Validating attribute '{attr_name}:{data_type}'...", err=True
+                )
+                attr_valid = datamodel_api.check_attribute_type_valid(
+                    client, attr_name, data_type
+                )
+                if not attr_valid:
+                    errors.append(
+                        f"Attribute '{attr_name}' with type '{data_type}' is not valid"
+                    )
+
+            if errors:
+                raise DWFError(
+                    "Validation failed",
+                    detail="; ".join(errors),
+                )
+
+        enriched_columns: list[dict[str, Any]] = []
+        for col in sheet.get("infoFromColumnList", []):
+            if not col.get("useThisColumn", True):
+                continue
+            enriched = dict(col)
+            enriched.setdefault("attributeName", col.get("firstRowData", ""))
+            enriched.setdefault("displayName", col.get("secondRowData", ""))
+            enriched_columns.append(enriched)
+
+        confirm_payload = {
+            "uuid": uuid_val,
+            "useFirstRowAsClassName": upload_data.get("useFirstRowAsClassName", True),
+            "useSecondRowAsDisplayName": upload_data.get(
+                "useSecondRowAsDisplayName", True
+            ),
+            "allSheetInfo": [
+                {
+                    "sheetName": sheet.get("sheetName", ""),
+                    "className": class_name,
+                    "displayName": sheet.get("displayName", class_name),
+                    "zoneName": sheet.get("zoneName", "CUS"),
+                    "isTree": sheet.get("isTree", False),
+                    "useThisSheet": True,
+                    "infoFromColumnList": enriched_columns,
+                }
+            ],
+        }
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "excel-confirm",
+                        "dry_run": True,
+                        "validated": not skip_validate,
+                        "payload": confirm_payload,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        typer.echo(f"Confirming class '{class_name}'...", err=True)
+        result = datamodel_api.confirm_excel(client, confirm_payload)
+
+        if not skip_cleanup:
+            typer.echo(f"Cleaning up temp file (uuid={uuid_val})...", err=True)
+            try:
+                datamodel_api.delete_temp_excel(client, uuid_val)
+            except DWFError as cleanup_exc:
+                typer.echo(f"Warning: cleanup failed: {cleanup_exc}", err=True)
+
+        typer.echo(
+            json_mod.dumps(
+                {
+                    "confirmed": True,
+                    "className": class_name,
+                    "uuid": uuid_val,
+                    "cleanup": not skip_cleanup,
+                    "result": result,
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command(name="excel-quickstart")
+def excel_quickstart_cmd(
+    ctx: typer.Context,
+    file: Annotated[Path, typer.Argument(help="Path to Excel file")],
+    skip_validate: Annotated[
+        bool,
+        typer.Option("--skip-validate", help="Skip class/attribute validation"),
+    ] = False,
+    skip_cleanup: Annotated[
+        bool,
+        typer.Option("--skip-cleanup", help="Skip temp file deletion after confirm"),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Upload and validate only, do not confirm"),
+    ] = False,
+) -> None:
+    try:
+        file = validate_path(file)
+        if not file.exists():
+            raise DWFError(f"File not found: {file}")
+
+        client = get_client(ctx)
+
+        typer.echo(f"Uploading {file.name}...", err=True)
+        upload_result = datamodel_api.upload_excel(client, str(file))
+
+        upload_data = (
+            upload_result.get("data", upload_result)
+            if isinstance(upload_result, dict)
+            else upload_result
+        )
+        if not isinstance(upload_data, dict) or not upload_data.get("uuid"):
+            raise DWFError("Upload succeeded but response missing uuid")
+
+        uuid_val = upload_data["uuid"]
+        all_sheet_info = upload_data.get("allSheetInfo", [])
+        if not all_sheet_info:
+            raise DWFError("Upload succeeded but allSheetInfo is empty")
+
+        sheet = all_sheet_info[0]
+        class_name = sheet.get("className", "")
+        if not class_name:
+            raise DWFError("First sheet missing className")
+
+        errors: list[str] = []
+
+        if not skip_validate:
+            typer.echo(f"Validating class '{class_name}'...", err=True)
+            valid = datamodel_api.check_class_name_valid(client, class_name)
+            if not valid:
+                errors.append(
+                    f"Class name '{class_name}' is not valid or already exists"
+                )
+
+            for col in sheet.get("infoFromColumnList", []):
+                if not col.get("useThisColumn", True):
+                    continue
+                attr_name = col.get("firstRowData", "")
+                data_type = col.get("dataType", "")
+                if not attr_name or not data_type:
+                    continue
+                typer.echo(
+                    f"Validating attribute '{attr_name}:{data_type}'...", err=True
+                )
+                attr_valid = datamodel_api.check_attribute_type_valid(
+                    client, attr_name, data_type
+                )
+                if not attr_valid:
+                    errors.append(
+                        f"Attribute '{attr_name}' with type '{data_type}' is not valid"
+                    )
+
+            if errors:
+                if not skip_cleanup:
+                    try:
+                        datamodel_api.delete_temp_excel(client, uuid_val)
+                    except DWFError:
+                        pass
+                raise DWFError(
+                    "Validation failed",
+                    detail="; ".join(errors),
+                )
+
+        enriched_columns: list[dict[str, Any]] = []
+        for col in sheet.get("infoFromColumnList", []):
+            if not col.get("useThisColumn", True):
+                continue
+            enriched = dict(col)
+            enriched.setdefault("attributeName", col.get("firstRowData", ""))
+            enriched.setdefault("displayName", col.get("secondRowData", ""))
+            enriched_columns.append(enriched)
+
+        confirm_payload = {
+            "uuid": uuid_val,
+            "useFirstRowAsClassName": upload_data.get("useFirstRowAsClassName", True),
+            "useSecondRowAsDisplayName": upload_data.get(
+                "useSecondRowAsDisplayName", True
+            ),
+            "allSheetInfo": [
+                {
+                    "sheetName": sheet.get("sheetName", ""),
+                    "className": class_name,
+                    "displayName": sheet.get("displayName", class_name),
+                    "zoneName": sheet.get("zoneName", "CUS"),
+                    "isTree": sheet.get("isTree", False),
+                    "useThisSheet": True,
+                    "infoFromColumnList": enriched_columns,
+                }
+            ],
+        }
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "excel-quickstart",
+                        "dry_run": True,
+                        "uploaded": True,
+                        "uuid": uuid_val,
+                        "validated": not skip_validate,
+                        "payload": confirm_payload,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        typer.echo(f"Confirming class '{class_name}'...", err=True)
+        result = datamodel_api.confirm_excel(client, confirm_payload)
+
+        if not skip_cleanup:
+            typer.echo(f"Cleaning up temp file (uuid={uuid_val})...", err=True)
+            try:
+                datamodel_api.delete_temp_excel(client, uuid_val)
+            except DWFError as cleanup_exc:
+                typer.echo(f"Warning: cleanup failed: {cleanup_exc}", err=True)
+
+        typer.echo(
+            json_mod.dumps(
+                {
+                    "confirmed": True,
+                    "className": class_name,
+                    "uuid": uuid_val,
+                    "cleanup": not skip_cleanup,
+                    "result": result,
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+# ── Attribute CRUD subgroup ──────────────────────────────────────
+
+
+@_attribute_sub.command(name="create")
+def create_attributes(
+    ctx: typer.Context,
+    data: Annotated[str, typer.Option("--data", "-d", help="JSON data string")] = "",
+    file: Annotated[
+        Path | None, typer.Option("--file", help="Path to JSON data file")
+    ] = None,
+    if_not_exists: Annotated[
+        bool,
+        typer.Option("--if-not-exists", help="Skip if attribute already exists"),
+    ] = False,
+    validate: Annotated[
+        bool,
+        typer.Option(
+            "--validate", help="Validate input against schema before executing"
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        payload = _read_payload(data, file)
+        if isinstance(payload, dict):
+            payload = [payload]
+
+        if validate:
+            _do_validate("datamodel attribute create", payload)
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "create",
+                        "resource": "attribute",
+                        "data": payload,
+                        "if_not_exists": if_not_exists,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        try:
+            result = datamodel_api.create_attributes(client, payload)
+            if fmt == OutputFormat.json:
+                typer.echo(
+                    json_mod.dumps(
+                        {
+                            "success": True,
+                            "action": "create",
+                            "resource": "attribute",
+                            "data": result,
+                        },
+                        ensure_ascii=False,
+                        indent=2,
+                    )
+                )
+            else:
+                typer.echo(f"Created: {result}", err=True)
+        except ConflictError:
+            if if_not_exists:
+                typer.echo(
+                    "Attribute already exists, skipped (--if-not-exists).", err=True
+                )
+            else:
+                raise
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_attribute_sub.command(name="update")
+def update_attribute(
+    ctx: typer.Context,
+    data: Annotated[str, typer.Option("--data", "-d", help="JSON data string")] = "",
+    file: Annotated[
+        Path | None, typer.Option("--file", help="Path to JSON data file")
+    ] = None,
+    validate: Annotated[
+        bool,
+        typer.Option(
+            "--validate", help="Validate input against schema before executing"
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        payload = _read_payload(data, file)
+
+        if validate:
+            _do_validate("datamodel attribute update", payload)
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {"action": "update", "resource": "attribute", "data": payload},
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        result = datamodel_api.update_attribute(client, payload)
+        if fmt == OutputFormat.json:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "success": True,
+                        "action": "update",
+                        "resource": "attribute",
+                        "data": result,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+        else:
+            typer.echo(f"Updated: {result}", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_attribute_sub.command(name="delete")
+def delete_attribute(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Attribute name")],
+    force_delete: Annotated[
+        bool,
+        typer.Option("--hard-delete", help="Force delete even if bound to classes"),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    yes: Annotated[
+        bool,
+        typer.Option("--force", help="Skip confirmation prompt"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete",
+                        "resource": "attribute",
+                        "target": name,
+                        "force": force_delete,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        if is_tty() and not yes:
+            confirm = typer.confirm(f"Delete attribute '{name}'?", default=False)
+            if not confirm:
+                typer.echo("Cancelled.", err=True)
+                raise typer.Exit(code=0)
+
+        client = get_client(ctx)
+        result = datamodel_api.delete_attribute(client, name, force=force_delete)
+        if fmt == OutputFormat.json:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "success": True,
+                        "action": "delete",
+                        "resource": "attribute",
+                        "target": name,
+                        "data": result,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+        else:
+            typer.echo(f"Deleted: {result}", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_attribute_sub.command(name="get")
+def get_attribute(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Attribute name")],
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = datamodel_api.get_attribute(client, name)
+
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+
+        data = result.get("data", result) if isinstance(result, dict) else result
+        console = get_console()
+        if isinstance(data, dict):
+            for key, value in data.items():
+                console.print(f"[bold]{key}[/bold]: {value}")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_attribute_sub.command(name="bind-classes")
+def get_bind_classes(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Attribute name")],
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = datamodel_api.get_attribute_bind_classes(client, name)
+
+        if isinstance(result, dict):
+            payload = result.get("data", result)
+            items = payload if isinstance(payload, list) else [payload]
+        elif isinstance(result, list):
+            items = result
+        else:
+            items = []
+
+        if not items:
+            _empty_ok(ctx, f"No classes bound to attribute '{name}'.")
+            return
+
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+
+        _print_table(items, None, get_console())
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_attribute_sub.command(name="bind")
+def bind_attributes(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    data: Annotated[
+        str, typer.Option("--data", "-d", help="JSON attributes string")
+    ] = "",
+    file: Annotated[
+        Path | None, typer.Option("--file", help="Path to JSON attributes file")
+    ] = None,
+    is_relation: Annotated[
+        bool,
+        typer.Option("--is-relation", help="Target is a relation class"),
+    ] = False,
+    validate: Annotated[
+        bool,
+        typer.Option(
+            "--validate", help="Validate input against schema before executing"
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        payload = _read_payload(data, file)
+        if isinstance(payload, dict):
+            payload = [payload]
+
+        if validate:
+            _do_validate("datamodel attribute bind", payload)
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "bind",
+                        "resource": "attribute",
+                        "class": class_name,
+                        "is_relation": is_relation,
+                        "data": payload,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        client = get_client(ctx)
+        result = datamodel_api.bind_attributes(
+            client, class_name, payload, is_relation=is_relation
+        )
+        if fmt == OutputFormat.json:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "success": True,
+                        "action": "bind",
+                        "resource": "attribute",
+                        "class": class_name,
+                        "data": result,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+        else:
+            typer.echo(f"Bound: {result}", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_attribute_sub.command(name="unbind")
+def unbind_attribute(
+    ctx: typer.Context,
+    class_name: Annotated[str, typer.Option("--class-name", "-c", help="Class name")],
+    attr_name: Annotated[str, typer.Argument(help="Attribute name to unbind")],
+    is_relation: Annotated[
+        bool,
+        typer.Option("--is-relation", help="Target is a relation class"),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+    yes: Annotated[
+        bool,
+        typer.Option("--force", help="Skip confirmation prompt"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "unbind",
+                        "resource": "attribute",
+                        "class": class_name,
+                        "attribute": attr_name,
+                        "is_relation": is_relation,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        if is_tty() and not yes:
+            confirm = typer.confirm(
+                f"Unbind attribute '{attr_name}' from '{class_name}'?",
+                default=False,
+            )
+            if not confirm:
+                typer.echo("Cancelled.", err=True)
+                raise typer.Exit(code=0)
+
+        client = get_client(ctx)
+        result = datamodel_api.unbind_attribute(
+            client, class_name, attr_name, is_relation=is_relation
+        )
+        if fmt == OutputFormat.json:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "success": True,
+                        "action": "unbind",
+                        "resource": "attribute",
+                        "class": class_name,
+                        "attribute": attr_name,
+                        "data": result,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+        else:
+            typer.echo(f"Unbound: {result}", err=True)
+    except DWFError as exc:
+        handle_error(exc)