cacholong-cloud-cli 1.13.2__tar.gz → 1.14.1__tar.gz

{cacholong_cloud_cli-1.13.2 → cacholong_cloud_cli-1.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cacholong-cloud-cli
-Version: 1.13.2
+Version: 1.14.1
 Summary: Cacholong CLI, manage cloud environments at Cacholong!
 License: MIT
 Author: Matthijs Möhlmann

{cacholong_cloud_cli-1.13.2 → cacholong_cloud_cli-1.14.1}/cacholong_cli/cli.py

@@ -18,6 +18,7 @@ from cacholong_cli.commands import (
     mail_forwards,
     products,
     purchases,
+    service_bundles,
     users,
 )
 from cacholong_cli.common import OutputFormat
@@ -64,6 +65,11 @@ app.add_typer(mail_domains.app, name="mail-domains", help="Manage mail domains")
 app.add_typer(mail_forwards.app, name="mail-forwards", help="Manage mail forwards")
 app.add_typer(products.app, name="products", help="Manage products")
 app.add_typer(purchases.app, name="purchases", help="Manage purchases")
+app.add_typer(
+    service_bundles.app,
+    name="service-bundles",
+    help='A service bundle is a named set of services that together deliver a product. It works as the "recipe": it states which PHP versions, which nginx, which MySQL and so on are used, and therefore on which servers or at which provider a product ends up.',
+)
 app.add_typer(users.app, name="users", help="Manage users")
 
 

{cacholong_cloud_cli-1.13.2 → cacholong_cloud_cli-1.14.1}/cacholong_cli/commands/dns_zones.py

@@ -346,9 +346,6 @@ async def create(
 async def update(
     ctx: typer.Context,
     dns_zone_id: Annotated[UUID, typer.Argument(help="Resource ID to update")],
-    domain: Annotated[
-        Optional[str], typer.Option(help="The domain name for this DNS zone")
-    ] = None,
     active: Annotated[
         Optional[bool],
         typer.Option(help="Enable or disable active DNS resolution for this zone"),
@@ -358,8 +355,6 @@ async def update(
         ctrl = DnsZone(conn, api_schema)
         model = await ctrl.fetch(dns_zone_id)
 
-        if domain is not None:
-            model["domain"] = domain
         if active is not None:
             model["active"] = active
 

cacholong_cloud_cli-1.14.1/cacholong_cli/commands/service_bundles.py

@@ -0,0 +1,905 @@
+import asyncio
+import typer
+from typing import List, Optional, Dict, Any, Union, Type
+from typing_extensions import Annotated
+from rich.table import Column
+from uuid import UUID
+from datetime import datetime, date, timezone
+from cacholong_cli.AsyncTyper import AsyncTyper
+from cacholong_cli.common import (
+    list_resources,
+    list_relation_resources,
+    show_resource,
+    TableDef,
+)
+from cacholong_cli.connection import Connection
+from cacholong_sdk import Filter, Inclusion, ResourceTuple
+from cacholong_sdk import ServiceBundle, ServiceBundleModel
+from cacholong_sdk.api_schema import api_schema
+
+# Create typer object
+app = AsyncTyper()
+
+
+@app.async_command(help="Get service bundles representing collections of services")
+async def list(
+    ctx: typer.Context,
+    name: Annotated[
+        Optional[str],
+        typer.Option(help="Service bundle name (must be unique within account)"),
+    ] = None,
+    description: Annotated[
+        Optional[str], typer.Option(help="Optional description for this service bundle")
+    ] = None,
+    account: Annotated[
+        Optional[UUID], typer.Option(help="Account owner (null for a global bundle)")
+    ] = None,
+    created_at: Annotated[
+        Optional[datetime],
+        typer.Option(help="Creation timestamp in ISO 8601 format (exact match)"),
+    ] = None,
+    created_at_gte: Annotated[
+        Optional[datetime],
+        typer.Option(
+            help="Creation timestamp in ISO 8601 format (greater than or equal)"
+        ),
+    ] = None,
+    created_at_lte: Annotated[
+        Optional[datetime],
+        typer.Option(help="Creation timestamp in ISO 8601 format (less than or equal)"),
+    ] = None,
+    created_at_gt: Annotated[
+        Optional[datetime],
+        typer.Option(help="Creation timestamp in ISO 8601 format (greater than)"),
+    ] = None,
+    created_at_lt: Annotated[
+        Optional[datetime],
+        typer.Option(help="Creation timestamp in ISO 8601 format (less than)"),
+    ] = None,
+    updated_at: Annotated[
+        Optional[datetime],
+        typer.Option(help="Last update timestamp in ISO 8601 format (exact match)"),
+    ] = None,
+    updated_at_gte: Annotated[
+        Optional[datetime],
+        typer.Option(
+            help="Last update timestamp in ISO 8601 format (greater than or equal)"
+        ),
+    ] = None,
+    updated_at_lte: Annotated[
+        Optional[datetime],
+        typer.Option(
+            help="Last update timestamp in ISO 8601 format (less than or equal)"
+        ),
+    ] = None,
+    updated_at_gt: Annotated[
+        Optional[datetime],
+        typer.Option(help="Last update timestamp in ISO 8601 format (greater than)"),
+    ] = None,
+    updated_at_lt: Annotated[
+        Optional[datetime],
+        typer.Option(help="Last update timestamp in ISO 8601 format (less than)"),
+    ] = None,
+):
+
+    # Build modifier
+    modifier = []
+
+    if name is not None:
+        modifier.append(Filter(name=name))
+
+    if description is not None:
+        modifier.append(Filter(description=description))
+
+    if account is not None:
+        modifier.append(Filter(account=str(account)))
+
+    if created_at is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[created_at]="
+                + created_at.astimezone(timezone.utc)
+                .replace(tzinfo=None)
+                .isoformat(timespec="milliseconds")
+                + "Z"
+            )
+        )
+    if created_at_gte is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[created_at_gte]="
+                + created_at_gte.astimezone(timezone.utc)
+                .replace(tzinfo=None)
+                .isoformat(timespec="milliseconds")
+                + "Z"
+            )
+        )
+    if created_at_lte is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[created_at_lte]="
+                + created_at_lte.astimezone(timezone.utc)
+                .replace(tzinfo=None)
+                .isoformat(timespec="milliseconds")
+                + "Z"
+            )
+        )
+    if created_at_gt is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[created_at_gt]="
+                + created_at_gt.astimezone(timezone.utc)
+                .replace(tzinfo=None)
+                .isoformat(timespec="milliseconds")
+                + "Z"
+            )
+        )
+    if created_at_lt is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[created_at_lt]="
+                + created_at_lt.astimezone(timezone.utc)
+                .replace(tzinfo=None)
+                .isoformat(timespec="milliseconds")
+                + "Z"
+            )
+        )
+
+    if updated_at is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[updated_at]="
+                + updated_at.astimezone(timezone.utc)
+                .replace(tzinfo=None)
+                .isoformat(timespec="milliseconds")
+                + "Z"
+            )
+        )
+    if updated_at_gte is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[updated_at_gte]="
+                + updated_at_gte.astimezone(timezone.utc)
+                .replace(tzinfo=None)
+                .isoformat(timespec="milliseconds")
+                + "Z"
+            )
+        )
+    if updated_at_lte is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[updated_at_lte]="
+                + updated_at_lte.astimezone(timezone.utc)
+                .replace(tzinfo=None)
+                .isoformat(timespec="milliseconds")
+                + "Z"
+            )
+        )
+    if updated_at_gt is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[updated_at_gt]="
+                + updated_at_gt.astimezone(timezone.utc)
+                .replace(tzinfo=None)
+                .isoformat(timespec="milliseconds")
+                + "Z"
+            )
+        )
+    if updated_at_lt is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[updated_at_lt]="
+                + updated_at_lt.astimezone(timezone.utc)
+                .replace(tzinfo=None)
+                .isoformat(timespec="milliseconds")
+                + "Z"
+            )
+        )
+
+    modifier.append(Inclusion("account"))
+
+    # Table definition
+    tabledef: TableDef = [
+        {"header": Column("Id", no_wrap=True), "column": "id"},
+        {
+            "header": "Account",
+            "column": "account",
+            "column_kebab": "account",
+            "nested_column": "name",
+        },
+        {"header": "Name", "column": "name"},
+        {"header": "Created", "column": "created_at"},
+        {"header": "Updated", "column": "updated_at"},
+    ]
+
+    async with Connection() as conn:
+        await list_resources(ctx, ServiceBundle(conn, api_schema), tabledef, modifier)
+
+
+@app.async_command(help="Get service bundle details by ID")
+async def show(
+    ctx: typer.Context,
+    service_bundle_id: Annotated[UUID, typer.Argument(help="Resource ID to show")],
+):
+    # Show resource
+    async with Connection() as conn:
+        ctrl = ServiceBundle(conn, api_schema)
+        model = await ctrl.fetch(service_bundle_id)
+
+        show_resource(ctx, model)
+
+
+@app.async_command(
+    name="show-account", help="Get the account associated with a service bundle"
+)
+async def show_account(
+    ctx: typer.Context,
+    service_bundle_id: Annotated[UUID, typer.Argument(help="Parent resource ID")],
+):
+    """Get the account associated with a service bundle"""
+    async with Connection() as conn:
+        # Fetch parent resource
+        parent_ctrl = ServiceBundle(conn, api_schema)
+        parent_model = await parent_ctrl.fetch(service_bundle_id)
+
+        # Fetch and show related resource
+        await parent_model["account"].fetch()
+        related = parent_model["account"].resource
+
+        show_resource(ctx, related)
+
+
+@app.async_command(name="list-services", help="List services for a service bundle")
+async def list_services(
+    ctx: typer.Context,
+    service_bundle_id: Annotated[UUID, typer.Argument(help="Parent resource ID")],
+    category: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Service category (apache, dns, domain, firewall, mysql, nginx, osuser, php, postgresql, shell, ssl)"
+        ),
+    ] = None,
+    name: Annotated[
+        Optional[str], typer.Option(help="Service name (descriptive identifier)")
+    ] = None,
+    description: Annotated[
+        Optional[str], typer.Option(help="Detailed description of the service")
+    ] = None,
+    version: Annotated[
+        Optional[str], typer.Option(help="Service version number")
+    ] = None,
+    deprecated_at: Annotated[
+        Optional[datetime],
+        typer.Option(
+            help="Planned deprecation date in ISO 8601 format (null if not scheduled) (exact match)"
+        ),
+    ] = None,
+    deprecated_at_gte: Annotated[
+        Optional[datetime],
+        typer.Option(
+            help="Planned deprecation date in ISO 8601 format (null if not scheduled) (greater than or equal)"
+        ),
+    ] = None,
+    deprecated_at_lte: Annotated[
+        Optional[datetime],
+        typer.Option(
+            help="Planned deprecation date in ISO 8601 format (null if not scheduled) (less than or equal)"
+        ),
+    ] = None,
+    deprecated_at_gt: Annotated[
+        Optional[datetime],
+        typer.Option(
+            help="Planned deprecation date in ISO 8601 format (null if not scheduled) (greater than)"
+        ),
+    ] = None,
+    deprecated_at_lt: Annotated[
+        Optional[datetime],
+        typer.Option(
+            help="Planned deprecation date in ISO 8601 format (null if not scheduled) (less than)"
+        ),
+    ] = None,
+    created_at: Annotated[
+        Optional[datetime],
+        typer.Option(help="Creation timestamp in ISO 8601 format (exact match)"),
+    ] = None,
+    created_at_gte: Annotated[
+        Optional[datetime],
+        typer.Option(
+            help="Creation timestamp in ISO 8601 format (greater than or equal)"
+        ),
+    ] = None,
+    created_at_lte: Annotated[
+        Optional[datetime],
+        typer.Option(help="Creation timestamp in ISO 8601 format (less than or equal)"),
+    ] = None,
+    created_at_gt: Annotated[
+        Optional[datetime],
+        typer.Option(help="Creation timestamp in ISO 8601 format (greater than)"),
+    ] = None,
+    created_at_lt: Annotated[
+        Optional[datetime],
+        typer.Option(help="Creation timestamp in ISO 8601 format (less than)"),
+    ] = None,
+    updated_at: Annotated[
+        Optional[datetime],
+        typer.Option(help="Last update timestamp in ISO 8601 format (exact match)"),
+    ] = None,
+    updated_at_gte: Annotated[
+        Optional[datetime],
+        typer.Option(
+            help="Last update timestamp in ISO 8601 format (greater than or equal)"
+        ),
+    ] = None,
+    updated_at_lte: Annotated[
+        Optional[datetime],
+        typer.Option(
+            help="Last update timestamp in ISO 8601 format (less than or equal)"
+        ),
+    ] = None,
+    updated_at_gt: Annotated[
+        Optional[datetime],
+        typer.Option(help="Last update timestamp in ISO 8601 format (greater than)"),
+    ] = None,
+    updated_at_lt: Annotated[
+        Optional[datetime],
+        typer.Option(help="Last update timestamp in ISO 8601 format (less than)"),
+    ] = None,
+):
+    """List services for a service bundle"""
+    async with Connection() as conn:
+        # Fetch parent resource
+        parent_ctrl = ServiceBundle(conn, api_schema)
+        parent_model = await parent_ctrl.fetch(service_bundle_id)
+
+        # Build modifier for filtering and includes
+        modifier = []
+
+        if category is not None:
+            modifier.append(Filter(category=category))
+
+        if name is not None:
+            modifier.append(Filter(name=name))
+
+        if description is not None:
+            modifier.append(Filter(description=description))
+
+        if version is not None:
+            modifier.append(Filter(version=version))
+
+        if deprecated_at is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[deprecated_at]="
+                    + deprecated_at.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if deprecated_at_gte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[deprecated_at_gte]="
+                    + deprecated_at_gte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if deprecated_at_lte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[deprecated_at_lte]="
+                    + deprecated_at_lte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if deprecated_at_gt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[deprecated_at_gt]="
+                    + deprecated_at_gt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if deprecated_at_lt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[deprecated_at_lt]="
+                    + deprecated_at_lt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+
+        if created_at is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[created_at]="
+                    + created_at.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if created_at_gte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[created_at_gte]="
+                    + created_at_gte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if created_at_lte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[created_at_lte]="
+                    + created_at_lte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if created_at_gt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[created_at_gt]="
+                    + created_at_gt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if created_at_lt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[created_at_lt]="
+                    + created_at_lt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+
+        if updated_at is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[updated_at]="
+                    + updated_at.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if updated_at_gte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[updated_at_gte]="
+                    + updated_at_gte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if updated_at_lte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[updated_at_lte]="
+                    + updated_at_lte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if updated_at_gt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[updated_at_gt]="
+                    + updated_at_gt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if updated_at_lt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[updated_at_lt]="
+                    + updated_at_lt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+
+        # Table definition
+        tabledef: TableDef = [
+            {"header": Column("Id", no_wrap=True), "column": "id"},
+            {"header": "Name", "column": "name"},
+            {"header": "Category", "column": "category"},
+            {"header": "Version", "column": "version"},
+            {"header": "Created", "column": "created_at"},
+            {"header": "Updated", "column": "updated_at"},
+        ]
+
+        # List related resources
+        await list_relation_resources(ctx, parent_model, "services", tabledef, modifier)
+
+
+@app.async_command(name="list-products", help="List products for a service bundle")
+async def list_products(
+    ctx: typer.Context,
+    service_bundle_id: Annotated[UUID, typer.Argument(help="Parent resource ID")],
+    name: Annotated[Optional[str], typer.Option(help="Product name")] = None,
+    product_type: Annotated[
+        Optional[str],
+        typer.Option(help="Type of product (option only available for child products)"),
+    ] = None,
+    price: Annotated[Optional[str], typer.Option(help="Product price")] = None,
+    default_bill_sequence: Annotated[
+        Optional[str],
+        typer.Option(help="Default billing sequence (only for management products)"),
+    ] = None,
+    invoice_description: Annotated[
+        Optional[str], typer.Option(help="Default description for the invoice item")
+    ] = None,
+    options: Annotated[
+        Optional[str], typer.Option(help="Product options in JSON format")
+    ] = None,
+    account: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="The account that owns this product (null for a global product)"
+        ),
+    ] = None,
+    parent: Annotated[
+        Optional[UUID],
+        typer.Option(help="The parent product (if this is a child product)"),
+    ] = None,
+    product_location: Annotated[
+        Optional[UUID],
+        typer.Option(help="The location where this product is delivered"),
+    ] = None,
+    publish_start: Annotated[
+        Optional[datetime],
+        typer.Option(help="Start of the publication window (exact match)"),
+    ] = None,
+    publish_start_gte: Annotated[
+        Optional[datetime],
+        typer.Option(help="Start of the publication window (greater than or equal)"),
+    ] = None,
+    publish_start_lte: Annotated[
+        Optional[datetime],
+        typer.Option(help="Start of the publication window (less than or equal)"),
+    ] = None,
+    publish_start_gt: Annotated[
+        Optional[datetime],
+        typer.Option(help="Start of the publication window (greater than)"),
+    ] = None,
+    publish_start_lt: Annotated[
+        Optional[datetime],
+        typer.Option(help="Start of the publication window (less than)"),
+    ] = None,
+    publish_end: Annotated[
+        Optional[datetime],
+        typer.Option(help="End of the publication window (exact match)"),
+    ] = None,
+    publish_end_gte: Annotated[
+        Optional[datetime],
+        typer.Option(help="End of the publication window (greater than or equal)"),
+    ] = None,
+    publish_end_lte: Annotated[
+        Optional[datetime],
+        typer.Option(help="End of the publication window (less than or equal)"),
+    ] = None,
+    publish_end_gt: Annotated[
+        Optional[datetime],
+        typer.Option(help="End of the publication window (greater than)"),
+    ] = None,
+    publish_end_lt: Annotated[
+        Optional[datetime],
+        typer.Option(help="End of the publication window (less than)"),
+    ] = None,
+    created_at: Annotated[
+        Optional[datetime], typer.Option(help=" (exact match)")
+    ] = None,
+    created_at_gte: Annotated[
+        Optional[datetime], typer.Option(help=" (greater than or equal)")
+    ] = None,
+    created_at_lte: Annotated[
+        Optional[datetime], typer.Option(help=" (less than or equal)")
+    ] = None,
+    created_at_gt: Annotated[
+        Optional[datetime], typer.Option(help=" (greater than)")
+    ] = None,
+    created_at_lt: Annotated[
+        Optional[datetime], typer.Option(help=" (less than)")
+    ] = None,
+    updated_at: Annotated[
+        Optional[datetime], typer.Option(help=" (exact match)")
+    ] = None,
+    updated_at_gte: Annotated[
+        Optional[datetime], typer.Option(help=" (greater than or equal)")
+    ] = None,
+    updated_at_lte: Annotated[
+        Optional[datetime], typer.Option(help=" (less than or equal)")
+    ] = None,
+    updated_at_gt: Annotated[
+        Optional[datetime], typer.Option(help=" (greater than)")
+    ] = None,
+    updated_at_lt: Annotated[
+        Optional[datetime], typer.Option(help=" (less than)")
+    ] = None,
+):
+    """List products for a service bundle"""
+    async with Connection() as conn:
+        # Fetch parent resource
+        parent_ctrl = ServiceBundle(conn, api_schema)
+        parent_model = await parent_ctrl.fetch(service_bundle_id)
+
+        # Build modifier for filtering and includes
+        modifier = []
+
+        if name is not None:
+            modifier.append(Filter(name=name))
+
+        if product_type is not None:
+            modifier.append(
+                Filter(query_str="filter[product_type]=" + str(product_type))
+            )
+
+        if price is not None:
+            modifier.append(Filter(price=price))
+
+        if default_bill_sequence is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[default_bill_sequence]="
+                    + str(default_bill_sequence)
+                )
+            )
+
+        if invoice_description is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[invoice_description]=" + str(invoice_description)
+                )
+            )
+
+        if options is not None:
+            modifier.append(Filter(options=options))
+
+        if account is not None:
+            modifier.append(Filter(account=str(account)))
+
+        if parent is not None:
+            modifier.append(Filter(parent=str(parent)))
+
+        if product_location is not None:
+            modifier.append(
+                Filter(query_str="filter[product-location]=" + str(product_location))
+            )
+
+        if publish_start is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[publish_start]="
+                    + publish_start.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if publish_start_gte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[publish_start_gte]="
+                    + publish_start_gte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if publish_start_lte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[publish_start_lte]="
+                    + publish_start_lte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if publish_start_gt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[publish_start_gt]="
+                    + publish_start_gt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if publish_start_lt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[publish_start_lt]="
+                    + publish_start_lt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+
+        if publish_end is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[publish_end]="
+                    + publish_end.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if publish_end_gte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[publish_end_gte]="
+                    + publish_end_gte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if publish_end_lte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[publish_end_lte]="
+                    + publish_end_lte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if publish_end_gt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[publish_end_gt]="
+                    + publish_end_gt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if publish_end_lt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[publish_end_lt]="
+                    + publish_end_lt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+
+        if created_at is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[created_at]="
+                    + created_at.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if created_at_gte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[created_at_gte]="
+                    + created_at_gte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if created_at_lte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[created_at_lte]="
+                    + created_at_lte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if created_at_gt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[created_at_gt]="
+                    + created_at_gt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if created_at_lt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[created_at_lt]="
+                    + created_at_lt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+
+        if updated_at is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[updated_at]="
+                    + updated_at.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if updated_at_gte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[updated_at_gte]="
+                    + updated_at_gte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if updated_at_lte is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[updated_at_lte]="
+                    + updated_at_lte.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if updated_at_gt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[updated_at_gt]="
+                    + updated_at_gt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+        if updated_at_lt is not None:
+            modifier.append(
+                Filter(
+                    query_str="filter[updated_at_lt]="
+                    + updated_at_lt.astimezone(timezone.utc)
+                    .replace(tzinfo=None)
+                    .isoformat(timespec="milliseconds")
+                    + "Z"
+                )
+            )
+
+        # Table definition
+        tabledef: TableDef = [
+            {"header": Column("Id", no_wrap=True), "column": "id"},
+            {"header": "Name", "column": "name"},
+            {"header": "Product Type", "column": "product_type"},
+            {"header": "Price", "column": "price"},
+            {"header": "Created", "column": "created_at"},
+            {"header": "Updated", "column": "updated_at"},
+        ]
+
+        # List related resources
+        await list_relation_resources(ctx, parent_model, "products", tabledef, modifier)

{cacholong_cloud_cli-1.13.2 → cacholong_cloud_cli-1.14.1}/cacholong_cli/common.py

@@ -15,6 +15,7 @@ import json
 from cacholong_sdk import BaseController, BaseModel
 from cacholong_sdk import Modifier, Sort, SparseField, DocumentError
 from cacholong_sdk.exception import ValidationException
+from jsonapi_client.relationships import SingleRelationship
 from uuid import UUID
 
 ErrorConsole = Console(stderr=True)
@@ -151,6 +152,20 @@ def _flatten(exc: BaseException) -> List[BaseException]:
     return [exc]
 
 
+def _is_empty_to_one(relationship: Any) -> bool:
+    """True for a to-one relationship without linkage.
+
+    The API may omit a relationship entirely (e.g. ``account`` on a global
+    service bundle). The client then builds it from the schema as an
+    identifier without type and id; fetching that would request
+    ``<api_url>/None/None``.
+    """
+    return (
+        isinstance(relationship, SingleRelationship)
+        and relationship.as_json_resource_identifiers is None
+    )
+
+
 async def _perform_list_resources(
     controller: BaseController,
     modifier: Modifier,
@@ -164,7 +179,8 @@ async def _perform_list_resources(
     ]
     async for resource in controller.fetch_all(modifier):
         for relation in relations:
-            await resource[relation].fetch()
+            if not _is_empty_to_one(resource[relation]):
+                await resource[relation].fetch()
         callback(resource)
 
 
@@ -179,8 +195,9 @@ async def _perform_list_relation_resources(
 def _handle_column(row: BaseModel, column_definition: Dict[str, Any]) -> str:
     if "nested_column" in column_definition:
         column_key = column_definition.get("column_kebab", column_definition["column"])
-        if row[column_key].resource != None:
-            return str(row[column_key].resource[column_definition["nested_column"]])
+        relationship = row[column_key]
+        if not _is_empty_to_one(relationship) and relationship.resource != None:
+            return str(relationship.resource[column_definition["nested_column"]])
         return ""
     else:
         return str(row[column_definition["column"]])

{cacholong_cloud_cli-1.13.2 → cacholong_cloud_cli-1.14.1}/cacholong_sdk/__init__.py

@@ -19,6 +19,8 @@ from .service_mails import ServiceMailModel, ServiceMail
 from .mail_forwards import MailForwardModel, MailForward
 from .products import ProductModel, Product
 from .purchases import PurchaseModel, Purchase
+from .service_bundles import ServiceBundleModel, ServiceBundle
+from .services import ServiceModel, Service
 
 # Import directly from jsonapi
 from jsonapi_client import Modifier, Filter, Inclusion, Sort, SparseField

{cacholong_cloud_cli-1.13.2 → cacholong_cloud_cli-1.14.1}/cacholong_sdk/api_schema.py

@@ -302,7 +302,7 @@ api_schema = {
     },
     "dns-zones:update": {
         "properties": {
-            "domain": {"type": ["string"]},
+            "domain": {"type": ["string", "null"]},
             "active": {"type": ["boolean", "null"]},
             "dnssec": {"type": ["boolean", "null"]},
             "account": {"relation": "to-one", "resource": "accounts"},
@@ -817,4 +817,65 @@ api_schema = {
             "product": {"relation": "to-one", "resource": "products"},
         }
     },
+    "service-bundles": {
+        "properties": {
+            "name": {"type": ["string"]},
+            "description": {"type": ["string", "null"]},
+            "created_at": {"type": ["string", "null"]},
+            "updated_at": {"type": ["string", "null"]},
+            "account": {"relation": "to-one", "resource": "accounts"},
+            "services": {"relation": "to-many", "resource": "services"},
+            "products": {"relation": "to-many", "resource": "products"},
+        }
+    },
+    "service-bundles:base": {
+        "properties": {
+            "name": {"type": ["string"]},
+            "description": {"type": ["string", "null"]},
+        }
+    },
+    "service-bundles:show": {
+        "properties": {
+            "name": {"type": ["string"]},
+            "description": {"type": ["string", "null"]},
+            "created_at": {"type": ["string", "null"]},
+            "updated_at": {"type": ["string", "null"]},
+            "account": {"relation": "to-one", "resource": "accounts"},
+            "services": {"relation": "to-many", "resource": "services"},
+            "products": {"relation": "to-many", "resource": "products"},
+        }
+    },
+    "services": {
+        "properties": {
+            "category": {"type": ["string"]},
+            "name": {"type": ["string"]},
+            "description": {"type": ["string", "null"]},
+            "version": {"type": ["string"]},
+            "deprecated_at": {"type": ["string", "null"]},
+            "created_at": {"type": ["string", "null"]},
+            "updated_at": {"type": ["string", "null"]},
+            "service-bundles": {"relation": "to-many", "resource": "service-bundles"},
+        }
+    },
+    "services:base": {
+        "properties": {
+            "category": {"type": ["string"]},
+            "name": {"type": ["string"]},
+            "description": {"type": ["string", "null"]},
+            "version": {"type": ["string"]},
+            "deprecated_at": {"type": ["string", "null"]},
+        }
+    },
+    "services:show": {
+        "properties": {
+            "category": {"type": ["string"]},
+            "name": {"type": ["string"]},
+            "description": {"type": ["string", "null"]},
+            "version": {"type": ["string"]},
+            "deprecated_at": {"type": ["string", "null"]},
+            "created_at": {"type": ["string", "null"]},
+            "updated_at": {"type": ["string", "null"]},
+            "service-bundles": {"relation": "to-many", "resource": "service-bundles"},
+        }
+    },
 }

cacholong_cloud_cli-1.14.1/cacholong_sdk/service_bundles.py

@@ -0,0 +1,14 @@
+from typing import Optional, Dict
+from .common import BaseController, BaseModel
+
+
+class ServiceBundleModel(BaseModel):
+    pass
+
+
+class ServiceBundle(BaseController[ServiceBundleModel]):
+    _class = ServiceBundleModel
+
+    def __init__(self, connection, api_schema: Optional[dict] = None):
+        self._resource = "service-bundles"
+        super().__init__(connection, api_schema)

cacholong_cloud_cli-1.14.1/cacholong_sdk/services.py

@@ -0,0 +1,14 @@
+from typing import Optional, Dict
+from .common import BaseController, BaseModel
+
+
+class ServiceModel(BaseModel):
+    pass
+
+
+class Service(BaseController[ServiceModel]):
+    _class = ServiceModel
+
+    def __init__(self, connection, api_schema: Optional[dict] = None):
+        self._resource = "services"
+        super().__init__(connection, api_schema)

{cacholong_cloud_cli-1.13.2 → cacholong_cloud_cli-1.14.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cacholong-cloud-cli"
-version = "1.13.2"
+version = "1.14.1"
 description = "Cacholong CLI, manage cloud environments at Cacholong!"
 authors = ["Matthijs Möhlmann <matthijs@cacholong.nl>"]
 readme = "README.md"