rdapper 0.1.1 → 0.2.0

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "rdapper",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "license": "MIT",
   "description": "🎩 RDAP/WHOIS fetcher, parser, and normalizer for Node",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jakejarvis/rdapper.git"
   },
+  "bugs": {
+    "url": "https://github.com/jakejarvis/rdapper/issues"
+  },
   "author": {
     "name": "Jake Jarvis",
     "email": "jake@jarv.is",
@@ -14,6 +17,7 @@
   },
   "type": "module",
   "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
@@ -26,13 +30,12 @@
     "dist"
   ],
   "scripts": {
-    "clean": "rm -rf dist",
-    "build": "npm run clean && tsc -p tsconfig.build.json",
-    "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",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "lint": "biome check",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
@@ -42,7 +45,7 @@
     "@biomejs/biome": "2.2.4",
     "@types/node": "24.5.2",
     "@types/psl": "1.1.3",
-    "@vitest/coverage-v8": "^3.2.4",
+    "tsdown": "0.15.5",
     "typescript": "5.9.2",
     "vitest": "^3.2.4"
   },

package/dist/lib/async.d.ts

@@ -1,2 +0,0 @@
-export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, reason?: string): Promise<T>;
-export declare function sleep(ms: number): Promise<void>;

package/dist/lib/async.js

@@ -1,18 +0,0 @@
-export function withTimeout(promise, timeoutMs, reason = "Timeout") {
-    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
-        return promise;
-    let timer;
-    const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(reason)), timeoutMs);
-    });
-    return Promise.race([
-        promise.finally(() => {
-            if (timer !== undefined)
-                clearTimeout(timer);
-        }),
-        timeout,
-    ]);
-}
-export function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/dist/lib/constants.d.ts

@@ -1 +0,0 @@
-export declare const DEFAULT_TIMEOUT_MS = 15000;

package/dist/lib/constants.js

@@ -1 +0,0 @@
-export const DEFAULT_TIMEOUT_MS = 15000;

package/dist/lib/dates.d.ts

@@ -1 +0,0 @@
-export declare function toISO(dateLike: string | number | Date | undefined | null): string | undefined;

package/dist/lib/dates.js

@@ -1,84 +0,0 @@
-// Lightweight date parsing helpers to avoid external dependencies.
-// We aim to parse common RDAP and WHOIS date representations and return a UTC ISO string.
-export function toISO(dateLike) {
-    if (dateLike == null)
-        return undefined;
-    if (dateLike instanceof Date)
-        return toIsoFromDate(dateLike);
-    if (typeof dateLike === "number")
-        return toIsoFromDate(new Date(dateLike));
-    const raw = String(dateLike).trim();
-    if (!raw)
-        return undefined;
-    // Try several structured formats seen in WHOIS outputs (treat as UTC when no TZ provided)
-    const tryFormats = [
-        // 2023-01-02 03:04:05Z or without Z
-        /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})(?:Z)?$/,
-        // 2023/01/02 03:04:05
-        /^(\d{4})\/(\d{2})\/(\d{2})[ T](\d{2}):(\d{2}):(\d{2})$/,
-        // 02-Jan-2023
-        /^(\d{2})-([A-Za-z]{3})-(\d{4})$/,
-        // Jan 02 2023
-        /^([A-Za-z]{3})\s+(\d{1,2})\s+(\d{4})$/,
-    ];
-    for (const re of tryFormats) {
-        const m = raw.match(re);
-        if (!m)
-            continue;
-        const d = parseWithRegex(m, re);
-        if (d)
-            return toIsoFromDate(d);
-    }
-    // Fallback to native Date parsing (handles ISO and RFC2822 with TZ)
-    const native = new Date(raw);
-    if (!Number.isNaN(native.getTime()))
-        return toIsoFromDate(native);
-    return undefined;
-}
-function toIsoFromDate(d) {
-    try {
-        return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), 0))
-            .toISOString()
-            .replace(/\.\d{3}Z$/, "Z");
-    }
-    catch {
-        return undefined;
-    }
-}
-function parseWithRegex(m, _re) {
-    const monthMap = {
-        jan: 0,
-        feb: 1,
-        mar: 2,
-        apr: 3,
-        may: 4,
-        jun: 5,
-        jul: 6,
-        aug: 7,
-        sep: 8,
-        oct: 9,
-        nov: 10,
-        dec: 11,
-    };
-    try {
-        // If the matched string contains time components, parse as Y-M-D H:M:S
-        if (m[0].includes(":")) {
-            const [_, y, mo, d, hh, mm, ss] = m;
-            return new Date(Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(hh), Number(mm), Number(ss)));
-        }
-        // If the matched string contains hyphens, treat as DD-MMM-YYYY
-        if (m[0].includes("-")) {
-            const [_, dd, monStr, yyyy] = m;
-            const mon = monthMap[monStr.toLowerCase()];
-            return new Date(Date.UTC(Number(yyyy), mon, Number(dd)));
-        }
-        // Otherwise treat as MMM DD YYYY
-        const [_, monStr, dd, yyyy] = m;
-        const mon = monthMap[monStr.toLowerCase()];
-        return new Date(Date.UTC(Number(yyyy), mon, Number(dd)));
-    }
-    catch {
-        // fall through to undefined
-    }
-    return undefined;
-}

package/dist/lib/domain.d.ts

@@ -1,8 +0,0 @@
-export declare function extractTld(domain: string): string;
-export declare function getDomainParts(domain: string): {
-    publicSuffix: string;
-    tld: string;
-};
-export declare function isLikelyDomain(input: string): boolean;
-export declare function punyToUnicode(domain: string): string;
-export declare function isWhoisAvailable(text: string | undefined): boolean;

package/dist/lib/domain.js

@@ -1,64 +0,0 @@
-import psl from "psl";
-export function extractTld(domain) {
-    const lower = domain.trim().toLowerCase();
-    try {
-        const parsed = psl.parse?.(lower);
-        const suffix = parsed?.tld;
-        if (suffix) {
-            const labels = String(suffix).split(".").filter(Boolean);
-            if (labels.length)
-                return labels[labels.length - 1];
-        }
-    }
-    catch {
-        // ignore and fall back
-    }
-    const parts = lower.split(".").filter(Boolean);
-    return parts[parts.length - 1] ?? lower;
-}
-export function getDomainParts(domain) {
-    const lower = domain.toLowerCase().trim();
-    let publicSuffix;
-    try {
-        const parsed = psl.parse?.(lower);
-        publicSuffix = parsed?.tld;
-    }
-    catch {
-        // ignore
-    }
-    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 };
-}
-export function isLikelyDomain(input) {
-    return /^[a-z0-9.-]+$/i.test(input) && input.includes(".");
-}
-export function punyToUnicode(domain) {
-    try {
-        return domain.normalize("NFC");
-    }
-    catch {
-        return domain;
-    }
-}
-// Common WHOIS availability phrases seen across registries/registrars
-const WHOIS_AVAILABLE_PATTERNS = [
-    /\bno match\b/i,
-    /\bnot found\b/i,
-    /\bno entries found\b/i,
-    /\bno data found\b/i,
-    /\bavailable for registration\b/i,
-    /\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,
-];
-export function isWhoisAvailable(text) {
-    if (!text)
-        return false;
-    return WHOIS_AVAILABLE_PATTERNS.some((re) => re.test(text));
-}

package/dist/lib/text.d.ts

@@ -1,6 +0,0 @@
-export declare function uniq<T>(arr: T[] | undefined | null): T[] | undefined;
-export declare function parseKeyValueLines(text: string): Record<string, string[]>;
-export declare function parseCsv(value: string | undefined): string[] | undefined;
-export declare function asString(value: unknown): string | undefined;
-export declare function asStringArray(value: unknown): string[] | undefined;
-export declare function asDateLike(value: unknown): string | number | Date | undefined;

package/dist/lib/text.js

@@ -1,77 +0,0 @@
-export function uniq(arr) {
-    if (!arr)
-        return undefined;
-    return Array.from(new Set(arr));
-}
-export function parseKeyValueLines(text) {
-    const map = new Map();
-    const lines = text.split(/\r?\n/);
-    let lastKey;
-    for (const rawLine of lines) {
-        const line = rawLine.replace(/\s+$/, "");
-        if (!line.trim())
-            continue;
-        // Bracketed form: [Key] value  (common in .jp and some ccTLDs)
-        const bracket = line.match(/^\s*\[([^\]]+)\]\s*(.*)$/);
-        if (bracket) {
-            const key = bracket[1].trim().toLowerCase();
-            const value = bracket[2].trim();
-            const list = map.get(key) ?? [];
-            if (value)
-                list.push(value);
-            map.set(key, list);
-            lastKey = key;
-            continue;
-        }
-        // Colon form: Key: value
-        const idx = line.indexOf(":");
-        if (idx !== -1) {
-            const key = line.slice(0, idx).trim().toLowerCase();
-            const value = line.slice(idx + 1).trim();
-            if (!key) {
-                lastKey = undefined;
-                continue;
-            }
-            const list = map.get(key) ?? [];
-            if (value)
-                list.push(value);
-            map.set(key, list);
-            lastKey = key;
-            continue;
-        }
-        // Continuation line: starts with indentation after a key appeared
-        if (lastKey && /^\s+/.test(line)) {
-            const value = line.trim();
-            if (value) {
-                const list = map.get(lastKey) ?? [];
-                list.push(value);
-                map.set(lastKey, list);
-            }
-        }
-        // Otherwise ignore non key-value lines
-    }
-    return Object.fromEntries(map);
-}
-export function parseCsv(value) {
-    if (!value)
-        return undefined;
-    return value
-        .split(/[,\s]+/)
-        .map((s) => s.trim())
-        .filter(Boolean);
-}
-export function asString(value) {
-    return typeof value === "string" ? value : undefined;
-}
-export function asStringArray(value) {
-    return Array.isArray(value)
-        ? value.filter((x) => typeof x === "string")
-        : undefined;
-}
-export function asDateLike(value) {
-    if (typeof value === "string" ||
-        typeof value === "number" ||
-        value instanceof Date)
-        return value;
-    return undefined;
-}

package/dist/rdap/bootstrap.d.ts

@@ -1,6 +0,0 @@
-import type { LookupOptions } from "../types.js";
-/**
- * Resolve RDAP base URLs for a given TLD using IANA's bootstrap registry.
- * Returns zero or more base URLs (always suffixed with a trailing slash).
- */
-export declare function getRdapBaseUrlsForTld(tld: string, options?: LookupOptions): Promise<string[]>;

package/dist/rdap/bootstrap.js

@@ -1,30 +0,0 @@
-import { withTimeout } from "../lib/async.js";
-import { DEFAULT_TIMEOUT_MS } from "../lib/constants.js";
-/**
- * Resolve RDAP base URLs for a given TLD using IANA's bootstrap registry.
- * Returns zero or more base URLs (always suffixed with a trailing slash).
- */
-export async function getRdapBaseUrlsForTld(tld, options) {
-    const bootstrapUrl = options?.customBootstrapUrl ?? "https://data.iana.org/rdap/dns.json";
-    const res = await withTimeout(fetch(bootstrapUrl, {
-        method: "GET",
-        headers: { accept: "application/json" },
-        signal: options?.signal,
-    }), options?.timeoutMs ?? DEFAULT_TIMEOUT_MS, "RDAP bootstrap timeout");
-    if (!res.ok)
-        return [];
-    const data = (await res.json());
-    const target = tld.toLowerCase();
-    const bases = [];
-    for (const svc of data.services) {
-        const tlds = svc[0];
-        const urls = svc[1];
-        if (tlds.map((x) => x.toLowerCase()).includes(target)) {
-            for (const u of urls) {
-                const base = u.endsWith("/") ? u : `${u}/`;
-                bases.push(base);
-            }
-        }
-    }
-    return Array.from(new Set(bases));
-}

package/dist/rdap/client.d.ts

@@ -1,9 +0,0 @@
-import type { LookupOptions } from "../types.js";
-/**
- * Fetch RDAP JSON for a domain from a specific RDAP base URL.
- * Throws on HTTP >= 400 (includes RDAP error JSON payloads).
- */
-export declare function fetchRdapDomain(domain: string, baseUrl: string, options?: LookupOptions): Promise<{
-    url: string;
-    json: unknown;
-}>;

package/dist/rdap/client.js

@@ -1,21 +0,0 @@
-import { withTimeout } from "../lib/async.js";
-import { DEFAULT_TIMEOUT_MS } from "../lib/constants.js";
-// Use global fetch (Node 18+). For large JSON we keep it simple.
-/**
- * Fetch RDAP JSON for a domain from a specific RDAP base URL.
- * Throws on HTTP >= 400 (includes RDAP error JSON payloads).
- */
-export async function fetchRdapDomain(domain, baseUrl, options) {
-    const url = new URL(`domain/${encodeURIComponent(domain)}`, baseUrl).toString();
-    const res = await withTimeout(fetch(url, {
-        method: "GET",
-        headers: { accept: "application/rdap+json, application/json" },
-        signal: options?.signal,
-    }), options?.timeoutMs ?? DEFAULT_TIMEOUT_MS, "RDAP lookup timeout");
-    if (!res.ok) {
-        const bodyText = await res.text();
-        throw new Error(`RDAP ${res.status}: ${bodyText.slice(0, 500)}`);
-    }
-    const json = await res.json();
-    return { url, json };
-}

package/dist/rdap/normalize.d.ts

@@ -1,6 +0,0 @@
-import type { DomainRecord } from "../types.js";
-/**
- * Convert RDAP JSON into our normalized DomainRecord.
- * This function is defensive: RDAP servers vary in completeness and field naming.
- */
-export declare function normalizeRdap(inputDomain: string, tld: string, rdap: unknown, rdapServersTried: string[], fetchedAtISO: string, includeRaw?: boolean): DomainRecord;

package/dist/rdap/normalize.js

@@ -1,214 +0,0 @@
-import { toISO } from "../lib/dates.js";
-import { asDateLike, asString, asStringArray, uniq } from "../lib/text.js";
-/**
- * Convert RDAP JSON into our normalized DomainRecord.
- * This function is defensive: RDAP servers vary in completeness and field naming.
- */
-export function normalizeRdap(inputDomain, tld, rdap, rdapServersTried, fetchedAtISO, includeRaw = false) {
-    const doc = (rdap ?? {});
-    // Safe helpers for optional fields
-    const _get = (obj, path) => path.reduce((o, k) => o?.[k] ?? undefined, obj);
-    // Prefer ldhName (punycode) and unicodeName if provided
-    const ldhName = asString(doc.ldhName) || asString(doc.handle);
-    const unicodeName = asString(doc.unicodeName);
-    // Registrar entity can be provided with role "registrar"
-    const registrar = extractRegistrar(doc.entities);
-    // Nameservers: normalize host + IPs
-    const nameservers = Array.isArray(doc.nameservers)
-        ? doc.nameservers
-            .map((ns) => {
-            const host = (asString(ns.ldhName) ??
-                asString(ns.unicodeName) ??
-                "").toLowerCase();
-            const ip = ns.ipAddresses;
-            const ipv4 = asStringArray(ip?.v4);
-            const ipv6 = asStringArray(ip?.v6);
-            const n = { host };
-            if (ipv4?.length)
-                n.ipv4 = ipv4;
-            if (ipv6?.length)
-                n.ipv6 = ipv6;
-            return n;
-        })
-            .filter((n) => !!n.host)
-        : undefined;
-    // Contacts: RDAP entities include roles like registrant, administrative, technical, billing, abuse
-    const contacts = extractContacts(doc.entities);
-    // RDAP uses IANA EPP status values. Preserve raw plus a description if any remarks are present.
-    const statuses = Array.isArray(doc.status)
-        ? doc.status
-            .filter((s) => typeof s === "string")
-            .map((s) => ({ status: s, raw: s }))
-        : undefined;
-    // Secure DNS info
-    const secureDNS = doc.secureDNS;
-    const dnssec = secureDNS
-        ? {
-            enabled: !!secureDNS.delegationSigned,
-            dsRecords: Array.isArray(secureDNS.dsData)
-                ? secureDNS.dsData.map((d) => ({
-                    keyTag: d.keyTag,
-                    algorithm: d.algorithm,
-                    digestType: d.digestType,
-                    digest: d.digest,
-                }))
-                : undefined,
-        }
-        : undefined;
-    const events = Array.isArray(doc.events)
-        ? doc.events
-        : [];
-    const byAction = (action) => events.find((e) => typeof e?.eventAction === "string" &&
-        e.eventAction.toLowerCase().includes(action));
-    const creationDate = toISO(asDateLike(byAction("registration")?.eventDate) ??
-        asDateLike(doc.registrationDate));
-    const updatedDate = toISO(asDateLike(byAction("last changed")?.eventDate) ??
-        asDateLike(doc.lastChangedDate));
-    const expirationDate = toISO(asDateLike(byAction("expiration")?.eventDate) ??
-        asDateLike(doc.expirationDate));
-    const deletionDate = toISO(asDateLike(byAction("deletion")?.eventDate) ?? asDateLike(doc.deletionDate));
-    // Derive a simple transfer lock flag from statuses
-    const transferLock = !!statuses?.some((s) => /transferprohibited/i.test(s.status));
-    // The RDAP document may include "port43" pointer to authoritative WHOIS
-    const whoisServer = asString(doc.port43);
-    const record = {
-        domain: unicodeName || ldhName || inputDomain,
-        tld,
-        isRegistered: true,
-        isIDN: /(^|\.)xn--/i.test(ldhName || inputDomain),
-        unicodeName: unicodeName || undefined,
-        punycodeName: ldhName || undefined,
-        registry: undefined, // RDAP rarely includes a clean registry operator name
-        registrar: registrar,
-        reseller: undefined,
-        statuses: statuses,
-        creationDate,
-        updatedDate,
-        expirationDate,
-        deletionDate,
-        transferLock,
-        dnssec,
-        nameservers: nameservers
-            ? uniq(nameservers.map((n) => ({ ...n, host: n.host.toLowerCase() })))
-            : undefined,
-        contacts,
-        whoisServer,
-        rdapServers: rdapServersTried,
-        rawRdap: includeRaw ? rdap : undefined,
-        rawWhois: undefined,
-        source: "rdap",
-        fetchedAt: fetchedAtISO,
-        warnings: undefined,
-    };
-    return record;
-}
-function extractRegistrar(entities) {
-    if (!Array.isArray(entities))
-        return undefined;
-    for (const ent of entities) {
-        const roles = Array.isArray(ent?.roles)
-            ? ent.roles.filter((r) => typeof r === "string")
-            : [];
-        if (!roles.some((r) => /registrar/i.test(r)))
-            continue;
-        const v = parseVcard(ent?.vcardArray);
-        const ianaId = Array.isArray(ent?.publicIds)
-            ? ent.publicIds.find((id) => /iana\s*registrar\s*id/i.test(String(id?.type)))?.identifier
-            : undefined;
-        return {
-            name: v.fn || v.org || asString(ent?.handle) || undefined,
-            ianaId: asString(ianaId),
-            url: v.url ?? undefined,
-            email: v.email ?? undefined,
-            phone: v.tel ?? undefined,
-        };
-    }
-    return undefined;
-}
-function extractContacts(entities) {
-    if (!Array.isArray(entities))
-        return undefined;
-    const out = [];
-    for (const ent of entities) {
-        const roles = Array.isArray(ent?.roles)
-            ? ent.roles.filter((r) => typeof r === "string")
-            : [];
-        const v = parseVcard(ent?.vcardArray);
-        const type = roles.find((r) => /registrant|administrative|technical|billing|abuse|reseller/i.test(r));
-        if (!type)
-            continue;
-        const map = {
-            registrant: "registrant",
-            administrative: "admin",
-            technical: "tech",
-            billing: "billing",
-            abuse: "abuse",
-            reseller: "reseller",
-        };
-        const roleKey = (map[type.toLowerCase()] ?? "unknown");
-        out.push({
-            type: roleKey,
-            name: v.fn,
-            organization: v.org,
-            email: v.email,
-            phone: v.tel,
-            fax: v.fax,
-            street: v.street,
-            city: v.locality,
-            state: v.region,
-            postalCode: v.postcode,
-            country: v.country,
-            countryCode: v.countryCode,
-        });
-    }
-    return out.length ? out : undefined;
-}
-// Parse a minimal subset of vCard 4.0 arrays as used in RDAP "vcardArray" fields
-function parseVcard(vcardArray) {
-    // vcardArray is typically ["vcard", [["version",{} ,"text","4.0"], ["fn",{} ,"text","Example"], ...]]
-    if (!Array.isArray(vcardArray) ||
-        vcardArray[0] !== "vcard" ||
-        !Array.isArray(vcardArray[1]))
-        return {};
-    const entries = vcardArray[1];
-    const out = {};
-    for (const e of entries) {
-        const key = e?.[0];
-        const _valueType = e?.[2];
-        const value = e?.[3];
-        if (!key)
-            continue;
-        switch (String(key).toLowerCase()) {
-            case "fn":
-                out.fn = asString(value);
-                break;
-            case "org":
-                out.org = Array.isArray(value)
-                    ? value.map((x) => String(x)).join(" ")
-                    : asString(value);
-                break;
-            case "email":
-                out.email = asString(value);
-                break;
-            case "tel":
-                out.tel = asString(value);
-                break;
-            case "url":
-                out.url = asString(value);
-                break;
-            case "adr": {
-                // adr value is [postOfficeBox, extendedAddress, street, locality, region, postalCode, country]
-                if (Array.isArray(value)) {
-                    out.street = value[2] ? String(value[2]).split(/\n|,\s*/) : undefined;
-                    out.locality = asString(value[3]);
-                    out.region = asString(value[4]);
-                    out.postcode = asString(value[5]);
-                    out.country = asString(value[6]);
-                }
-                break;
-            }
-        }
-    }
-    // Best effort country code from country name (often omitted). Leaving undefined unless explicitly provided.
-    return out;
-}