@aoxborrow/registrar-client 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aoxborrow/registrar-client",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "One consistent, fully-typed TypeScript interface to many domain registrar APIs (GoDaddy, Cloudflare, Namecheap, Spaceship, Dynadot, Porkbun, and more) behind a single pluggable multi-provider client",
   "author": {
     "name": "Aaron Oxborrow",
@@ -11,6 +11,7 @@
     "access": "public"
   },
   "homepage": "https://github.com/aoxborrow/registrar-client",
+  "funding": "https://github.com/sponsors/aoxborrow",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/aoxborrow/registrar-client.git"

package/src/client.ts

@@ -50,8 +50,10 @@ export class RegistrarClient {
           const detail = await this.provider.getDomain(name, opts);
           let merged = { ...domains[index], ...detail };
           // Some providers expose nameservers only via a dedicated endpoint, not
-          // on the domain detail — fetch them separately when still empty.
-          if (merged.nameservers.length === 0) {
+          // on the domain detail — fetch them separately when still empty. Skip
+          // providers whose getNameservers just re-reads getDomain: it would
+          // repeat the same call and return the same empty result.
+          if (merged.nameservers.length === 0 && this.provider.requiresNameserversFetch) {
             try {
               const nameservers = normalizeNameservers(
                 await this.provider.getNameservers(name, opts)

package/src/registrar.ts

@@ -75,6 +75,12 @@ export abstract class BaseRegistrar implements Registrar {
     return this.features.includes(feature);
   }
 
+  // See Registrar.requiresNameserversFetch. Defaults true, so a provider
+  // whose getNameservers hits a real endpoint keeps the enrichment fallback
+  // without opting in; the providers whose getNameservers just re-reads getDomain
+  // override this to false to drop the redundant call.
+  readonly requiresNameserversFetch: boolean = true;
+
   constructor(
     credentials: RegistrarCredentials,
     httpConfig: Omit<HttpClientConfig, 'options'>,

package/src/registrars/dynadot.ts

@@ -321,6 +321,10 @@ export class DynadotRegistrar extends BaseRegistrar {
     return data.domain_info;
   }
 
+  // getNameservers re-reads getDomain (domain_info carries NS inline; no separate
+  // endpoint), so listing enrichment gains nothing from the fallback — skip it.
+  override readonly requiresNameserversFetch = false;
+
   override async getNameservers(domainName: string, opts?: RequestOptions): Promise<string[]> {
     // domain_info carries the nameservers inline (empty for Dynadot-DNS-hosted
     // domains, which have no external NS)

package/src/registrars/godaddy.ts

@@ -271,20 +271,28 @@ export class GoDaddyRegistrar extends BaseRegistrar {
   static readonly displayName = 'GoDaddy';
   static readonly website = 'godaddy.com';
   static readonly helpText =
-    'Authenticate one of two ways. For production, create a Personal Access ' +
-    'Token (PAT) at https://developer.godaddy.com and pass it as `apiToken` — ' +
-    'this enables the modern v3 API. For sandbox testing, create OTE ' +
-    '(test environment) keys and pass `apiKey` + `apiSecret` with ' +
-    '{ environment: "sandbox" }; OTE only exposes the legacy v1 API. The ' +
-    'sso-key (API Key/Secret) scheme is deprecated by GoDaddy in 2026. ' +
-    'Domain forwarding uses the v2 customer-scoped API — set `customerId` to ' +
-    'your GoDaddy customer UUID, or to your numeric shopper/account ID (which ' +
-    'the client resolves to the UUID via an sso-key-authenticated lookup).';
+    'Create a Personal Access Token (PAT) at https://developer.godaddy.com and ' +
+    "paste it here. The PAT is GoDaddy's modern credential: it unlocks the v3 " +
+    'API (discovery, registration, DNS, nameservers) and also authenticates the ' +
+    'legacy v1 API for management operations (renew, transfer, auto-renew, ' +
+    'lock, privacy, contacts) — one token covers everything.';
+  // Only the PAT is exposed for configuration — it is the sole credential
+  // GoDaddy recommends going forward, and it covers every production operation.
+  //
+  // The legacy `apiKey` + `apiSecret` (sso-key) pair and the `customerId` field
+  // are intentionally NOT advertised here. The code that consumes them is kept
+  // (see `authHeader`, `useV3`, `resolveCustomerId`, and the forwarding methods)
+  // so OTE/sandbox testing and direct programmatic use still work when those
+  // values are passed in credentials explicitly. But because they are no longer
+  // configurable, two capabilities are effectively unreachable through normal
+  // (config-driven) setup:
+  //   - OTE/sandbox, which needs an sso-key (`apiKey` + `apiSecret`), and
+  //   - domain forwarding, which needs `customerId` (a customer UUID), plus an
+  //     sso-key to resolve a numeric shopper ID to that UUID.
+  // GoDaddy is deprecating the sso-key scheme in 2026, so this is the direction
+  // of travel regardless.
   static readonly configFields: ConfigField[] = [
-    { name: 'apiToken', label: 'API Token (PAT)', type: 'password', required: false },
-    { name: 'apiKey', label: 'API Key', type: 'password', required: false },
-    { name: 'apiSecret', label: 'API Secret', type: 'password', required: false },
-    { name: 'customerId', label: 'Customer ID or Shopper ID', type: 'text', required: false },
+    { name: 'apiToken', label: 'API Token (PAT)', type: 'password', required: true },
   ];
   // GoDaddy's OTE ("Operational Test Environment") is its sandbox
   static readonly supportsSandbox = true;
@@ -421,6 +429,10 @@ export class GoDaddyRegistrar extends BaseRegistrar {
     return this.toDomain(d);
   }
 
+  // getNameservers re-reads getDomain (GoDaddy has no dedicated NS endpoint), so
+  // listing enrichment gains nothing from the fallback — skip it.
+  override readonly requiresNameserversFetch = false;
+
   override async getNameservers(domainName: string, opts?: RequestOptions): Promise<string[]> {
     const domain = await this.getDomain(domainName, opts);
     return domain.nameservers;

package/src/registrars/namesilo.ts

@@ -286,6 +286,10 @@ export class NameSiloRegistrar extends BaseRegistrar {
     });
   }
 
+  // getNameservers re-reads getDomain (getDomainInfo carries NS; no separate
+  // endpoint), so listing enrichment gains nothing from the fallback — skip it.
+  override readonly requiresNameserversFetch = false;
+
   override async getNameservers(domainName: string, opts?: RequestOptions): Promise<string[]> {
     const domain = await this.getDomain(domainName, opts);
     return domain.nameservers;

package/src/registrars/spaceship.ts

@@ -204,6 +204,10 @@ export class SpaceshipRegistrar extends BaseRegistrar {
     return this.toDomain(await this.getRaw(domainName, opts));
   }
 
+  // getNameservers reads the same getRaw payload as getDomain (no dedicated NS
+  // endpoint), so listing enrichment gains nothing from the fallback — skip it.
+  override readonly requiresNameserversFetch = false;
+
   override async getNameservers(domainName: string, opts?: RequestOptions): Promise<string[]> {
     const d = await this.getRaw(domainName, opts);
     return d.nameservers?.hosts ?? [];

package/src/types.ts

@@ -307,6 +307,13 @@ export interface Registrar {
   // the capabilities this provider supports (core contract + its extended features)
   readonly features: readonly RegistrarFeature[];
 
+  // Whether reading a domain's nameservers needs a getNameservers call beyond
+  // getDomain. True when getNameservers hits its own endpoint that can surface
+  // nameservers getDomain omits; false when it just re-reads getDomain, so
+  // listing enrichment skips the redundant fetch. See BaseRegistrar for the
+  // default.
+  readonly requiresNameserversFetch: boolean;
+
   // whether this provider supports a given capability
   supports(feature: RegistrarFeature): boolean;