@aoxborrow/registrar-client 0.7.0 → 0.8.0

package/README.md

@@ -503,6 +503,12 @@ Requests retry with exponential backoff (`retries`, default 2). What may be
 re-sent depends on where the failure happened and on whether the call reads or
 writes, and is the same for every provider:
 
+HTTP 429 honors valid `Retry-After` delay-seconds and HTTP dates. Missing or
+invalid headers use the provider's fallback or the configured backoff: Dynadot
+waits a conservative 60 seconds, and Name.com waits until its
+`X-RateLimit-Reset` time. An explicit zero or past date remains
+an immediate retry instruction from the server.
+
 | Failure                                                                    | Read  | Write                                  |
 | -------------------------------------------------------------------------- | ----- | -------------------------------------- |
 | The registrar never saw it: DNS failure, connection refused, TLS handshake | Retry | Retry                                  |

package/dist/index.cjs

@@ -599,8 +599,8 @@ var HttpClient = class {
       case 404:
         return new NotFoundError(message);
       case 429: {
-        const retryAfter = Number(response.headers.get("retry-after"));
-        return new RateLimitError(message, Number.isFinite(retryAfter) ? retryAfter : void 0);
+        const retryAfter = parseRetryAfter(response.headers.get("retry-after")) ?? this.config.rateLimitFallbackSeconds;
+        return new RateLimitError(message, retryAfter);
       }
       default: {
         if (response.status >= 500) {
@@ -613,6 +613,19 @@ var HttpClient = class {
     }
   }
 };
+function parseRetryAfter(value) {
+  const text2 = value?.trim();
+  if (!text2) return void 0;
+  if (/^\d+$/.test(text2)) {
+    const seconds = Number(text2);
+    return Number.isSafeInteger(seconds) ? seconds : void 0;
+  }
+  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(text2) && !asctimeDate.test(text2)) return void 0;
+  const date = Date.parse(asctimeDate.test(text2) ? `${text2} GMT` : text2);
+  return Number.isFinite(date) ? Math.max(0, Math.ceil((date - Date.now()) / 1e3)) : void 0;
+}
 function isOutcomeUnknown(error) {
   if (error instanceof TimeoutError || error instanceof InvalidResponseError) return true;
   return error instanceof ConnectionError && !error.notSent;
@@ -1800,7 +1813,10 @@ var DynadotRegistrar = class extends BaseRegistrar {
           production: "https://api.dynadot.com",
           sandbox: "https://api-sandbox.dynadot.com"
         }),
-        headers: { Authorization: `Bearer ${credentials.apiKey}` }
+        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
     );
@@ -4741,9 +4757,10 @@ var NamecheapRegistrar = class 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.
    */
   async checkAvailability(domainNames, opts) {
     const results = [];
@@ -4756,12 +4773,16 @@ var NamecheapRegistrar = class extends BaseRegistrar {
       );
       for (const el of ensureArray(cr.DomainCheckResult)) {
         const premium = el["@_IsPremiumName"] === "true";
-        const premiumPrice = premium ? Number(el["@_PremiumRegistrationPrice"]) : NaN;
+        const premiumPrice = (attr) => {
+          const n = premium ? Number(attr) : NaN;
+          return Number.isFinite(n) && n > 0 ? n : void 0;
+        };
         results.push({
           domainName: el["@_Domain"] ?? "",
           available: el["@_Available"] === "true",
           premium,
-          price: Number.isFinite(premiumPrice) && premiumPrice > 0 ? premiumPrice : void 0
+          price: premiumPrice(el["@_PremiumRegistrationPrice"]),
+          renewalPrice: premiumPrice(el["@_PremiumRenewalPrice"])
         });
       }
     }
@@ -5169,12 +5190,11 @@ var NamecomHttpClient = class 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()) / 1e3) : reset != null && Number.isFinite(Number(reset)) ? Math.max(0, Number(reset) - Date.now() / 1e3) : void 0;
+    if (error instanceof RateLimitError && error.retryAfter === void 0) {
+      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() / 1e3));
+      }
     }
     return error;
   }