rdapper 0.4.1 → 0.6.0

package/README.md

@@ -35,6 +35,16 @@ await isRegistered("example.com"); // => true
 await isAvailable("likely-unregistered-thing-320485230458.com"); // => false
 ```
 
+Normalize arbitrary input (domain or URL) to its registrable domain (eTLD+1):
+
+```ts
+import { toRegistrableDomain } from "rdapper";
+
+toRegistrableDomain("https://sub.example.co.uk/page"); // => "example.co.uk"
+toRegistrableDomain("spark-public.s3.amazonaws.com");   // => "amazonaws.com" (ICANN-only default)
+toRegistrableDomain("192.168.0.1");                      // => null
+```
+
 ## API
 
 - `lookupDomain(domain, options?) => Promise<LookupResult>`
@@ -43,6 +53,20 @@ await isAvailable("likely-unregistered-thing-320485230458.com"); // => false
 - `isRegistered(domain, options?) => Promise<boolean>`
 - `isAvailable(domain, options?) => Promise<boolean>`
 
+### Edge runtimes (e.g., Vercel Edge)
+
+WHOIS requires a raw TCP connection over port 43 via `node:net`, which is not available on edge runtimes. This package lazily loads `node:net` only when the WHOIS code path runs. To use rdapper safely on edge:
+
+- Prefer RDAP only:
+
+```ts
+import { lookupDomain } from "rdapper";
+
+const res = await lookupDomain("example.com", { rdapOnly: true });
+```
+
+- If `rdapOnly` is omitted and the code path reaches WHOIS on edge, rdapper throws a clear runtime error indicating WHOIS is unsupported on edge and to run in Node or set `rdapOnly: true`.
+
 ### Options
 
 - `timeoutMs?: number` – Total timeout budget per network operation (default `15000`).
@@ -181,6 +205,7 @@ Project layout:
 - Some TLDs provide no RDAP service; `rdapOnly: true` will fail for them.
 - Registries may throttle or block WHOIS; respect rate limits and usage policies.
 - Field presence depends on source and privacy policies (e.g., redaction/withholding).
+- Public suffix detection uses `tldts` with ICANN‑only defaults (Private section is ignored). If you need behavior closer to `psl` that considers private suffixes, see the `allowPrivateDomains` option in the `tldts` docs (rdapper currently sticks to ICANN‑only by default). See: [tldts migration notes](https://github.com/remusao/tldts#migrating-from-other-libraries).
 
 ## License
 

package/dist/index.d.ts

@@ -124,6 +124,13 @@ interface LookupResult {
 }
 type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 //#endregion
+//#region src/lib/domain.d.ts
+/**
+ * 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;
+//#endregion
 //#region src/index.d.ts
 /**
  * High-level lookup that prefers RDAP and falls back to WHOIS.
@@ -137,4 +144,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 };
+export { Contact, DomainRecord, FetchLike, LookupOptions, LookupResult, LookupSource, Nameserver, RegistrarInfo, StatusEvent, isAvailable, isRegistered, lookupDomain, toRegistrableDomain };

package/dist/index.js

@@ -1,26 +1,32 @@
-import psl from "psl";
-import { createConnection } from "node:net";
+import { parse } from "tldts";
 
 //#region src/lib/domain.ts
+/**
+* Parse a domain into its parts.
+*/
 function getDomainParts(domain) {
-	const lower = domain.toLowerCase().trim();
-	let publicSuffix;
-	try {
-		publicSuffix = (psl.parse?.(lower))?.tld;
-	} catch {}
-	if (!publicSuffix) {
-		const parts = lower.split(".").filter(Boolean);
-		publicSuffix = parts.length ? parts[parts.length - 1] : lower;
-	}
-	const labels = publicSuffix.split(".").filter(Boolean);
-	const tld = labels.length ? labels[labels.length - 1] : publicSuffix;
-	return {
-		publicSuffix,
-		tld
-	};
+	return parse(domain);
 }
-function isLikelyDomain(input) {
-	return /^[a-z0-9.-]+$/i.test(input) && input.includes(".");
+/**
+* Basic domain validity check (hostname-like), not performing DNS or RDAP.
+*/
+function isLikelyDomain(value) {
+	const v = (value ?? "").trim();
+	return /^(?=.{1,253}$)(?:(?!-)[a-z0-9-]{1,63}(?<!-)\.)+(?!-)[a-z0-9-]{2,63}(?<!-)$/.test(v.toLowerCase());
+}
+/**
+* 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) {
+	const raw = (input ?? "").trim();
+	if (raw === "") return null;
+	const result = parse(raw);
+	if (result.isIp) return null;
+	if (!result.isIcann) return null;
+	const domain = result.domain ?? "";
+	if (domain === "") return null;
+	return domain.toLowerCase();
 }
 const WHOIS_AVAILABLE_PATTERNS = [
 	/\bno match\b/i,
@@ -555,9 +561,16 @@ async function whoisQuery(server, query, options) {
 		text
 	};
 }
-function queryTcp(host, port, query, options) {
+async function queryTcp(host, port, query, options) {
+	let net;
+	try {
+		net = await import("net");
+	} catch {
+		net = null;
+	}
+	if (!net?.createConnection) throw new Error("WHOIS client is only available in Node.js runtimes; try setting `rdapOnly: true`.");
 	return new Promise((resolve, reject) => {
-		const socket = createConnection({
+		const socket = net.createConnection({
 			host,
 			port
 		});
@@ -977,7 +990,11 @@ async function lookupDomain(domain, opts) {
 			ok: false,
 			error: "Input does not look like a domain"
 		};
-		const { publicSuffix, tld } = getDomainParts(domain);
+		const { publicSuffix: tld } = getDomainParts(domain);
+		if (!tld) return {
+			ok: false,
+			error: "Invalid TLD"
+		};
 		if (!opts?.whoisOnly) {
 			const bases = await getRdapBaseUrlsForTld(tld, opts);
 			const tried = [];
@@ -1008,19 +1025,6 @@ async function lookupDomain(domain, opts) {
 			};
 		}
 		const res = await followWhoisReferrals(whoisServer, domain, opts);
-		if (publicSuffix.includes(".") && /no match|not found/i.test(res.text) && opts?.followWhoisReferral !== false) {
-			const candidates = [];
-			const ps = publicSuffix.toLowerCase();
-			const exception = WHOIS_TLD_EXCEPTIONS[ps];
-			if (exception) candidates.push(exception);
-			for (const server of candidates) try {
-				const alt = await whoisQuery(server, domain, opts);
-				if (alt.text && !/error/i.test(alt.text)) return {
-					ok: true,
-					record: normalizeWhois(domain, tld, alt.text, alt.serverQueried, !!opts?.includeRaw)
-				};
-			} catch {}
-		}
 		return {
 			ok: true,
 			record: normalizeWhois(domain, tld, res.text, res.serverQueried, !!opts?.includeRaw)
@@ -1048,4 +1052,4 @@ async function isRegistered(domain, opts) {
 }
 
 //#endregion
-export { isAvailable, isRegistered, lookupDomain };
+export { isAvailable, isRegistered, lookupDomain, toRegistrableDomain };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rdapper",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "license": "MIT",
   "description": "🎩 RDAP/WHOIS fetcher, parser, and normalizer for Node",
   "repository": {
@@ -39,14 +39,13 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "psl": "1.15.0"
+    "tldts": "7.0.17"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.2.4",
-    "@types/node": "24.5.2",
-    "@types/psl": "1.1.3",
-    "tsdown": "0.15.5",
-    "typescript": "5.9.2",
+    "@biomejs/biome": "2.2.5",
+    "@types/node": "24.7.2",
+    "tsdown": "0.15.6",
+    "typescript": "5.9.3",
     "vitest": "^3.2.4"
   },
   "engines": {