rdapper 0.7.0 → 0.9.1

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { parse } from "tldts";
+
 //#region src/types.d.ts
 type LookupSource = "rdap" | "whois";
 interface RegistrarInfo {
@@ -125,11 +127,23 @@ interface LookupResult {
 type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 //#endregion
 //#region src/lib/domain.d.ts
+type ParseOptions = Parameters<typeof parse>[1];
+/**
+ * Parse a domain into its parts. Accepts options which are passed to tldts.parse().
+ * @see https://github.com/remusao/tldts/blob/master/packages/tldts-core/src/options.ts
+ */
+declare function getDomainParts(domain: string, opts?: ParseOptions): ReturnType<typeof parse>;
+/** Get the TLD (ICANN-only public suffix) of a domain. */
+declare function getDomainTld(domain: string, opts?: ParseOptions): string | null;
+/**
+ * Basic domain validity check (hostname-like), not performing DNS or RDAP.
+ */
+declare function isLikelyDomain(value: string): boolean;
 /**
  * Normalize arbitrary input (domain or URL) to its registrable domain (eTLD+1).
  * Returns null when the input is not a valid ICANN domain (e.g., invalid TLD, IPs).
  */
-declare function toRegistrableDomain(input: string): string | null;
+declare function toRegistrableDomain(input: string, opts?: ParseOptions): string | null;
 //#endregion
 //#region src/index.d.ts
 /**
@@ -144,4 +158,4 @@ declare function isAvailable(domain: string, opts?: LookupOptions): Promise<bool
  * Performs a lookup and resolves to a boolean. Rejects on lookup error. */
 declare function isRegistered(domain: string, opts?: LookupOptions): Promise<boolean>;
 //#endregion
-export { Contact, DomainRecord, FetchLike, LookupOptions, LookupResult, LookupSource, Nameserver, RegistrarInfo, StatusEvent, isAvailable, isRegistered, lookupDomain, toRegistrableDomain };
+export { Contact, DomainRecord, FetchLike, LookupOptions, LookupResult, LookupSource, Nameserver, RegistrarInfo, StatusEvent, getDomainParts, getDomainTld, isAvailable, isLikelyDomain, isRegistered, lookupDomain, toRegistrableDomain };

package/dist/index.js

@@ -2,10 +2,18 @@ import { parse } from "tldts";
 
 //#region src/lib/domain.ts
 /**
-* Parse a domain into its parts.
+* Parse a domain into its parts. Accepts options which are passed to tldts.parse().
+* @see https://github.com/remusao/tldts/blob/master/packages/tldts-core/src/options.ts
 */
-function getDomainParts(domain) {
-	return parse(domain);
+function getDomainParts(domain, opts) {
+	return parse(domain, { ...opts });
+}
+/** Get the TLD (ICANN-only public suffix) of a domain. */
+function getDomainTld(domain, opts) {
+	return getDomainParts(domain, {
+		allowPrivateDomains: false,
+		...opts
+	}).publicSuffix ?? null;
 }
 /**
 * Basic domain validity check (hostname-like), not performing DNS or RDAP.
@@ -18,10 +26,13 @@ function isLikelyDomain(value) {
 * Normalize arbitrary input (domain or URL) to its registrable domain (eTLD+1).
 * Returns null when the input is not a valid ICANN domain (e.g., invalid TLD, IPs).
 */
-function toRegistrableDomain(input) {
+function toRegistrableDomain(input, opts) {
 	const raw = (input ?? "").trim();
 	if (raw === "") return null;
-	const result = parse(raw);
+	const result = getDomainParts(raw, {
+		allowPrivateDomains: false,
+		...opts
+	});
 	if (result.isIp) return null;
 	if (!result.isIcann) return null;
 	const domain = result.domain ?? "";
@@ -37,7 +48,12 @@ const WHOIS_AVAILABLE_PATTERNS = [
 	/\bdomain\s+available\b/i,
 	/\bdomain status[:\s]+available\b/i,
 	/\bobject does not exist\b/i,
-	/\bthe queried object does not exist\b/i
+	/\bthe queried object does not exist\b/i,
+	/\bstatus:\s*free\b/i,
+	/\bstatus:\s*available\b/i,
+	/\bno object found\b/i,
+	/\bnicht gefunden\b/i,
+	/\bpending release\b/i
 ];
 function isWhoisAvailable(text) {
 	if (!text) return false;
@@ -79,9 +95,9 @@ async function getRdapBaseUrlsForTld(tld, options) {
 	const target = tld.toLowerCase();
 	const bases = [];
 	for (const svc of data.services) {
-		const tlds = svc[0];
+		const tlds = svc[0].map((x) => x.toLowerCase());
 		const urls = svc[1];
-		if (tlds.map((x) => x.toLowerCase()).includes(target)) for (const u of urls) {
+		if (tlds.includes(target)) for (const u of urls) {
 			const base = u.endsWith("/") ? u : `${u}/`;
 			bases.push(base);
 		}
@@ -106,10 +122,9 @@ async function fetchRdapDomain(domain, baseUrl, options) {
 		const bodyText = await res.text();
 		throw new Error(`RDAP ${res.status}: ${bodyText.slice(0, 500)}`);
 	}
-	const json = await res.json();
 	return {
 		url,
-		json
+		json: await res.json()
 	};
 }
 
@@ -210,10 +225,9 @@ async function fetchRdapUrl(url, options) {
 		const bodyText = await res.text();
 		throw new Error(`RDAP ${res.status}: ${bodyText.slice(0, 500)}`);
 	}
-	const json = await res.json();
 	return {
 		url,
-		json
+		json: await res.json()
 	};
 }
 function toArray(val) {
@@ -553,12 +567,9 @@ function parseVcard(vcardArray) {
 */
 async function whoisQuery(server, query, options) {
 	const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	const port = 43;
-	const host = server.replace(/^whois:\/\//i, "");
-	const text = await withTimeout(queryTcp(host, port, query, options), timeoutMs, "WHOIS timeout");
 	return {
 		serverQueried: server,
-		text
+		text: await withTimeout(queryTcp(server.replace(/^whois:\/\//i, ""), 43, query, options), timeoutMs, "WHOIS timeout")
 	};
 }
 async function queryTcp(host, port, query, options) {
@@ -743,6 +754,89 @@ function normalizeServer(server) {
 	return server.replace(/^whois:\/\//i, "").replace(/\/$/, "");
 }
 
+//#endregion
+//#region src/whois/merge.ts
+function dedupeStatuses(a, b) {
+	const list = [...a || [], ...b || []];
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const s of list) {
+		const key = (s?.status || "").toLowerCase();
+		if (!key || seen.has(key)) continue;
+		seen.add(key);
+		out.push(s);
+	}
+	return out.length ? out : void 0;
+}
+function dedupeNameservers(a, b) {
+	const map = /* @__PURE__ */ new Map();
+	for (const ns of [...a || [], ...b || []]) {
+		const host = ns.host.toLowerCase();
+		const prev = map.get(host);
+		if (!prev) {
+			map.set(host, {
+				...ns,
+				host
+			});
+			continue;
+		}
+		const ipv4 = uniq([...prev.ipv4 || [], ...ns.ipv4 || []]);
+		const ipv6 = uniq([...prev.ipv6 || [], ...ns.ipv6 || []]);
+		map.set(host, {
+			host,
+			ipv4,
+			ipv6
+		});
+	}
+	const out = Array.from(map.values());
+	return out.length ? out : void 0;
+}
+function dedupeContacts(a, b) {
+	const list = [...a || [], ...b || []];
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const c of list) {
+		const key = `${c.type}|${(c.organization || c.name || c.email || "").toString().toLowerCase()}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(c);
+	}
+	return out.length ? out : void 0;
+}
+/** Conservative merge: start with base; fill missing scalars; union arrays; prefer more informative dates. */
+function mergeWhoisRecords(base, others) {
+	const merged = { ...base };
+	for (const cur of others) {
+		merged.isRegistered = merged.isRegistered || cur.isRegistered;
+		merged.registry = merged.registry ?? cur.registry;
+		merged.registrar = merged.registrar ?? cur.registrar;
+		merged.reseller = merged.reseller ?? cur.reseller;
+		merged.statuses = dedupeStatuses(merged.statuses, cur.statuses);
+		merged.creationDate = preferEarliestIso(merged.creationDate, cur.creationDate);
+		merged.updatedDate = preferLatestIso(merged.updatedDate, cur.updatedDate);
+		merged.expirationDate = preferLatestIso(merged.expirationDate, cur.expirationDate);
+		merged.deletionDate = merged.deletionDate ?? cur.deletionDate;
+		merged.transferLock = Boolean(merged.transferLock || cur.transferLock);
+		merged.dnssec = merged.dnssec ?? cur.dnssec;
+		merged.nameservers = dedupeNameservers(merged.nameservers, cur.nameservers);
+		merged.contacts = dedupeContacts(merged.contacts, cur.contacts);
+		merged.privacyEnabled = merged.privacyEnabled ?? cur.privacyEnabled;
+		merged.whoisServer = cur.whoisServer ?? merged.whoisServer;
+		merged.rawWhois = cur.rawWhois ?? merged.rawWhois;
+	}
+	return merged;
+}
+function preferEarliestIso(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	return new Date(a) <= new Date(b) ? a : b;
+}
+function preferLatestIso(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	return new Date(a) >= new Date(b) ? a : b;
+}
+
 //#endregion
 //#region src/whois/normalize.ts
 /**
@@ -759,11 +853,13 @@ function normalizeWhois(domain, tld, whoisText, whoisServer, includeRaw = false)
 		"domain create date",
 		"created",
 		"registered",
+		"registration time",
 		"domain record activated"
 	]);
 	const updatedDate = anyValue(map, [
 		"updated date",
 		"last updated",
+		"last update",
 		"last modified",
 		"modified",
 		"domain record last updated"
@@ -773,6 +869,8 @@ function normalizeWhois(domain, tld, whoisText, whoisServer, includeRaw = false)
 		"registry expiration date",
 		"expiry date",
 		"expiration date",
+		"expire date",
+		"expiration time",
 		"registrar registration expiration date",
 		"registrar registration expiry date",
 		"registrar expiration date",
@@ -780,6 +878,7 @@ function normalizeWhois(domain, tld, whoisText, whoisServer, includeRaw = false)
 		"domain expires",
 		"paid-till",
 		"expires on",
+		"expires",
 		"renewal date"
 	]);
 	const registrar = (() => {
@@ -978,6 +1077,40 @@ async function followWhoisReferrals(initialServer, domain, opts) {
 	}
 	return current;
 }
+/**
+* Collect the WHOIS referral chain starting from the TLD server.
+* Always includes the initial TLD response; may include one or more registrar responses.
+* Stops on contradiction (registrar claims availability) or failures.
+*/
+async function collectWhoisReferralChain(initialServer, domain, opts) {
+	const results = [];
+	const maxHops = Math.max(0, opts?.maxWhoisReferralHops ?? 2);
+	const first = await whoisQuery(initialServer, domain, opts);
+	results.push(first);
+	if (opts?.followWhoisReferral === false || maxHops === 0) return results;
+	const visited = new Set([normalize(first.serverQueried)]);
+	let current = first;
+	let hops = 0;
+	while (hops < maxHops) {
+		const next = extractWhoisReferral(current.text);
+		if (!next) break;
+		const normalized = normalize(next);
+		if (visited.has(normalized)) break;
+		visited.add(normalized);
+		try {
+			const res = await whoisQuery(next, domain, opts);
+			const registeredBefore = !isWhoisAvailable(current.text);
+			const registeredAfter = !isWhoisAvailable(res.text);
+			if (registeredBefore && !registeredAfter) break;
+			results.push(res);
+			current = res;
+		} catch {
+			break;
+		}
+		hops += 1;
+	}
+	return results;
+}
 function normalize(server) {
 	return server.replace(/^whois:\/\//i, "").toLowerCase();
 }
@@ -1000,7 +1133,8 @@ async function lookupDomain(domain, opts) {
 			error: "Invalid TLD"
 		};
 		if (!opts?.whoisOnly) {
-			const bases = await getRdapBaseUrlsForTld(tld, opts);
+			let bases = await getRdapBaseUrlsForTld(tld, opts);
+			if (bases.length === 0 && tld.includes(".")) bases = await getRdapBaseUrlsForTld(tld.split(".").pop() ?? tld, opts);
 			const tried = [];
 			for (const base of bases) {
 				tried.push(base);
@@ -1022,16 +1156,23 @@ async function lookupDomain(domain, opts) {
 		if (!whoisServer) {
 			const ianaText = await getIanaWhoisTextForTld(tld, opts);
 			const regUrl = ianaText ? parseIanaRegistrationInfoUrl(ianaText) : void 0;
-			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}`
+				error: `No WHOIS server discovered for TLD '${tld}'. This registry may not publish public WHOIS over port 43.${regUrl ? ` See registration info at ${regUrl}.` : ""}`
+			};
+		}
+		const chain = await collectWhoisReferralChain(whoisServer, domain, opts);
+		if (chain.length === 0) {
+			const res = await followWhoisReferrals(whoisServer, domain, opts);
+			return {
+				ok: true,
+				record: normalizeWhois(domain, tld, res.text, res.serverQueried, !!opts?.includeRaw)
 			};
 		}
-		const res = await followWhoisReferrals(whoisServer, domain, opts);
+		const [first, ...rest] = chain.map((r) => normalizeWhois(domain, tld, r.text, r.serverQueried, !!opts?.includeRaw));
 		return {
 			ok: true,
-			record: normalizeWhois(domain, tld, res.text, res.serverQueried, !!opts?.includeRaw)
+			record: rest.length ? mergeWhoisRecords(first, rest) : first
 		};
 	} catch (err) {
 		return {
@@ -1056,4 +1197,4 @@ async function isRegistered(domain, opts) {
 }
 
 //#endregion
-export { isAvailable, isRegistered, lookupDomain, toRegistrableDomain };
+export { getDomainParts, getDomainTld, isAvailable, isLikelyDomain, isRegistered, lookupDomain, toRegistrableDomain };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rdapper",
-  "version": "0.7.0",
+  "version": "0.9.1",
   "license": "MIT",
   "description": "🎩 RDAP/WHOIS fetcher, parser, and normalizer for Node",
   "repository": {
@@ -22,12 +22,14 @@
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "bin": "./bin/cli.js",
+  "bin": {
+    "rdapper": "bin/cli.js"
+  },
   "exports": {
     ".": {
-      "default": "./dist/index.js",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "default": "./dist/index.js"
     }
   },
   "files": [
@@ -47,9 +49,9 @@
     "tldts": "7.0.17"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.2.5",
-    "@types/node": "24.7.2",
-    "tsdown": "0.15.6",
+    "@biomejs/biome": "2.2.6",
+    "@types/node": "24.9.0",
+    "tsdown": "0.15.9",
     "typescript": "5.9.3",
     "vitest": "^3.2.4"
   },