rdapper 0.1.0 → 0.1.1

package/README.md

@@ -7,7 +7,7 @@ RDAP‑first domain registration lookups with WHOIS fallback. Produces a single,
 - Normalized output: registrar, contacts, nameservers, statuses, dates, DNSSEC, source metadata
 - TypeScript types included; ESM‑only; no external HTTP client (uses global `fetch`)
 
-Requirements: Node >= 18.17 (global `fetch`). WHOIS uses TCP port 43.
+### [🦉 See it in action on hoot.sh!](https://hoot.sh)
 
 ## Install
 
@@ -155,9 +155,11 @@ Timeouts are enforced per request using a simple race against `timeoutMs` (defau
 ## Development
 
 - Build: `npm run build`
-- Test: `npm test`
+- Test: `npm test` (Vitest)
   - By default, tests are offline/deterministic.
-  - Smoke tests that hit the network are gated by `SMOKE=1`, e.g. `SMOKE=1 npm test`.
+  - Watch mode: `npm run test:watch`
+  - Coverage: `npm run test:coverage`
+  - Smoke tests that hit the network are gated by `SMOKE=1`, e.g. `SMOKE=1 npm run test:smoke`.
 - Lint/format: `npm run lint` (Biome)
 
 Project layout:

package/dist/index.js

@@ -4,7 +4,7 @@ import { getRdapBaseUrlsForTld } from "./rdap/bootstrap.js";
 import { fetchRdapDomain } from "./rdap/client.js";
 import { normalizeRdap } from "./rdap/normalize.js";
 import { whoisQuery } from "./whois/client.js";
-import { extractWhoisReferral, ianaWhoisServerForTld, } from "./whois/discovery.js";
+import { extractWhoisReferral, ianaWhoisServerForTld, getIanaWhoisTextForTld, parseIanaRegistrationInfoUrl, } from "./whois/discovery.js";
 import { normalizeWhois } from "./whois/normalize.js";
 import { WHOIS_TLD_EXCEPTIONS } from "./whois/servers.js";
 /**
@@ -38,14 +38,25 @@ export async function lookupDomain(domain, opts) {
             if (opts?.rdapOnly) {
                 return {
                     ok: false,
-                    error: "RDAP not available or failed for this TLD",
+                    error: `RDAP not available or failed for TLD '${tld}'. Many TLDs do not publish RDAP; try WHOIS fallback (omit rdapOnly).`,
                 };
             }
         }
         // WHOIS fallback path
         const whoisServer = await ianaWhoisServerForTld(tld, opts);
         if (!whoisServer) {
-            return { ok: false, error: "No WHOIS server discovered for TLD" };
+            // Provide a clearer, actionable message
+            const ianaText = await getIanaWhoisTextForTld(tld, opts);
+            const regUrl = ianaText
+                ? parseIanaRegistrationInfoUrl(ianaText)
+                : undefined;
+            const hint = regUrl
+                ? ` See registration info at ${regUrl}.`
+                : "";
+            return {
+                ok: false,
+                error: `No WHOIS server discovered for TLD '${tld}'. This registry may not publish public WHOIS over port 43.${hint}`,
+            };
         }
         // Query the TLD server first; if it returns a referral, we follow it below.
         let res = await whoisQuery(whoisServer, domain, opts);

package/dist/whois/discovery.d.ts

@@ -1,4 +1,19 @@
 import type { LookupOptions } from "../types.js";
+/**
+ * Parse the IANA WHOIS response for a TLD and extract the WHOIS server
+ * without crossing line boundaries. Some TLDs (e.g. .np) leave the field
+ * blank, in which case this returns undefined.
+ */
+export declare function parseIanaWhoisServer(text: string): string | undefined;
+/**
+ * Parse a likely registration information URL from an IANA WHOIS response.
+ * Looks at lines like:
+ *   remarks: Registration information: http://example.tld
+ *   url: https://registry.example
+ */
+export declare function parseIanaRegistrationInfoUrl(text: string): string | undefined;
+/** Fetch raw IANA WHOIS text for a TLD (best-effort). */
+export declare function getIanaWhoisTextForTld(tld: string, options?: LookupOptions): Promise<string | undefined>;
 /**
  * Best-effort discovery of the authoritative WHOIS server for a TLD via IANA root DB.
  */

package/dist/whois/discovery.js

@@ -1,5 +1,57 @@
 import { whoisQuery } from "./client.js";
 import { WHOIS_TLD_EXCEPTIONS } from "./servers.js";
+/**
+ * Parse the IANA WHOIS response for a TLD and extract the WHOIS server
+ * without crossing line boundaries. Some TLDs (e.g. .np) leave the field
+ * blank, in which case this returns undefined.
+ */
+export function parseIanaWhoisServer(text) {
+    // Search lines in priority order: whois, refer, whois server
+    const fields = ["whois", "refer", "whois server"];
+    const lines = String(text).split(/\r?\n/);
+    for (const field of fields) {
+        for (const raw of lines) {
+            const line = raw.trimEnd();
+            // Match beginning of line, allowing leading spaces, case-insensitive
+            const re = new RegExp(`^\\s*${field}\\s*:\\s*(.*?)$`, "i");
+            const m = line.match(re);
+            if (m) {
+                const value = (m[1] || "").trim();
+                if (value)
+                    return value;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Parse a likely registration information URL from an IANA WHOIS response.
+ * Looks at lines like:
+ *   remarks: Registration information: http://example.tld
+ *   url: https://registry.example
+ */
+export function parseIanaRegistrationInfoUrl(text) {
+    const lines = String(text).split(/\r?\n/);
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!/^\s*(remarks|url|website)\s*:/i.test(line))
+            continue;
+        const urlMatch = line.match(/https?:\/\/\S+/i);
+        if (urlMatch?.[0])
+            return urlMatch[0];
+    }
+    return undefined;
+}
+/** Fetch raw IANA WHOIS text for a TLD (best-effort). */
+export async function getIanaWhoisTextForTld(tld, options) {
+    try {
+        const res = await whoisQuery("whois.iana.org", tld.toLowerCase(), options);
+        return res.text;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Best-effort discovery of the authoritative WHOIS server for a TLD via IANA root DB.
  */
@@ -13,10 +65,7 @@ export async function ianaWhoisServerForTld(tld, options) {
     try {
         const res = await whoisQuery("whois.iana.org", key, options);
         const txt = res.text;
-        const m = txt.match(/^whois:\s*(\S+)/im) ||
-            txt.match(/^refer:\s*(\S+)/im) ||
-            txt.match(/^whois server:\s*(\S+)/im);
-        const server = m?.[1];
+        const server = parseIanaWhoisServer(txt);
         if (server)
             return normalizeServer(server);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rdapper",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "MIT",
   "description": "🎩 RDAP/WHOIS fetcher, parser, and normalizer for Node",
   "repository": {
@@ -28,7 +28,10 @@
   "scripts": {
     "clean": "rm -rf dist",
     "build": "npm run clean && tsc -p tsconfig.build.json",
-    "test": "npm run clean && tsc -p tsconfig.json && node --test dist/**/*.test.js",
+    "test": "npm run clean && tsc -p tsconfig.json && vitest run",
+    "test:watch": "npm run clean && tsc -p tsconfig.json && vitest",
+    "test:coverage": "npm run clean && tsc -p tsconfig.json && vitest run --coverage",
+    "test:smoke": "SMOKE=1 npm run test",
     "lint": "biome check --write",
     "prepublishOnly": "npm run build"
   },
@@ -39,7 +42,9 @@
     "@biomejs/biome": "2.2.4",
     "@types/node": "24.5.2",
     "@types/psl": "1.1.3",
-    "typescript": "5.9.2"
+    "@vitest/coverage-v8": "^3.2.4",
+    "typescript": "5.9.2",
+    "vitest": "^3.2.4"
   },
   "engines": {
     "node": ">=18.17"