rdapify 0.3.0 → 0.3.1

package/dist/esm/infrastructure/cache/PersistentCache.js

@@ -0,0 +1,188 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export class PersistentCache {
+    constructor(options = {}) {
+        this.cache = new Map();
+        this.dirty = false;
+        this.storage = options.storage || 'memory';
+        this.ttl = options.ttl || 3600000;
+        this.maxSize = options.maxSize || 1000;
+        this.autoSave = options.autoSave ?? true;
+        if (this.storage === 'file') {
+            this.filePath = options.path || path.join(process.cwd(), '.cache', 'rdap-cache.json');
+            this.ensureCacheDirectory();
+            this.load();
+            if (this.autoSave) {
+                const interval = options.saveInterval || 60000;
+                this.saveTimer = setInterval(() => {
+                    if (this.dirty) {
+                        this.save();
+                    }
+                }, interval);
+            }
+        }
+    }
+    async get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return null;
+        }
+        if (Date.now() > entry.expires) {
+            this.cache.delete(key);
+            this.dirty = true;
+            return null;
+        }
+        entry.accessed = Date.now();
+        entry.hits++;
+        this.dirty = true;
+        return entry.value;
+    }
+    async set(key, value, ttl) {
+        const effectiveTtl = ttl || this.ttl;
+        const now = Date.now();
+        const entry = {
+            value,
+            expires: now + effectiveTtl,
+            created: now,
+            accessed: now,
+            hits: 0,
+        };
+        this.cache.set(key, entry);
+        this.dirty = true;
+        if (this.cache.size > this.maxSize) {
+            this.evictLRU();
+        }
+        if (this.storage === 'file' && !this.autoSave) {
+            await this.save();
+        }
+    }
+    async delete(key) {
+        const deleted = this.cache.delete(key);
+        if (deleted) {
+            this.dirty = true;
+        }
+        return deleted;
+    }
+    async has(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return false;
+        }
+        if (Date.now() > entry.expires) {
+            this.cache.delete(key);
+            this.dirty = true;
+            return false;
+        }
+        return true;
+    }
+    async clear() {
+        this.cache.clear();
+        this.dirty = true;
+        if (this.storage === 'file') {
+            await this.save();
+        }
+    }
+    async getStats() {
+        let totalHits = 0;
+        let oldestEntry;
+        let newestEntry;
+        for (const entry of this.cache.values()) {
+            totalHits += entry.hits;
+            if (!oldestEntry || entry.created < oldestEntry) {
+                oldestEntry = entry.created;
+            }
+            if (!newestEntry || entry.created > newestEntry) {
+                newestEntry = entry.created;
+            }
+        }
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            storage: this.storage,
+            hits: totalHits,
+            oldestEntry,
+            newestEntry,
+        };
+    }
+    evictLRU() {
+        let lruKey = null;
+        let lruTime = Infinity;
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.accessed < lruTime) {
+                lruTime = entry.accessed;
+                lruKey = key;
+            }
+        }
+        if (lruKey) {
+            this.cache.delete(lruKey);
+        }
+    }
+    ensureCacheDirectory() {
+        if (!this.filePath)
+            return;
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    load() {
+        if (!this.filePath || !fs.existsSync(this.filePath)) {
+            return;
+        }
+        try {
+            const data = fs.readFileSync(this.filePath, 'utf-8');
+            const entries = JSON.parse(data);
+            const now = Date.now();
+            for (const [key, entry] of Object.entries(entries)) {
+                const cacheEntry = entry;
+                if (cacheEntry.expires > now) {
+                    this.cache.set(key, cacheEntry);
+                }
+            }
+            this.dirty = false;
+        }
+        catch (error) {
+            console.warn('Failed to load cache:', error);
+        }
+    }
+    async save() {
+        if (!this.filePath)
+            return;
+        try {
+            const entries = {};
+            for (const [key, entry] of this.cache.entries()) {
+                entries[key] = entry;
+            }
+            const data = JSON.stringify(entries, null, 2);
+            fs.writeFileSync(this.filePath, data, 'utf-8');
+            this.dirty = false;
+        }
+        catch (error) {
+            console.error('Failed to save cache:', error);
+        }
+    }
+    async cleanup() {
+        const now = Date.now();
+        let removed = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.expires < now) {
+                this.cache.delete(key);
+                removed++;
+            }
+        }
+        if (removed > 0) {
+            this.dirty = true;
+        }
+        return removed;
+    }
+    destroy() {
+        if (this.saveTimer) {
+            clearInterval(this.saveTimer);
+            this.saveTimer = undefined;
+        }
+        if (this.storage === 'file' && this.dirty) {
+            this.save();
+        }
+        this.cache.clear();
+    }
+}

package/dist/esm/infrastructure/cache/RedisCache.js

@@ -0,0 +1,106 @@
+export class RedisCache {
+    constructor(client, options = {}) {
+        this.client = client;
+        this.keyPrefix = options.keyPrefix ?? 'rdapify:';
+        this.keyMaxLength = options.keyMaxLength ?? 200;
+    }
+    prefixed(key) {
+        const compressed = this.keyMaxLength > 0 && key.length > this.keyMaxLength
+            ? RedisCache.sha256Hex(key)
+            : key;
+        return `${this.keyPrefix}${compressed}`;
+    }
+    static sha256Hex(input) {
+        const crypto = require('crypto');
+        return crypto.createHash('sha256').update(input, 'utf8').digest('hex');
+    }
+    patternAll() {
+        return `${this.keyPrefix}*`;
+    }
+    async scanAll(pattern) {
+        if (typeof this.client.scan === 'function') {
+            const collected = [];
+            let cursor = '0';
+            do {
+                const [nextCursor, keys] = await this.client.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+                cursor = nextCursor;
+                collected.push(...keys);
+            } while (cursor !== '0');
+            return collected;
+        }
+        return this.client.keys(pattern);
+    }
+    async get(key) {
+        const raw = await this.client.get(this.prefixed(key));
+        if (raw === null) {
+            return null;
+        }
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    async set(key, value, ttl) {
+        const serialised = JSON.stringify(value);
+        const prefixedKey = this.prefixed(key);
+        if (ttl !== undefined && ttl > 0) {
+            await this.client.set(prefixedKey, serialised, { EX: ttl });
+        }
+        else {
+            await this.client.set(prefixedKey, serialised);
+        }
+    }
+    async delete(key) {
+        await this.client.del(this.prefixed(key));
+    }
+    async clear() {
+        const matchingKeys = await this.scanAll(this.patternAll());
+        if (matchingKeys.length > 0) {
+            await this.client.del(...matchingKeys);
+        }
+    }
+    async has(key) {
+        const count = await this.client.exists(this.prefixed(key));
+        return count > 0;
+    }
+    async size() {
+        const matchingKeys = await this.scanAll(this.patternAll());
+        return matchingKeys.length;
+    }
+    async getMany(keys) {
+        if (keys.length === 0)
+            return [];
+        const prefixedKeys = keys.map((k) => this.prefixed(k));
+        let raws;
+        const clientAsAny = this.client;
+        if (typeof clientAsAny['mget'] === 'function') {
+            const mget = clientAsAny['mget'];
+            raws = await mget(...prefixedKeys);
+        }
+        else {
+            raws = await Promise.all(prefixedKeys.map((k) => this.client.get(k)));
+        }
+        return raws.map((raw) => {
+            if (raw === null)
+                return null;
+            try {
+                return JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        });
+    }
+    async setMany(entries) {
+        await Promise.all(entries.map((e) => this.set(e.key, e.value, e.ttl)));
+    }
+    async getStats() {
+        return {
+            keyPrefix: this.keyPrefix,
+            size: await this.size(),
+            keyMaxLength: this.keyMaxLength,
+        };
+    }
+}

package/dist/esm/infrastructure/cache/StaleWhileRevalidateCache.js

@@ -0,0 +1,43 @@
+export class StaleWhileRevalidateCache {
+    constructor(maxSize = 1000, revalidateCallback) {
+        this.entries = new Map();
+        this.maxSize = maxSize;
+        this.revalidateCallback = revalidateCallback;
+    }
+    async get(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return null;
+        const isExpired = Date.now() > entry.expiresAt;
+        if (isExpired && this.revalidateCallback) {
+            Promise.resolve().then(() => {
+                this.revalidateCallback(key, entry.value);
+            }).catch(() => { });
+        }
+        return entry.value;
+    }
+    async set(key, value, ttl = 3600) {
+        if (this.entries.size >= this.maxSize && !this.entries.has(key)) {
+            this.evictOldest();
+        }
+        this.entries.set(key, { value, expiresAt: Date.now() + ttl * 1000 });
+    }
+    async delete(key) {
+        this.entries.delete(key);
+    }
+    async clear() {
+        this.entries.clear();
+    }
+    async has(key) {
+        return this.entries.has(key);
+    }
+    async size() {
+        return this.entries.size;
+    }
+    evictOldest() {
+        const firstKey = this.entries.keys().next().value;
+        if (firstKey !== undefined) {
+            this.entries.delete(firstKey);
+        }
+    }
+}

package/dist/esm/infrastructure/cache/index.js

@@ -0,0 +1,3 @@
+export { InMemoryCache } from './InMemoryCache';
+export { CacheManager } from './CacheManager';
+export { RedisCache } from './RedisCache';

package/dist/esm/infrastructure/http/AuthenticationManager.js

@@ -0,0 +1,94 @@
+export class AuthenticationManager {
+    constructor(options) {
+        this.type = options.type;
+        this.username = options.username;
+        this.password = options.password;
+        this.token = options.token;
+        this.apiKey = options.apiKey;
+        this.apiKeyHeader = options.apiKeyHeader || 'X-API-Key';
+        this.oauth2 = options.oauth2;
+        this.validate();
+    }
+    validate() {
+        switch (this.type) {
+            case 'basic':
+                if (!this.username || !this.password) {
+                    throw new Error('Basic auth requires username and password');
+                }
+                break;
+            case 'bearer':
+                if (!this.token) {
+                    throw new Error('Bearer auth requires token');
+                }
+                break;
+            case 'apikey':
+                if (!this.apiKey) {
+                    throw new Error('API key auth requires apiKey');
+                }
+                break;
+            case 'oauth2':
+                if (!this.oauth2?.accessToken) {
+                    throw new Error('OAuth2 requires accessToken');
+                }
+                break;
+        }
+    }
+    getHeaders() {
+        const headers = {};
+        switch (this.type) {
+            case 'basic':
+                if (this.username && this.password) {
+                    const credentials = Buffer.from(`${this.username}:${this.password}`).toString('base64');
+                    headers['Authorization'] = `Basic ${credentials}`;
+                }
+                break;
+            case 'bearer':
+                if (this.token) {
+                    headers['Authorization'] = `Bearer ${this.token}`;
+                }
+                break;
+            case 'apikey':
+                if (this.apiKey) {
+                    headers[this.apiKeyHeader] = this.apiKey;
+                }
+                break;
+            case 'oauth2':
+                if (this.oauth2?.accessToken) {
+                    const tokenType = this.oauth2.tokenType || 'Bearer';
+                    headers['Authorization'] = `${tokenType} ${this.oauth2.accessToken}`;
+                }
+                break;
+        }
+        return headers;
+    }
+    isTokenExpired() {
+        if (this.type !== 'oauth2' || !this.oauth2?.expiresAt) {
+            return false;
+        }
+        return Date.now() >= this.oauth2.expiresAt;
+    }
+    updateOAuth2Token(options) {
+        if (this.type !== 'oauth2') {
+            throw new Error('Cannot update OAuth2 token for non-OAuth2 auth');
+        }
+        this.oauth2 = options;
+    }
+    getType() {
+        return this.type;
+    }
+    getInfo() {
+        const info = {
+            type: this.type,
+        };
+        if (this.type === 'basic' && this.username) {
+            info.username = this.username;
+        }
+        if (this.type === 'apikey') {
+            info.apiKeyHeader = this.apiKeyHeader;
+        }
+        if (this.type === 'oauth2') {
+            info.tokenExpired = this.isTokenExpired();
+        }
+        return info;
+    }
+}

package/dist/esm/infrastructure/http/BootstrapDiscovery.js

@@ -0,0 +1,189 @@
+import * as ipaddr from 'ipaddr.js';
+import { NoServerFoundError, NetworkError } from '../../shared/errors';
+import { extractTLD } from '../../shared/utils/helpers';
+import { Fetcher } from './Fetcher';
+const REGIONAL_BOOTSTRAP_URLS = {
+    us: 'https://data.iana.org/rdap',
+    eu: 'https://data.iana.org/rdap',
+    ap: 'https://data.iana.org/rdap',
+};
+export class BootstrapDiscovery {
+    constructor(baseUrl = 'https://data.iana.org/rdap', fetcher, options) {
+        this.fetcher = fetcher || new Fetcher();
+        this.cache = new Map();
+        this.cacheExpiry = new Map();
+        this.cacheTTL = ((options?.ttl ?? 86400) * 1000);
+        this.fallback = options?.fallback ?? true;
+        this.customServersMap = new Map((options?.customServers ?? []).map(({ tld, url }) => [tld.toLowerCase(), url]));
+        const regionUrls = (options?.regions ?? [])
+            .map((r) => REGIONAL_BOOTSTRAP_URLS[r])
+            .filter((url) => Boolean(url));
+        const seen = new Set();
+        this.regionalUrls = [...regionUrls, baseUrl].filter((url) => {
+            if (seen.has(url))
+                return false;
+            seen.add(url);
+            return true;
+        });
+        void baseUrl;
+    }
+    async discoverDomain(domain) {
+        const tld = extractTLD(domain);
+        const tldKey = tld.toLowerCase();
+        const custom = this.customServersMap.get(tldKey);
+        if (custom)
+            return custom;
+        if (!this.fallback) {
+            throw new NoServerFoundError(`No RDAP server found for TLD: ${tld}`, { domain, tld });
+        }
+        const entries = await this.getBootstrapData('dns');
+        for (const entry of entries) {
+            if (entry.patterns.includes(tldKey)) {
+                if (entry.servers.length === 0 || !entry.servers[0]) {
+                    throw new NoServerFoundError(`No RDAP server found for TLD: ${tld}`, { domain, tld });
+                }
+                return entry.servers[0];
+            }
+        }
+        throw new NoServerFoundError(`No RDAP server found for domain: ${domain}`, { domain, tld });
+    }
+    async discoverIPv4(ip) {
+        const entries = await this.getBootstrapData('ipv4');
+        for (const entry of entries) {
+            for (const pattern of entry.patterns) {
+                if (this.ipMatchesCIDR(ip, pattern)) {
+                    if (entry.servers.length === 0 || !entry.servers[0]) {
+                        throw new NoServerFoundError(`No RDAP server found for IPv4: ${ip}`, { ip, pattern });
+                    }
+                    return entry.servers[0];
+                }
+            }
+        }
+        throw new NoServerFoundError(`No RDAP server found for IPv4: ${ip}`, { ip });
+    }
+    async discoverIPv6(ip) {
+        const entries = await this.getBootstrapData('ipv6');
+        for (const entry of entries) {
+            for (const pattern of entry.patterns) {
+                if (this.ipMatchesCIDR(ip, pattern)) {
+                    if (entry.servers.length === 0 || !entry.servers[0]) {
+                        throw new NoServerFoundError(`No RDAP server found for IPv6: ${ip}`, { ip, pattern });
+                    }
+                    return entry.servers[0];
+                }
+            }
+        }
+        throw new NoServerFoundError(`No RDAP server found for IPv6: ${ip}`, { ip });
+    }
+    async discoverNameserver(nameserver) {
+        const tld = extractTLD(nameserver);
+        const tldKey = tld.toLowerCase();
+        const custom = this.customServersMap.get(tldKey);
+        if (custom)
+            return custom;
+        if (!this.fallback) {
+            throw new NoServerFoundError(`No RDAP server found for nameserver TLD: ${tld}`, {
+                nameserver,
+                tld,
+            });
+        }
+        const entries = await this.getBootstrapData('dns');
+        for (const entry of entries) {
+            if (entry.patterns.includes(tldKey)) {
+                if (entry.servers.length === 0 || !entry.servers[0]) {
+                    throw new NoServerFoundError(`No RDAP server found for nameserver TLD: ${tld}`, {
+                        nameserver,
+                        tld,
+                    });
+                }
+                return entry.servers[0];
+            }
+        }
+        throw new NoServerFoundError(`No RDAP server found for nameserver: ${nameserver}`, {
+            nameserver,
+            tld,
+        });
+    }
+    async discoverASN(asn) {
+        const entries = await this.getBootstrapData('asn');
+        for (const entry of entries) {
+            for (const pattern of entry.patterns) {
+                const parts = pattern.split('-').map((n) => parseInt(n, 10));
+                const start = parts[0];
+                const end = parts[1];
+                if (start === undefined || end === undefined || isNaN(start) || isNaN(end)) {
+                    continue;
+                }
+                if (asn >= start && asn <= end) {
+                    if (entry.servers.length === 0 || !entry.servers[0]) {
+                        throw new NoServerFoundError(`No RDAP server found for ASN: ${asn}`, { asn, pattern });
+                    }
+                    return entry.servers[0];
+                }
+            }
+        }
+        throw new NoServerFoundError(`No RDAP server found for ASN: ${asn}`, { asn });
+    }
+    async getBootstrapData(type) {
+        const cached = this.cache.get(type);
+        const expiry = this.cacheExpiry.get(type);
+        if (cached && expiry && Date.now() < expiry) {
+            return cached;
+        }
+        let response;
+        let lastError;
+        let lastUrl = '';
+        for (const base of this.regionalUrls) {
+            const url = `${base}/${type}.json`;
+            lastUrl = url;
+            try {
+                response = await this.fetcher.fetch(url);
+                break;
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        if (response === undefined) {
+            throw new NetworkError(`Failed to fetch bootstrap data for ${type}`, undefined, {
+                type,
+                url: lastUrl,
+                originalError: lastError,
+            });
+        }
+        const bootstrapData = response;
+        if (!bootstrapData.services || !Array.isArray(bootstrapData.services)) {
+            throw new NetworkError(`Invalid bootstrap data format for ${type}`, undefined, { type, url: lastUrl });
+        }
+        const entries = bootstrapData.services.map((service) => ({
+            patterns: service[0],
+            servers: service[1],
+        }));
+        this.cache.set(type, entries);
+        this.cacheExpiry.set(type, Date.now() + this.cacheTTL);
+        return entries;
+    }
+    ipMatchesCIDR(ip, cidr) {
+        try {
+            if (!cidr.includes('/')) {
+                return ip === cidr;
+            }
+            const addr = ipaddr.process(ip);
+            const range = ipaddr.parseCIDR(cidr);
+            return addr.match(range);
+        }
+        catch {
+            return false;
+        }
+    }
+    clearCache() {
+        this.cache.clear();
+        this.cacheExpiry.clear();
+    }
+    getCacheStats() {
+        return {
+            size: this.cache.size,
+            types: Array.from(this.cache.keys()),
+        };
+    }
+}

package/dist/esm/infrastructure/http/BrowserFetcher.js

@@ -0,0 +1,42 @@
+import { NetworkError, RDAPServerError, TimeoutError, RDAPifyError } from '../../shared/errors';
+export class BrowserFetcher {
+    constructor(options) {
+        if (!options.proxyUrl) {
+            throw new Error('BrowserFetcher: proxyUrl is required');
+        }
+        this.proxyUrl = options.proxyUrl.replace(/\/$/, '');
+        this.timeout = options.timeout ?? 15000;
+        this.headers = options.headers ?? {};
+    }
+    async fetch(url) {
+        const proxiedUrl = `${this.proxyUrl}?url=${encodeURIComponent(url)}`;
+        try {
+            const response = await globalThis.fetch(proxiedUrl, {
+                method: 'GET',
+                headers: {
+                    Accept: 'application/rdap+json, application/json',
+                    ...this.headers,
+                },
+                signal: AbortSignal.timeout(this.timeout),
+            });
+            if (!response.ok) {
+                throw new RDAPServerError(`RDAP proxy returned ${response.status} for ${url}`, response.status, { url: proxiedUrl });
+            }
+            const data = (await response.json());
+            return data;
+        }
+        catch (err) {
+            if (err instanceof RDAPifyError)
+                throw err;
+            if (err instanceof DOMException && err.name === 'TimeoutError') {
+                throw new TimeoutError(`Browser proxy request timed out after ${this.timeout}ms`, {
+                    url: proxiedUrl,
+                });
+            }
+            throw new NetworkError(`BrowserFetcher: failed to fetch ${url} via proxy: ${err instanceof Error ? err.message : String(err)}`, undefined, { url: proxiedUrl, originalError: err });
+        }
+    }
+    getProxyUrl() {
+        return this.proxyUrl;
+    }
+}