unitysvc-services 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

unitysvc_services/query.py

@@ -1,174 +1,274 @@
 """Query command group - query backend API for data."""
 
+import asyncio
 import json
-import os
 from typing import Any
 
-import httpx
 import typer
 from rich.console import Console
 from rich.table import Table
 
+from .api import UnitySvcAPI
+
 app = typer.Typer(help="Query backend API for data")
 console = Console()
 
 
-class ServiceDataQuery:
-    """Query service data from UnitySVC backend endpoints."""
+class ServiceDataQuery(UnitySvcAPI):
+    """Query service data from UnitySVC backend endpoints.
 
-    def __init__(self, base_url: str, api_key: str):
-        """Initialize query client with backend URL and API key.
+    Inherits HTTP methods with automatic curl fallback from UnitySvcAPI.
+    Provides convenient methods for listing public service data.
 
-        Args:
-            base_url: UnitySVC backend URL
-            api_key: API key for authentication
+    Provides sync wrapper methods for CLI usage that wrap async base class methods.
+    """
 
-        Raises:
-            ValueError: If base_url or api_key is not provided
-        """
-        if not base_url:
-            raise ValueError(
-                "Backend URL not provided. Use --backend-url or set UNITYSVC_BACKEND_URL env var."
-            )
-        if not api_key:
-            raise ValueError(
-                "API key not provided. Use --api-key or set UNITYSVC_API_KEY env var."
-            )
-
-        self.base_url = base_url.rstrip("/")
-        self.api_key = api_key
-        self.client = httpx.Client(
-            headers={
-                "X-API-Key": api_key,
-                "Content-Type": "application/json",
-            },
-            timeout=30.0,
-        )
+    def list_service_offerings(self, skip: int = 0, limit: int = 100) -> list[dict[str, Any]]:
+        """List all service offerings from the backend (sync wrapper).
 
-    def list_service_offerings(self) -> list[dict[str, Any]]:
-        """List all service offerings from the backend."""
-        response = self.client.get(f"{self.base_url}/publish/service_offerings")
-        response.raise_for_status()
-        result = response.json()
+        Args:
+            skip: Number of records to skip (for pagination)
+            limit: Maximum number of records to return
+        """
+        result: dict[str, Any] = asyncio.run(super().get("/publish/offerings", {"skip": skip, "limit": limit}))
         return result.get("data", result) if isinstance(result, dict) else result
 
-    def list_service_listings(self) -> list[dict[str, Any]]:
-        """List all service listings from the backend."""
-        response = self.client.get(f"{self.base_url}/publish/services")
-        response.raise_for_status()
-        result = response.json()
+    def list_service_listings(self, skip: int = 0, limit: int = 100) -> list[dict[str, Any]]:
+        """List all service listings from the backend (sync wrapper).
+
+        Args:
+            skip: Number of records to skip (for pagination)
+            limit: Maximum number of records to return
+        """
+        result: dict[str, Any] = asyncio.run(super().get("/publish/listings", {"skip": skip, "limit": limit}))
         return result.get("data", result) if isinstance(result, dict) else result
 
-    def list_providers(self) -> list[dict[str, Any]]:
-        """List all providers from the backend."""
-        response = self.client.get(f"{self.base_url}/publish/providers")
-        response.raise_for_status()
-        result = response.json()
+    def list_providers(self, skip: int = 0, limit: int = 100) -> list[dict[str, Any]]:
+        """List all providers from the backend (sync wrapper).
+
+        Args:
+            skip: Number of records to skip (for pagination)
+            limit: Maximum number of records to return
+        """
+        result: dict[str, Any] = asyncio.run(super().get("/publish/providers", {"skip": skip, "limit": limit}))
         return result.get("data", result) if isinstance(result, dict) else result
 
-    def list_sellers(self) -> list[dict[str, Any]]:
-        """List all sellers from the backend."""
-        response = self.client.get(f"{self.base_url}/publish/sellers")
-        response.raise_for_status()
-        result = response.json()
+    def list_sellers(self, skip: int = 0, limit: int = 100) -> list[dict[str, Any]]:
+        """List all sellers from the backend (sync wrapper).
+
+        Args:
+            skip: Number of records to skip (for pagination)
+            limit: Maximum number of records to return
+        """
+        result: dict[str, Any] = asyncio.run(super().get("/publish/sellers", {"skip": skip, "limit": limit}))
         return result.get("data", result) if isinstance(result, dict) else result
 
-    def list_access_interfaces(self) -> dict[str, Any]:
-        """List all access interfaces from the backend (private endpoint)."""
-        response = self.client.get(f"{self.base_url}/private/access_interfaces")
-        response.raise_for_status()
-        return response.json()
+    def get(self, endpoint: str, params: dict[str, Any] | None = None) -> dict[str, Any]:  # type: ignore[override]
+        """Sync wrapper for base class async get() method.
 
-    def list_documents(self) -> dict[str, Any]:
-        """List all documents from the backend (private endpoint)."""
-        response = self.client.get(f"{self.base_url}/private/documents")
-        response.raise_for_status()
-        return response.json()
+        Args:
+            endpoint: API endpoint path
+            params: Query parameters
 
-    def close(self):
-        """Close the HTTP client."""
-        self.client.close()
+        Returns:
+            JSON response as dictionary
+        """
+        return asyncio.run(super().get(endpoint, params))
 
-    def __enter__(self):
-        """Context manager entry."""
-        return self
+    def post(  # type: ignore[override]
+        self, endpoint: str, json_data: dict[str, Any] | None = None, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        """Sync wrapper for base class async post() method.
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit."""
-        self.close()
+        Args:
+            endpoint: API endpoint path
+            json_data: JSON body data
+            params: Query parameters
 
-    @staticmethod
-    def from_env(
-        backend_url: str | None = None, api_key: str | None = None
-    ) -> "ServiceDataQuery":
-        """Create ServiceDataQuery from environment variables or arguments.
+        Returns:
+            JSON response as dictionary
+        """
+        return asyncio.run(super().post(endpoint, json_data, params))
+
+    def check_task(self, task_id: str, poll_interval: float = 2.0, timeout: float = 300.0) -> dict[str, Any]:  # type: ignore[override]
+        """Sync wrapper for base class async check_task() method.
 
         Args:
-            backend_url: Optional backend URL (falls back to UNITYSVC_BACKEND_URL env var)
-            api_key: Optional API key (falls back to UNITYSVC_API_KEY env var)
+            task_id: Celery task ID to poll
+            poll_interval: Seconds between status checks
+            timeout: Maximum seconds to wait
 
         Returns:
-            ServiceDataQuery instance
+            Task result dictionary
 
         Raises:
-            ValueError: If required credentials are not provided
+            ValueError: If task fails or times out
         """
-        resolved_backend_url = backend_url or os.getenv("UNITYSVC_BACKEND_URL") or ""
-        resolved_api_key = api_key or os.getenv("UNITYSVC_API_KEY") or ""
-        return ServiceDataQuery(base_url=resolved_backend_url, api_key=resolved_api_key)
+        return asyncio.run(super().check_task(task_id, poll_interval, timeout))
+
+    def __enter__(self):
+        """Sync context manager entry for CLI usage."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Sync context manager exit for CLI usage."""
+        asyncio.run(self.aclose())
 
 
 @app.command("sellers")
 def query_sellers(
-    backend_url: str | None = typer.Option(
-        None,
-        "--backend-url",
-        "-u",
-        help="UnitySVC backend URL (default: from UNITYSVC_BACKEND_URL env var)",
-    ),
-    api_key: str | None = typer.Option(
-        None,
-        "--api-key",
-        "-k",
-        help="API key for authentication (default: from UNITYSVC_API_KEY env var)",
-    ),
     format: str = typer.Option(
         "table",
         "--format",
         "-f",
         help="Output format: table, json",
     ),
+    fields: str = typer.Option(
+        "id,name,display_name,seller_type",
+        "--fields",
+        help=(
+            "Comma-separated list of fields to display. Available fields: "
+            "id, name, display_name, seller_type, contact_email, "
+            "secondary_contact_email, homepage, description, "
+            "business_registration, tax_id, account_manager_id, "
+            "created_at, updated_at, status"
+        ),
+    ),
+    skip: int = typer.Option(
+        0,
+        "--skip",
+        help="Number of records to skip (for pagination)",
+    ),
+    limit: int = typer.Option(
+        100,
+        "--limit",
+        help="Maximum number of records to return (default: 100)",
+    ),
 ):
-    """Query all sellers from the backend."""
+    """Query all sellers from the backend.
+
+    Examples:
+        # Use default fields
+        unitysvc_services query sellers
+
+        # Show only specific fields
+        unitysvc_services query sellers --fields id,name,contact_email
+
+        # Retrieve more than 100 records
+        unitysvc_services query sellers --limit 500
+
+        # Pagination: skip first 100, get next 100
+        unitysvc_services query sellers --skip 100 --limit 100
+
+        # Show all available fields
+        unitysvc_services query sellers --fields \\
+            id,name,display_name,seller_type,contact_email,homepage,created_at,updated_at
+    """
+    # Parse fields list
+    field_list = [f.strip() for f in fields.split(",")]
+
+    # Define allowed fields from SellerPublic model
+    allowed_fields = {
+        "id",
+        "name",
+        "display_name",
+        "seller_type",
+        "contact_email",
+        "secondary_contact_email",
+        "homepage",
+        "description",
+        "business_registration",
+        "tax_id",
+        "account_manager_id",
+        "created_at",
+        "updated_at",
+        "status",
+    }
+
+    # Validate fields
+    invalid_fields = [f for f in field_list if f not in allowed_fields]
+    if invalid_fields:
+        console.print(
+            f"[red]✗[/red] Invalid field(s): {', '.join(invalid_fields)}",
+            style="bold red",
+        )
+        console.print(f"[yellow]Allowed fields:[/yellow] {', '.join(sorted(allowed_fields))}")
+        raise typer.Exit(code=1)
+
     try:
-        with ServiceDataQuery.from_env(backend_url, api_key) as query:
-            sellers = query.list_sellers()
+        with ServiceDataQuery() as query:
+            sellers = query.list_sellers(skip=skip, limit=limit)
 
             if format == "json":
-                console.print(json.dumps(sellers, indent=2))
+                # For JSON, filter fields if not all are requested
+                if set(field_list) != allowed_fields:
+                    filtered_sellers = [{k: v for k, v in seller.items() if k in field_list} for seller in sellers]
+                    console.print(json.dumps(filtered_sellers, indent=2))
+                else:
+                    console.print(json.dumps(sellers, indent=2))
             else:
                 if not sellers:
                     console.print("[yellow]No sellers found.[/yellow]")
                 else:
                     table = Table(title="Sellers")
-                    table.add_column("ID", style="cyan")
-                    table.add_column("Name", style="green")
-                    table.add_column("Display Name", style="blue")
-                    table.add_column("Type", style="magenta")
-                    table.add_column("Contact Email", style="yellow")
-                    table.add_column("Active", style="white")
 
+                    # Define column styles
+                    field_styles = {
+                        "id": "cyan",
+                        "name": "green",
+                        "display_name": "blue",
+                        "seller_type": "magenta",
+                        "contact_email": "yellow",
+                        "secondary_contact_email": "yellow",
+                        "homepage": "blue",
+                        "description": "white",
+                        "business_registration": "white",
+                        "tax_id": "white",
+                        "account_manager_id": "cyan",
+                        "created_at": "white",
+                        "updated_at": "white",
+                        "status": "green",
+                    }
+
+                    # Define column headers
+                    field_headers = {
+                        "id": "ID",
+                        "name": "Name",
+                        "display_name": "Display Name",
+                        "seller_type": "Type",
+                        "contact_email": "Contact Email",
+                        "secondary_contact_email": "Secondary Email",
+                        "homepage": "Homepage",
+                        "description": "Description",
+                        "business_registration": "Business Reg",
+                        "tax_id": "Tax ID",
+                        "account_manager_id": "Account Manager ID",
+                        "created_at": "Created At",
+                        "updated_at": "Updated At",
+                        "status": "Status",
+                    }
+
+                    # Add columns based on requested fields
+                    for field in field_list:
+                        header = field_headers.get(field, field.title())
+                        style = field_styles.get(field, "white")
+                        table.add_column(header, style=style)
+
+                    # Add rows
                     for seller in sellers:
-                        table.add_row(
-                            str(seller.get("id", "N/A")),
-                            seller.get("name", "N/A"),
-                            seller.get("display_name", "N/A"),
-                            seller.get("seller_type", "N/A"),
-                            seller.get("contact_email", "N/A"),
-                            "✓" if seller.get("is_active") else "✗",
-                        )
+                        row = []
+                        for field in field_list:
+                            value = seller.get(field)
+                            if value is None:
+                                row.append("N/A")
+                            elif isinstance(value, dict | list):
+                                row.append(str(value)[:50])  # Truncate complex types
+                            else:
+                                row.append(str(value))
+                        table.add_row(*row)
 
                     console.print(table)
+                    console.print(f"\n[green]Total:[/green] {len(sellers)} seller(s)")
     except ValueError as e:
         console.print(f"[red]✗[/red] {e}", style="bold red")
         raise typer.Exit(code=1)
@@ -179,51 +279,146 @@ def query_sellers(
 
 @app.command("providers")
 def query_providers(
-    backend_url: str | None = typer.Option(
-        None,
-        "--backend-url",
-        "-u",
-        help="UnitySVC backend URL (default: from UNITYSVC_BACKEND_URL env var)",
-    ),
-    api_key: str | None = typer.Option(
-        None,
-        "--api-key",
-        "-k",
-        help="API key for authentication (default: from UNITYSVC_API_KEY env var)",
-    ),
     format: str = typer.Option(
         "table",
         "--format",
         "-f",
         help="Output format: table, json",
     ),
+    fields: str = typer.Option(
+        "id,name,display_name,status",
+        "--fields",
+        help=(
+            "Comma-separated list of fields to display. Available fields: "
+            "id, name, display_name, contact_email, secondary_contact_email, "
+            "homepage, description, status, created_at, updated_at"
+        ),
+    ),
+    skip: int = typer.Option(
+        0,
+        "--skip",
+        help="Number of records to skip (for pagination)",
+    ),
+    limit: int = typer.Option(
+        100,
+        "--limit",
+        help="Maximum number of records to return (default: 100)",
+    ),
 ):
-    """Query all providers from the backend."""
+    """Query all providers from the backend.
+
+    Examples:
+        # Use default fields
+        unitysvc_services query providers
+
+        # Retrieve more than 100 records
+        unitysvc_services query providers --limit 500
+
+        # Pagination: skip first 100, get next 100
+        unitysvc_services query providers --skip 100 --limit 100
+
+        # Show only specific fields
+        unitysvc_services query providers --fields id,name,contact_email
+
+        # Show all available fields
+        unitysvc_services query providers --fields \\
+            id,name,display_name,contact_email,homepage,status,created_at,updated_at
+    """
+    # Parse fields list
+    field_list = [f.strip() for f in fields.split(",")]
+
+    # Define allowed fields from ProviderPublic model
+    allowed_fields = {
+        "id",
+        "name",
+        "display_name",
+        "contact_email",
+        "secondary_contact_email",
+        "homepage",
+        "description",
+        "status",
+        "created_at",
+        "updated_at",
+    }
+
+    # Validate fields
+    invalid_fields = [f for f in field_list if f not in allowed_fields]
+    if invalid_fields:
+        console.print(
+            f"[red]✗[/red] Invalid field(s): {', '.join(invalid_fields)}",
+            style="bold red",
+        )
+        console.print(f"[yellow]Allowed fields:[/yellow] {', '.join(sorted(allowed_fields))}")
+        raise typer.Exit(code=1)
+
     try:
-        with ServiceDataQuery.from_env(backend_url, api_key) as query:
-            providers = query.list_providers()
+        with ServiceDataQuery() as query:
+            providers = query.list_providers(skip=skip, limit=limit)
 
             if format == "json":
-                console.print(json.dumps(providers, indent=2))
+                # For JSON, filter fields if not all are requested
+                if set(field_list) != allowed_fields:
+                    filtered_providers = [
+                        {k: v for k, v in provider.items() if k in field_list} for provider in providers
+                    ]
+                    console.print(json.dumps(filtered_providers, indent=2))
+                else:
+                    console.print(json.dumps(providers, indent=2))
             else:
                 if not providers:
                     console.print("[yellow]No providers found.[/yellow]")
                 else:
                     table = Table(title="Providers")
-                    table.add_column("ID", style="cyan")
-                    table.add_column("Name", style="green")
-                    table.add_column("Display Name", style="blue")
-                    table.add_column("Time Created", style="magenta")
 
+                    # Define column styles
+                    field_styles = {
+                        "id": "cyan",
+                        "name": "green",
+                        "display_name": "blue",
+                        "contact_email": "yellow",
+                        "secondary_contact_email": "yellow",
+                        "homepage": "blue",
+                        "description": "white",
+                        "status": "green",
+                        "created_at": "magenta",
+                        "updated_at": "magenta",
+                    }
+
+                    # Define column headers
+                    field_headers = {
+                        "id": "ID",
+                        "name": "Name",
+                        "display_name": "Display Name",
+                        "contact_email": "Contact Email",
+                        "secondary_contact_email": "Secondary Email",
+                        "homepage": "Homepage",
+                        "description": "Description",
+                        "status": "Status",
+                        "created_at": "Created At",
+                        "updated_at": "Updated At",
+                    }
+
+                    # Add columns based on requested fields
+                    for field in field_list:
+                        header = field_headers.get(field, field.title())
+                        style = field_styles.get(field, "white")
+                        table.add_column(header, style=style)
+
+                    # Add rows
                     for provider in providers:
-                        table.add_row(
-                            str(provider.get("id", "N/A")),
-                            provider.get("name", "N/A"),
-                            provider.get("display_name", "N/A"),
-                            str(provider.get("time_created", "N/A")),
-                        )
+                        row = []
+                        for field in field_list:
+                            value = provider.get(field)
+                            if value is None:
+                                row.append("N/A")
+                            elif isinstance(value, dict | list):
+                                row.append(str(value)[:50])  # Truncate complex types
+                            else:
+                                row.append(str(value))
+                        table.add_row(*row)
 
                     console.print(table)
+                    console.print(f"\n[green]Total:[/green] {len(providers)} provider(s)")
     except ValueError as e:
         console.print(f"[red]✗[/red] {e}", style="bold red")
         raise typer.Exit(code=1)
@@ -234,256 +429,246 @@ def query_providers(
 
 @app.command("offerings")
 def query_offerings(
-    backend_url: str | None = typer.Option(
-        None,
-        "--backend-url",
-        "-u",
-        help="UnitySVC backend URL (default: from UNITYSVC_BACKEND_URL env var)",
-    ),
-    api_key: str | None = typer.Option(
-        None,
-        "--api-key",
-        "-k",
-        help="API key for authentication (default: from UNITYSVC_API_KEY env var)",
-    ),
     format: str = typer.Option(
         "table",
         "--format",
         "-f",
         help="Output format: table, json",
     ),
+    fields: str = typer.Option(
+        "id,name,service_type,provider_name,status",
+        "--fields",
+        help=(
+            "Comma-separated list of fields to display. Available fields: "
+            "id, definition_id, provider_id, status, price, service_name, "
+            "service_type, provider_name"
+        ),
+    ),
+    skip: int = typer.Option(
+        0,
+        "--skip",
+        help="Number of records to skip (for pagination)",
+    ),
+    limit: int = typer.Option(
+        100,
+        "--limit",
+        help="Maximum number of records to return (default: 100)",
+    ),
 ):
-    """Query all service offerings from UnitySVC backend."""
+    """Query all service offerings from UnitySVC backend.
+
+    Examples:
+        # Use default fields
+        unitysvc_services query offerings
+
+        # Show only specific fields
+        unitysvc_services query offerings --fields id,name,status
+
+        # Retrieve more than 100 records
+        unitysvc_services query offerings --limit 500
+
+        # Pagination: skip first 100, get next 100
+        unitysvc_services query offerings --skip 100 --limit 100
+
+        # Show all available fields
+        unitysvc_services query offerings --fields \\
+            id,service_name,service_type,provider_name,status,price,definition_id,provider_id
+    """
+    # Parse fields list
+    field_list = [f.strip() for f in fields.split(",")]
+
+    # Define allowed fields from ServiceOfferingPublic model
+    allowed_fields = {
+        "id",
+        "definition_id",
+        "provider_id",
+        "status",
+        "price",
+        "name",
+        "service_type",
+        "provider_name",
+    }
+
+    # Validate fields
+    invalid_fields = [f for f in field_list if f not in allowed_fields]
+    if invalid_fields:
+        console.print(
+            f"[red]Error:[/red] Invalid field(s): {', '.join(invalid_fields)}",
+            style="bold red",
+        )
+        console.print(f"[yellow]Available fields:[/yellow] {', '.join(sorted(allowed_fields))}")
+        raise typer.Exit(code=1)
+
     try:
-        with ServiceDataQuery.from_env(backend_url, api_key) as query:
-            offerings = query.list_service_offerings()
+        with ServiceDataQuery() as query:
+            offerings = query.list_service_offerings(skip=skip, limit=limit)
 
             if format == "json":
-                console.print(json.dumps(offerings, indent=2))
+                # For JSON, filter fields if not all are requested
+                if set(field_list) != allowed_fields:
+                    filtered_offerings = [
+                        {k: v for k, v in offering.items() if k in field_list} for offering in offerings
+                    ]
+                    console.print(json.dumps(filtered_offerings, indent=2))
+                else:
+                    console.print(json.dumps(offerings, indent=2))
             else:
                 if not offerings:
                     console.print("[yellow]No service offerings found.[/yellow]")
                 else:
-                    table = Table(title="Service Offerings", show_lines=True)
-                    table.add_column("ID", style="cyan")
-                    table.add_column("Name", style="green")
-                    table.add_column("Display Name", style="blue")
-                    table.add_column("Type", style="magenta")
-                    table.add_column("Status", style="yellow")
-                    table.add_column("Version")
+                    table = Table(title="Service Offerings")
+
+                    # Add columns dynamically based on selected fields
+                    for field in field_list:
+                        # Capitalize and format field names for display
+                        column_name = field.replace("_", " ").title()
+                        table.add_column(column_name)
 
+                    # Add rows
                     for offering in offerings:
-                        table.add_row(
-                            str(offering.get("id", "N/A")),
-                            offering.get("name", "N/A"),
-                            offering.get("display_name", "N/A"),
-                            offering.get("service_type", "N/A"),
-                            offering.get("upstream_status", "N/A"),
-                            offering.get("version", "N/A"),
-                        )
+                        row = []
+                        for field in field_list:
+                            value = offering.get(field)
+                            if value is None:
+                                row.append("N/A")
+                            elif isinstance(value, dict | list):
+                                row.append(str(value)[:50])  # Truncate complex types
+                            else:
+                                row.append(str(value))
+                        table.add_row(*row)
 
                     console.print(table)
-                    console.print(
-                        f"\n[green]Total:[/green] {len(offerings)} service offering(s)"
-                    )
+                    console.print(f"\n[green]Total:[/green] {len(offerings)} service offering(s)")
     except ValueError as e:
         console.print(f"[red]✗[/red] {e}", style="bold red")
         raise typer.Exit(code=1)
     except Exception as e:
-        console.print(
-            f"[red]✗[/red] Failed to query service offerings: {e}", style="bold red"
-        )
+        console.print(f"[red]✗[/red] Failed to query service offerings: {e}", style="bold red")
         raise typer.Exit(code=1)
 
 
 @app.command("listings")
 def query_listings(
-    backend_url: str | None = typer.Option(
-        None,
-        "--backend-url",
-        "-u",
-        help="UnitySVC backend URL (default: from UNITYSVC_BACKEND_URL env var)",
-    ),
-    api_key: str | None = typer.Option(
-        None,
-        "--api-key",
-        "-k",
-        help="API key for authentication (default: from UNITYSVC_API_KEY env var)",
-    ),
     format: str = typer.Option(
         "table",
         "--format",
         "-f",
         help="Output format: table, json",
     ),
-):
-    """Query all service listings from UnitySVC backend."""
-    try:
-        with ServiceDataQuery.from_env(backend_url, api_key) as query:
-            listings = query.list_service_listings()
-
-            if format == "json":
-                console.print(json.dumps(listings, indent=2))
-            else:
-                if not listings:
-                    console.print("[yellow]No service listings found.[/yellow]")
-                else:
-                    table = Table(title="Service Listings", show_lines=True)
-                    table.add_column("ID", style="cyan")
-                    table.add_column("Service ID", style="blue")
-                    table.add_column("Seller", style="green")
-                    table.add_column("Status", style="yellow")
-                    table.add_column("Interfaces")
-
-                    for listing in listings:
-                        interfaces_count = len(
-                            listing.get("user_access_interfaces", [])
-                        )
-                        table.add_row(
-                            str(listing.get("id", "N/A")),
-                            str(listing.get("service_id", "N/A")),
-                            listing.get("seller_name", "N/A"),
-                            listing.get("listing_status", "N/A"),
-                            str(interfaces_count),
-                        )
-
-                    console.print(table)
-                    console.print(
-                        f"\n[green]Total:[/green] {len(listings)} service listing(s)"
-                    )
-    except ValueError as e:
-        console.print(f"[red]✗[/red] {e}", style="bold red")
-        raise typer.Exit(code=1)
-    except Exception as e:
-        console.print(
-            f"[red]✗[/red] Failed to query service listings: {e}", style="bold red"
-        )
-        raise typer.Exit(code=1)
-
-
-@app.command("interfaces")
-def query_interfaces(
-    backend_url: str | None = typer.Option(
-        None,
-        "--backend-url",
-        "-u",
-        help="UnitySVC backend URL (default: from UNITYSVC_BACKEND_URL env var)",
+    fields: str = typer.Option(
+        "id,service_name,service_type,seller_name,listing_type,status",
+        "--fields",
+        help=(
+            "Comma-separated list of fields to display. Available fields: "
+            "id, offering_id, offering_status, seller_id, status, created_at, updated_at, "
+            "parameters_schema, parameters_ui_schema, tags, service_name, "
+            "service_type, provider_name, seller_name, listing_type"
+        ),
     ),
-    api_key: str | None = typer.Option(
-        None,
-        "--api-key",
-        "-k",
-        help="API key for authentication (default: from UNITYSVC_API_KEY env var)",
+    skip: int = typer.Option(
+        0,
+        "--skip",
+        help="Number of records to skip (for pagination)",
     ),
-    format: str = typer.Option(
-        "table",
-        "--format",
-        "-f",
-        help="Output format: table, json",
+    limit: int = typer.Option(
+        100,
+        "--limit",
+        help="Maximum number of records to return (default: 100)",
     ),
 ):
-    """Query all access interfaces from UnitySVC backend (private endpoint)."""
-    try:
-        with ServiceDataQuery.from_env(backend_url, api_key) as query:
-            data = query.list_access_interfaces()
-
-            if format == "json":
-                console.print(json.dumps(data, indent=2))
-            else:
-                interfaces = data.get("data", [])
-                if not interfaces:
-                    console.print("[yellow]No access interfaces found.[/yellow]")
-                else:
-                    table = Table(title="Access Interfaces", show_lines=True)
-                    table.add_column("ID", style="cyan")
-                    table.add_column("Name", style="green")
-                    table.add_column("Context", style="blue")
-                    table.add_column("Entity ID", style="yellow")
-                    table.add_column("Method", style="magenta")
-                    table.add_column("Active", style="green")
-
-                    for interface in interfaces:
-                        table.add_row(
-                            str(interface.get("id", "N/A"))[:8] + "...",
-                            interface.get("name", "N/A"),
-                            interface.get("context_type", "N/A"),
-                            str(interface.get("entity_id", "N/A"))[:8] + "...",
-                            interface.get("access_method", "N/A"),
-                            "✓" if interface.get("is_active") else "✗",
-                        )
-
-                    console.print(table)
-                    console.print(
-                        f"\n[green]Total:[/green] {data.get('count', 0)} access interface(s)"
-                    )
-    except ValueError as e:
-        console.print(f"[red]✗[/red] {e}", style="bold red")
-        raise typer.Exit(code=1)
-    except Exception as e:
+    """Query all service listings from UnitySVC backend.
+
+    Examples:
+        # Use default fields
+        unitysvc_services query listings
+
+        # Show only specific fields
+        unitysvc_services query listings --fields id,service_name,status
+
+        # Retrieve more than 100 records
+        unitysvc_services query listings --limit 500
+
+        # Pagination: skip first 100, get next 100
+        unitysvc_services query listings --skip 100 --limit 100
+
+        # Show all available fields
+        unitysvc_services query listings --fields \\
+            id,name,service_name,service_type,seller_name,listing_type,status,provider_name
+    """
+    # Parse fields list
+    field_list = [f.strip() for f in fields.split(",")]
+
+    # Define allowed fields from ServiceListingPublic model
+    allowed_fields = {
+        "id",
+        "name",
+        "offering_id",
+        "offering_status",
+        "seller_id",
+        "status",
+        "created_at",
+        "updated_at",
+        "parameters_schema",
+        "parameters_ui_schema",
+        "tags",
+        "service_name",
+        "service_type",
+        "provider_name",
+        "seller_name",
+        "listing_type",
+    }
+
+    # Validate fields
+    invalid_fields = [f for f in field_list if f not in allowed_fields]
+    if invalid_fields:
         console.print(
-            f"[red]✗[/red] Failed to query access interfaces: {e}", style="bold red"
+            f"[red]Error:[/red] Invalid field(s): {', '.join(invalid_fields)}",
+            style="bold red",
         )
+        console.print(f"[yellow]Available fields:[/yellow] {', '.join(sorted(allowed_fields))}")
         raise typer.Exit(code=1)
 
-
-@app.command("documents")
-def query_documents(
-    backend_url: str | None = typer.Option(
-        None,
-        "--backend-url",
-        "-u",
-        help="UnitySVC backend URL (default: from UNITYSVC_BACKEND_URL env var)",
-    ),
-    api_key: str | None = typer.Option(
-        None,
-        "--api-key",
-        "-k",
-        help="API key for authentication (default: from UNITYSVC_API_KEY env var)",
-    ),
-    format: str = typer.Option(
-        "table",
-        "--format",
-        "-f",
-        help="Output format: table, json",
-    ),
-):
-    """Query all documents from UnitySVC backend (private endpoint)."""
     try:
-        with ServiceDataQuery.from_env(backend_url, api_key) as query:
-            data = query.list_documents()
+        with ServiceDataQuery() as query:
+            listings = query.list_service_listings(skip=skip, limit=limit)
 
             if format == "json":
-                console.print(json.dumps(data, indent=2))
+                # For JSON, filter fields if not all are requested
+                if set(field_list) != allowed_fields:
+                    filtered_listings = [{k: v for k, v in listing.items() if k in field_list} for listing in listings]
+                    console.print(json.dumps(filtered_listings, indent=2))
+                else:
+                    console.print(json.dumps(listings, indent=2))
             else:
-                documents = data.get("data", [])
-                if not documents:
-                    console.print("[yellow]No documents found.[/yellow]")
+                if not listings:
+                    console.print("[yellow]No service listings found.[/yellow]")
                 else:
-                    table = Table(title="Documents", show_lines=True)
-                    table.add_column("ID", style="cyan")
-                    table.add_column("Title", style="green")
-                    table.add_column("Category", style="blue")
-                    table.add_column("MIME Type", style="yellow")
-                    table.add_column("Context", style="magenta")
-                    table.add_column("Public", style="red")
-
-                    for doc in documents:
-                        table.add_row(
-                            str(doc.get("id", "N/A"))[:8] + "...",
-                            doc.get("title", "N/A")[:40],
-                            doc.get("category", "N/A"),
-                            doc.get("mime_type", "N/A"),
-                            doc.get("context_type", "N/A"),
-                            "✓" if doc.get("is_public") else "✗",
-                        )
+                    table = Table(title="Service Listings")
+
+                    # Add columns dynamically based on selected fields
+                    for field in field_list:
+                        # Capitalize and format field names for display
+                        column_name = field.replace("_", " ").title()
+                        table.add_column(column_name)
+
+                    # Add rows
+                    for listing in listings:
+                        row = []
+                        for field in field_list:
+                            value = listing.get(field)
+                            if value is None:
+                                row.append("N/A")
+                            elif isinstance(value, dict | list):
+                                row.append(str(value)[:50])  # Truncate complex types
+                            else:
+                                row.append(str(value))
+                        table.add_row(*row)
 
                     console.print(table)
-                    console.print(
-                        f"\n[green]Total:[/green] {data.get('count', 0)} document(s)"
-                    )
+                    console.print(f"\n[green]Total:[/green] {len(listings)} service listing(s)")
     except ValueError as e:
         console.print(f"[red]✗[/red] {e}", style="bold red")
         raise typer.Exit(code=1)
     except Exception as e:
-        console.print(f"[red]✗[/red] Failed to query documents: {e}", style="bold red")
+        console.print(f"[red]✗[/red] Failed to query service listings: {e}", style="bold red")
         raise typer.Exit(code=1)