@aoxborrow/registrar-client 0.7.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aoxborrow/registrar-client",
-  "version": "0.7.0",
+  "version": "0.8.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",
@@ -89,20 +89,20 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/node": "^26.2.0",
-    "@typescript-eslint/eslint-plugin": "^8.56.0",
-    "@typescript-eslint/parser": "^8.56.0",
+    "@types/node": "^26.6.2",
+    "@typescript-eslint/eslint-plugin": "^8.71.1",
+    "@typescript-eslint/parser": "^8.71.1",
     "@vitest/coverage-v8": "^4.1.11",
-    "dotenv": "^17.4.2",
-    "eslint": "^10.9.0",
+    "dotenv": "^18.0.1",
+    "eslint": "^10.11.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import-x": "^4.17.1",
-    "globals": "^17.11.0",
-    "prettier": "^3.6.2",
+    "globals": "^17.12.0",
+    "prettier": "^3.9.8",
     "tsup": "^8.5.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.56.0",
+    "typescript-eslint": "^8.71.1",
     "vitest": "^4.1.11"
   },
   "dependencies": {

package/src/http.ts

@@ -31,6 +31,9 @@ export interface HttpClientConfig {
   // unset for APIs where the method means nothing: Namecheap and NameSilo send
   // writes as GET. Those mark their nested reads with `asRead` instead.
   safeMethods?: readonly string[];
+  // A provider-specific delay for HTTP 429 without a usable Retry-After.
+  // Otherwise the normal exponential backoff applies.
+  rateLimitFallbackSeconds?: number;
 }
 
 export const REST_SAFE_METHODS: readonly string[] = ['GET', 'HEAD'];
@@ -260,8 +263,10 @@ export class HttpClient {
       case 404:
         return new NotFoundError(message);
       case 429: {
-        const retryAfter = Number(response.headers.get('retry-after'));
-        return new RateLimitError(message, Number.isFinite(retryAfter) ? retryAfter : undefined);
+        const retryAfter =
+          parseRetryAfter(response.headers.get('retry-after')) ??
+          this.config.rateLimitFallbackSeconds;
+        return new RateLimitError(message, retryAfter);
       }
       default: {
         if (response.status >= 500) {
@@ -277,6 +282,25 @@ export class HttpClient {
   }
 }
 
+// RFC 9110 Retry-After is delay-seconds or an HTTP date. Absence must stay
+// undefined: Number(null) is zero and would bypass the configured backoff.
+function parseRetryAfter(value: string | null): number | undefined {
+  const text = value?.trim();
+  if (!text) return undefined;
+  if (/^\d+$/.test(text)) {
+    const seconds = Number(text);
+    return Number.isSafeInteger(seconds) ? seconds : undefined;
+  }
+  // Accept the HTTP-date formats from RFC 9110, not Date.parse's permissive
+  // numeric/calendar inputs. The obsolete asctime form has implicit UTC.
+  const zonedDate =
+    /^(?:[a-z]{3}, \d{2} [a-z]{3} \d{4}|[a-z]+, \d{2}-[a-z]{3}-\d{2}) \d{2}:\d{2}:\d{2} GMT$/i;
+  const asctimeDate = /^[a-z]{3} [a-z]{3} (?: \d|\d{2}) \d{2}:\d{2}:\d{2} \d{4}$/i;
+  if (!zonedDate.test(text) && !asctimeDate.test(text)) return undefined;
+  const date = Date.parse(asctimeDate.test(text) ? `${text} GMT` : text);
+  return Number.isFinite(date) ? Math.max(0, Math.ceil((date - Date.now()) / 1000)) : undefined;
+}
+
 // A retryable failure that leaves a write's result unknown: the request may
 // have reached the registrar. A rate limit is an explicit rejection, and a
 // connection error known to precede sending never reached it.

package/src/registrars/dynadot.ts

@@ -216,6 +216,9 @@ export class DynadotRegistrar extends BaseRegistrar {
           sandbox: 'https://api-sandbox.dynadot.com',
         }),
         headers: { Authorization: `Bearer ${credentials.apiKey}` },
+        // HTTP 429 can omit Retry-After. Avoid exhausting all attempts inside
+        // Dynadot's regular-tier minute window in that case.
+        rateLimitFallbackSeconds: 60,
       },
       options
     );

package/src/registrars/namecheap.ts

@@ -60,6 +60,7 @@ interface NcCheckEl {
   '@_Available'?: string;
   '@_IsPremiumName'?: string;
   '@_PremiumRegistrationPrice'?: string;
+  '@_PremiumRenewalPrice'?: string;
 }
 
 // a contact group in namecheap.domains.getContacts (children are text elements)
@@ -367,9 +368,10 @@ export class NamecheapRegistrar extends BaseRegistrar {
 
   /**
    * Availability via domains.check (batched at 50 per request, Namecheap's cap).
-   * The check response only carries a price for *premium* names
-   * (`PremiumRegistrationPrice`); regular registration pricing comes from
-   * `getPricing`, so `price` is set only for premium results.
+   * The check response only carries prices for *premium* names
+   * (`PremiumRegistrationPrice`, `PremiumRenewalPrice`); regular pricing comes
+   * from `getPricing`, so `price` and `renewalPrice` are set only for premium
+   * results.
    */
   override async checkAvailability(
     domainNames: string[],
@@ -385,12 +387,16 @@ export class NamecheapRegistrar extends BaseRegistrar {
       );
       for (const el of ensureArray(cr.DomainCheckResult)) {
         const premium = el['@_IsPremiumName'] === 'true';
-        const premiumPrice = premium ? Number(el['@_PremiumRegistrationPrice']) : NaN;
+        const premiumPrice = (attr: string | undefined) => {
+          const n = premium ? Number(attr) : NaN;
+          return Number.isFinite(n) && n > 0 ? n : undefined;
+        };
         results.push({
           domainName: el['@_Domain'] ?? '',
           available: el['@_Available'] === 'true',
           premium,
-          price: Number.isFinite(premiumPrice) && premiumPrice > 0 ? premiumPrice : undefined,
+          price: premiumPrice(el['@_PremiumRegistrationPrice']),
+          renewalPrice: premiumPrice(el['@_PremiumRenewalPrice']),
         });
       }
     }

package/src/registrars/namecom.ts

@@ -108,18 +108,14 @@ class NamecomHttpClient extends HttpClient {
       }),
       url
     );
-    if (error instanceof RateLimitError) {
-      const retryAfter = response.headers.get('retry-after');
-      const seconds = retryAfter == null ? NaN : Number(retryAfter);
-      const date = retryAfter == null ? NaN : Date.parse(retryAfter);
-      const reset = response.headers.get('x-ratelimit-reset');
-      error.retryAfter = Number.isFinite(seconds)
-        ? Math.max(0, seconds)
-        : Number.isFinite(date)
-          ? Math.max(0, (date - Date.now()) / 1000)
-          : reset != null && Number.isFinite(Number(reset))
-            ? Math.max(0, Number(reset) - Date.now() / 1000)
-            : undefined;
+    // The shared client has already read Retry-After. Without a usable one,
+    // fall back to X-RateLimit-Reset (Unix seconds); otherwise leave it unset
+    // so the configured backoff applies.
+    if (error instanceof RateLimitError && error.retryAfter === undefined) {
+      const reset = response.headers.get('x-ratelimit-reset')?.trim();
+      if (reset && /^\d+(?:\.\d+)?$/.test(reset)) {
+        error.retryAfter = Math.max(0, Math.ceil(Number(reset) - Date.now() / 1000));
+      }
     }
     return error;
   }

package/src/types.ts

@@ -194,6 +194,9 @@ export interface DomainAvailability {
   premium?: boolean;
   // registration price in major currency units (e.g. 11.99), when the API reports it
   price?: number;
+  // annual renewal price in major currency units, when the API reports one for
+  // this specific name (e.g. a premium name's renewal)
+  renewalPrice?: number;
   // ISO 4217 currency code, e.g. "USD"
   currency?: string;
   // the registration period the price covers, in years