feat(domain): migrate domain list to v3, add premium/pricing support

[jpage-godaddy]

Summary

Migrates gddy domain list from the v1 API to the v3 Domain Lifecycle Management API's listDomains, plus premium-domain/pricing support that shipped alongside it. v3 domains is now live in production and this has been sign-off'd by the domains team.

• domain list calls v3 GET /domain-names instead of v1. --status stays repeatable (comma-joined client-side, matching the API's style: form, explode: false); the default "hide non-visible domains" view maps to lifecycleGroups excluding TERMINAL. Output fields and --schema type move to the v3 Domain shape (breaking change for --output json consumers).
• domain list fetches every page via listDomains's cursor pagination (links[rel=next]), not just the first — an explicit --limit/--offset window (cli-engine's existing pagination pipeline) short-circuits the fetch once satisfied; unflagged, every domain is fetched. Requests the API's max pageSize (200) each time to minimize round trips against a tightly rate-limited API. A defensive cap (50 pages) errors rather than silently returning a partial list if a next link ever loops or is malformed.
• Afternic premium-domain support end to end: Fee/FeeType, TermPrice.fees/firstTermPrice, RegistrationQuote.fees/inventory, Registration.fees, Consent.acknowledgedFees. A premium quote's fees/inventory are surfaced and cached, and purchase echoes the fees back into consent.acknowledgedFees (required server-side for the purchase to succeed).
• Bulk check-availability's domain cap corrected to the now-official 25 (was 50).
• domain available lists every priced registration term (1yr, 2yr, 3yr, ...) as a nested table instead of a single 1-year headline, including any first-term promotion. Also breaking for --output json consumers (price/renewalPrice/period/periodLabel replaced by terms[]). TermPrice.recommended is deliberately not surfaced — it's a hint meant for web UIs, not CLI output.

Deliberately not included:

• replaceDNSRecord (PUT) — live-confirmed the old zone-wiping bug (gddy dns set wipes the entire zone — issues a PUT to a non-existent v3 dns-records endpoint that the API executes as a full-collection replace #136) is fixed, but still excluded from the client pending a decision on simplifying dns set's existing create-then-delete workaround.
• setAutoRenew/setTransferLock — new v3.2 endpoints, not yet wired to any command.
• domain agreements stays on v1 — no v3 equivalent exists yet.

Production readiness

• Vendored spec re-diffed against the canonical source and the private prototype bundle: every schema/path this crate uses matches exactly, no drift since the last sync.
• servers[0].url in the vendored spec is now prod-canonical (api.godaddy.com) — needed correctly by generate-api-catalog's resolve_catalog_base_url, which derives every other environment's URL from it by host substitution.
• Live-verified directly against api.godaddy.com: domain list/available/suggest/quote all return genuine 200s; domain get/dns list against domains this account doesn't own return proper structured DOMAIN_NOT_FOUND/ZONE_NOT_FOUND errors (not gateway 404s), confirming those routes are correctly wired.
• Caught and worked around a transient rollout gap (an EFD/routing config issue that had listDomains/getDomain/DNS-records gateway-404ing even though suggest/available/quote were live) — confirmed fixed by the domains team before finalizing this PR.

Test plan

• cargo check, cargo clippy -- -D warnings, cargo test, cargo fmt --check all clean (656 tests)
• Live-smoke-tested against prod: domain list (default view, pagination envelope via --limit/--offset), domain available, domain suggest, domain quote, domain get, dns list
• Copilot review clean across 12+ rounds — every finding fixed or explained on the PR thread (see review history)
• Rebased onto latest main, no conflicts

🤖 Generated with Claude Code

[Copilot]

Pull request overview

Preview migration of the Domains CLI to newer v3 Domain Lifecycle Management API shapes, including premium-domain fee acknowledgement and richer pricing/term output, backed by an updated vendored OpenAPI spec.

Changes:

• Migrate gddy domain list to v3 listDomains and update default fields/schema to the v3 Domain shape.
• Add premium-domain fee plumbing: cache quote fees, surface them in domain quote output, and echo them into consent.acknowledgedFees on domain purchase.
• Update domain available to emit per-term pricing as a nested terms[] table and sync spec changes (listDomains, fees, availability cap).

Reviewed changes

Copilot reviewed 10 out of 10 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
rust/src/quote_cache.rs	Cache premium quote fees alongside existing quote metadata.
rust/src/domain/suggest.rs	Update test fixtures for new v3 suggestion fields (fees/first-term/recommended).
rust/src/domain/quote.rs	Surface premium inventory/fees in quote output and cache fees for purchase.
rust/src/domain/purchase.rs	Echo cached quote fees into purchase consent; align request struct fields with new spec.
rust/src/domain/list.rs	Switch domain list to v3 listDomains and adjust filtering/default fields.
rust/src/domain/common.rs	Remove now-unused headline pricing helper (available now emits all terms).
rust/src/domain/available.rs	Replace headline price output with per-term terms[] nested table output.
rust/domains-client/src/lib.rs	Update generated-client test expectations for new consent/registration fields.
rust/domains-client/openapi/swagger_domains.v3.yaml	Vendor spec updates for listDomains, fee types, acknowledgedFees, and availability cap.
rust/domains-client/openapi/domains.oas3.json	Mirror spec updates in merged OAS3 JSON consumed by codegen.

Suppressed comments (1)

rust/src/domain/list.rs:113

• listDomains is cursor-paginated (returns a DomainCollection with pagination links), but this handler only sends a single request and returns items from the first page. For accounts with more domains than the API default page size, gddy domain list will silently omit the remaining domains.

Consider looping while a links entry with rel == "next" exists: extract pageToken from its href, call list_domains().page_token(...) (and direction if required), and accumulate items until no next link remains (or until the CLI --limit is satisfied).

            let client = make_client(&ctx).await?;
            let mut req = client.list_domains();
            if !statuses.is_empty() {
                // `statuses` is `style: form, explode: false` — one
                // comma-joined value, not repeated `statuses=` pairs
                // (progenitor always seq-serializes a `Vec` as repeated pairs
                // regardless of the spec's `explode` setting; see
                // `comma_joined`'s doc comment / DEVEX-882).
                req = req.statuses(comma_joined(statuses));
            } else if visible_only {
                req = req.lifecycle_groups(
                    comma_joined(
                        DEFAULT_VISIBLE_GROUPS
                            .into_iter()
                            .map(str::to_string)
                            .collect(),
                    )
                    .into_iter()
                    .map(types::DomainLifecycleGroup::from)
                    .collect::<Vec<_>>(),
                );
            }
            let resp = match req.send().await {
                Ok(r) => r,
                Err(e) => return Err(api_error("listing domains", debug, e).await),
            };
            let domains: Vec<serde_json::Value> = resp
                .into_inner()
                .items
                .unwrap_or_default()
                .iter()
                .map(serde_json::to_value)
                .collect::<std::result::Result<_, _>>()
                .map_err(|e| {

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[Copilot]

Pull request overview

Copilot reviewed 10 out of 10 changed files in this pull request and generated no new comments.

Suppressed comments (2)

rust/src/domain/list.rs:106

• listDomains returns a paginated DomainCollection (default pageSize is 100, with cursor-based pageToken + links[rel=next]). The handler currently performs a single send() and serializes only that page’s items, so accounts with more than one page of domains will get truncated results.

Consider looping until there is no next link (parse pageToken/optional direction from the href) and accumulating items across pages; also consider setting pageSize to the API max (200) to reduce requests.

            let resp = match req.send().await {
                Ok(r) => r,
                Err(e) => return Err(api_error("listing domains", debug, e).await),
            };
            let domains: Vec<serde_json::Value> = resp

rust/src/domain/list.rs:88

• The statuses/lifecycleGroups query params require the comma_joined workaround (style: form, explode: false), but there’s no regression test here to prove we keep sending a single statuses=ACTIVE,EXPIRED (and the default visible lifecycleGroups=...) rather than repeated statuses= pairs.

Add an httpmock-based test similar to rust/src/domain/agreements.rs’s tlds_are_sent_as_a_single_comma_joined_query_param, covering both multiple --status values and the default visible-only lifecycleGroups path.

This issue also appears on line 102 of the same file.

                // comma-joined value, not repeated `statuses=` pairs
                // (progenitor always seq-serializes a `Vec` as repeated pairs
                // regardless of the spec's `explode` setting; see
                // `comma_joined`'s doc comment / DEVEX-882).
                req = req.statuses(comma_joined(statuses));

[Copilot]

Pull request overview

Copilot reviewed 10 out of 10 changed files in this pull request and generated no new comments.

[Copilot]

Pull request overview

Copilot reviewed 10 out of 10 changed files in this pull request and generated no new comments.

Suppressed comments (1)

rust/src/domain/list.rs:30

• MAX_PAGES’ doc comment says hitting the cap “is treated as a bug … rather than silently returned as if it were the complete list”, but fetch_domains currently just exits the loop and returns Ok(items) even if a rel=next token is still present. That’s misleading for maintainers and future debugging of truncated results.

/// Defensive cap on pages fetched for one invocation. No real account should
/// ever approach `MAX_PAGE_SIZE * MAX_PAGES` (10,000) domains; hitting this
/// is treated as a bug (a malformed or looping `next` link) rather than
/// silently returned as if it were the complete list.
const MAX_PAGES: usize = 50;

[Copilot]

Pull request overview

Copilot reviewed 10 out of 10 changed files in this pull request and generated 1 comment.

Suppressed comments (2)

rust/src/domain/list.rs:343

• The pagination tests only exercise absolute href values, but the spec’s link examples commonly use relative paths (e.g. /v3/domains/...). Using a relative href here would better pin the real-world behavior and would have caught the Url::parse issue.

    fn next_page_token_parses_token_and_direction_from_the_next_link() {
        let links = next_link(
            "https://api.example.com/v3/domains/domain-names?pageToken=abc123&pageTokenDirection=forward",
        );
        let (token, direction) = next_page_token(&links).expect("next link present");

rust/src/domain/available.rs:78

• shared_currency looks only at price/renewal_price, but the handler can emit firstTermPrice in terms. If (now or in a future API version) a term includes only firstTermPrice with a currency code, the top-level currency field would be omitted even though the information is available.

/// The currency code shared by a domain's priced terms, sourced from whichever
/// term has a price or renewal price first (all terms use the same currency in
/// practice, so one top-level field covers every row in `terms`).
fn shared_currency(prices: &[types::TermPrice]) -> Option<String> {
    prices
        .iter()
        .find_map(|t| t.price.as_ref().or(t.renewal_price.as_ref()))
        .and_then(|m| m.currency_code.as_ref())
        .map(|c| c.to_string())

[Copilot]

Pull request overview

Copilot reviewed 10 out of 10 changed files in this pull request and generated no new comments.

Suppressed comments (3)

rust/src/domain/quote.rs:384

• fees caching silently drops JSON serialization errors via .ok(). If serialization ever fails (e.g., a future type change), the quote will still be shown but domain purchase will later fail with quote_mismatch because consent.acknowledgedFees can’t be echoed back. This should fail fast with a clear message (similar to profile_json) instead of silently caching None.

                    fees: quote
                        .fees
                        .as_ref()
                        .filter(|f| !f.is_empty())
                        .and_then(|f| serde_json::to_value(f).ok()),

rust/src/domain/list.rs:105

• The PR description says true cursor pagination for domain list is “deliberately not included” and that the handler fetches only the first page. This implementation now follows links[rel=next] across pages via fetch_domains, so the description looks out of date and could mislead reviewers/users about behavior and rate-limit impact.

/// Fetch every domain matching `statuses`/`visible_only`, following v3's
/// `links[rel=next]` cursor until the API reports no further page — or until
/// `stop_at` items have been accumulated, when an explicit `--limit`/
/// `--offset` window needs no more than that many (cli-engine's own
/// pagination pipeline slices the exact window from whatever this returns;

rust/domains-client/openapi/swagger_domains.v3.yaml:1156

• A safety note explaining why replaceDNSRecord (PUT) was removed is no longer present. Given the historical zone-wipe behavior (#136) and the PR description stating this endpoint is still deliberately excluded, keeping a short warning here helps prevent accidental reintroduction without a re-verification.

  /zones/{zone}/dns-records/{recordId}:

[Copilot]

Pull request overview

Copilot reviewed 10 out of 10 changed files in this pull request and generated no new comments.

Suppressed comments (3)

rust/src/domain/list.rs:43

• parse_statuses uppercases each --status value twice (to_uppercase() in both validation and return). This does extra allocation/work for every status value; compute the uppercase string once and reuse it for both the enum validation and the returned wire form.

fn parse_statuses(raw: &[String]) -> Result<Vec<String>> {
    raw.iter()
        .map(|s| {
            types::DomainStatus::try_from(s.to_uppercase().as_str())
                .map(|_| s.to_uppercase())
                .map_err(|_| CliCoreError::message(format!("invalid --status {s:?}")))

rust/domains-client/openapi/domains.oas3.json:18

• The OpenAPI servers[0].url is now set to the OTE (test) host. If any code (or future consumers) uses the generated client’s default base URL from the spec, this can cause unintended calls to test instead of prod. Since the CLI already selects the environment via config (config.domains_api_url), consider keeping the spec’s server URL pointed at the production host and relying on runtime config for test/prod selection.

  "servers": [
    {
      "url": "https://api.ote-godaddy.com",
      "description": "Domains API host"
    }

rust/src/domain/quote.rs:56

• fees_to_json always emits a type key, but its value can be null when f.type_ is absent. That null will leak into --output json and the nested table output; it’s clearer to omit the key when it’s missing (consistent with how other optional fields are handled in this file).

                let mut out = json!({
                    "type": f.type_.as_ref().map(|t| t.to_string()),
                });

[Copilot]

Pull request overview

Copilot reviewed 10 out of 10 changed files in this pull request and generated no new comments.

Suppressed comments (1)

rust/src/domain/quote.rs:265

• inventory and fees were added to the quote output/table view, but there are no unit tests asserting that view_columns() correctly renders these new nested fields (or that they stay omitted when absent). Since this file already has view-rendering regression tests for other nested fields, add a similar test that builds an envelope containing inventory + a non-empty fees array and asserts the human view includes the expected nested rows/labels.

        TableColumn::new("inventory", "Inventory"),
        TableColumn::new("fees", "Fees").nested(vec![
            TableColumn::new("type", "Type"),
            TableColumn::new("amount", "Amount"),
            TableColumn::new("currency", "Currency"),
        ]),

[Copilot]

Pull request overview

Copilot reviewed 10 out of 10 changed files in this pull request and generated no new comments.

Suppressed comments (1)

rust/src/domain/list.rs:159

• PR description says the defensive pagination cap should error when a links[rel=next] is malformed; however fetch_domains currently treats an unparseable/missing pageToken as end-of-list and returns a partial result silently (next_page_token returns None both for “no next page” and “malformed next link”). Consider failing fast when a next rel is present but pageToken can’t be extracted, so callers don’t get truncated domain lists that look complete. (If you keep the current behavior, the PR description should be updated to match.)

        page_token = collection.links.and_then(|links| next_page_token(&links));
        if page_token.is_none() {
            return Ok(items);
        }

[Copilot]

Pull request overview

Copilot reviewed 10 out of 10 changed files in this pull request and generated no new comments.

Suppressed comments (1)

rust/src/domain/list.rs:236

• stop_at is computed via ctx.middleware.offset.max(0) + limit, which can overflow for large --offset values (panics in debug builds; wraps in release). Using a saturating/checked add avoids overflow while preserving the existing fallback-to-usize::MAX behavior.

            let limit = ctx.middleware.limit;
            let stop_at = (limit > 0).then(|| {
                usize::try_from(ctx.middleware.offset.max(0) + limit).unwrap_or(usize::MAX)
            });

[Copilot]

Pull request overview

Copilot reviewed 11 out of 11 changed files in this pull request and generated no new comments.