rdapify 0.2.3 → 0.3.1

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

@@ -0,0 +1,233 @@
+import { ParseError } from '../../shared/errors';
+const RFC7483_STANDARD_FIELDS = new Set([
+    'objectClassName', 'handle', 'ldhName', 'unicodeName', 'status', 'entities',
+    'events', 'links', 'remarks', 'nameservers', 'secureDNS', 'registrar',
+    'ipVersion', 'startAddress', 'endAddress', 'cidr0_cidrs', 'name', 'type',
+    'country', 'startAutnum', 'endAutnum', 'port43', 'publicIds', 'network',
+    'rdapConformance', 'notices', 'vcardArray', 'roles', 'ipAddresses',
+]);
+function extractExtensions(raw) {
+    const extensions = {};
+    let hasExtensions = false;
+    for (const key of Object.keys(raw)) {
+        if (!RFC7483_STANDARD_FIELDS.has(key)) {
+            extensions[key] = raw[key];
+            hasExtensions = true;
+        }
+    }
+    return hasExtensions ? extensions : undefined;
+}
+export class Normalizer {
+    normalize(raw, query, source, cached = false, includeRaw = false) {
+        const objectClass = raw.objectClassName;
+        if (!objectClass) {
+            throw new ParseError('Missing objectClassName in RDAP response', { raw });
+        }
+        switch (objectClass) {
+            case 'domain':
+                return this.normalizeDomain(raw, query, source, cached, includeRaw);
+            case 'ip network':
+                return this.normalizeIP(raw, query, source, cached, includeRaw);
+            case 'autnum':
+                return this.normalizeASN(raw, query, source, cached, includeRaw);
+            case 'nameserver':
+                return this.normalizeNameserver(raw, query, source, cached, includeRaw);
+            case 'entity':
+                return this.normalizeEntity(raw, query, source, cached, includeRaw);
+            default:
+                throw new ParseError(`Unsupported object class: ${objectClass}`, { objectClass, raw });
+        }
+    }
+    normalizeDomain(raw, query, source, cached, includeRaw) {
+        const response = {
+            query,
+            objectClass: 'domain',
+            handle: raw.handle,
+            ldhName: raw['ldhName'],
+            unicodeName: raw['unicodeName'],
+            status: raw['status'] || [],
+            nameservers: this.extractNameservers(raw),
+            entities: raw['entities'] || [],
+            events: this.normalizeEvents(raw['events'] || []),
+            registrar: this.extractRegistrar(raw),
+            links: raw['links'] || [],
+            remarks: raw['remarks'] || [],
+            extensions: extractExtensions(raw),
+            metadata: {
+                source,
+                timestamp: new Date().toISOString(),
+                cached,
+            },
+        };
+        if (includeRaw) {
+            response.raw = raw;
+        }
+        return response;
+    }
+    normalizeIP(raw, query, source, cached, includeRaw) {
+        const response = {
+            query,
+            objectClass: 'ip network',
+            handle: raw.handle,
+            startAddress: raw['startAddress'],
+            endAddress: raw['endAddress'],
+            ipVersion: raw['ipVersion'],
+            name: raw['name'],
+            type: raw['type'],
+            country: raw['country'],
+            status: raw['status'] || [],
+            entities: raw['entities'] || [],
+            events: this.normalizeEvents(raw['events'] || []),
+            links: raw['links'] || [],
+            remarks: raw['remarks'] || [],
+            extensions: extractExtensions(raw),
+            metadata: {
+                source,
+                timestamp: new Date().toISOString(),
+                cached,
+            },
+        };
+        if (includeRaw) {
+            response.raw = raw;
+        }
+        return response;
+    }
+    normalizeASN(raw, query, source, cached, includeRaw) {
+        const response = {
+            query,
+            objectClass: 'autnum',
+            handle: raw.handle,
+            startAutnum: raw['startAutnum'],
+            endAutnum: raw['endAutnum'],
+            name: raw['name'],
+            type: raw['type'],
+            country: raw['country'],
+            status: raw['status'] || [],
+            entities: raw['entities'] || [],
+            events: this.normalizeEvents(raw['events'] || []),
+            links: raw['links'] || [],
+            remarks: raw['remarks'] || [],
+            extensions: extractExtensions(raw),
+            metadata: {
+                source,
+                timestamp: new Date().toISOString(),
+                cached,
+            },
+        };
+        if (includeRaw) {
+            response.raw = raw;
+        }
+        return response;
+    }
+    normalizeNameserver(raw, query, source, cached, includeRaw) {
+        const ipAddresses = raw['ipAddresses'];
+        const response = {
+            query,
+            objectClass: 'nameserver',
+            handle: raw.handle,
+            ldhName: raw['ldhName'],
+            unicodeName: raw['unicodeName'],
+            status: raw['status'] || [],
+            ipAddresses: ipAddresses
+                ? {
+                    v4: ipAddresses.v4 || [],
+                    v6: ipAddresses.v6 || [],
+                }
+                : undefined,
+            entities: raw['entities'] || [],
+            events: this.normalizeEvents(raw['events'] || []),
+            links: raw['links'] || [],
+            remarks: raw['remarks'] || [],
+            extensions: extractExtensions(raw),
+            metadata: {
+                source,
+                timestamp: new Date().toISOString(),
+                cached,
+            },
+        };
+        if (includeRaw) {
+            response.raw = raw;
+        }
+        return response;
+    }
+    normalizeEntity(raw, query, source, cached, includeRaw) {
+        const response = {
+            query,
+            objectClass: 'entity',
+            handle: raw.handle,
+            vcardArray: raw['vcardArray'],
+            roles: raw['roles'] || [],
+            status: raw['status'] || [],
+            entities: raw['entities'] || [],
+            events: this.normalizeEvents(raw['events'] || []),
+            links: raw['links'] || [],
+            remarks: raw['remarks'] || [],
+            extensions: extractExtensions(raw),
+            metadata: {
+                source,
+                timestamp: new Date().toISOString(),
+                cached,
+            },
+        };
+        if (includeRaw) {
+            response.raw = raw;
+        }
+        return response;
+    }
+    extractNameservers(raw) {
+        const nameservers = raw['nameservers'];
+        if (!nameservers || !Array.isArray(nameservers)) {
+            return [];
+        }
+        return nameservers
+            .map((ns) => {
+            if (!ns || typeof ns !== 'object') {
+                return undefined;
+            }
+            return ns.ldhName || ns.unicodeName;
+        })
+            .filter((name) => name !== undefined && name !== '');
+    }
+    extractRegistrar(raw) {
+        const entities = raw['entities'];
+        if (!entities || !Array.isArray(entities)) {
+            return undefined;
+        }
+        const registrar = entities.find((entity) => entity && typeof entity === 'object' && entity.roles?.includes('registrar'));
+        if (!registrar) {
+            return undefined;
+        }
+        let name;
+        if (registrar.vcardArray && Array.isArray(registrar.vcardArray) && registrar.vcardArray.length >= 2) {
+            const vcard = registrar.vcardArray[1];
+            if (Array.isArray(vcard)) {
+                const fnField = vcard.find((field) => Array.isArray(field) && field[0] === 'fn');
+                if (fnField && Array.isArray(fnField) && fnField.length >= 4) {
+                    name = fnField[3];
+                }
+            }
+        }
+        let url;
+        if (registrar.links && Array.isArray(registrar.links)) {
+            const selfLink = registrar.links.find((link) => link && link.rel === 'self');
+            if (selfLink) {
+                url = selfLink.href;
+            }
+        }
+        return {
+            name,
+            handle: registrar.handle,
+            url,
+        };
+    }
+    normalizeEvents(events) {
+        if (!Array.isArray(events)) {
+            return [];
+        }
+        return events.map((event) => ({
+            type: (event.eventAction || event.type),
+            date: event.eventDate || event.date,
+            actor: event.eventActor || event.actor,
+        }));
+    }
+}

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

@@ -0,0 +1,82 @@
+export class ProxyManager {
+    constructor(options) {
+        this.protocol = options.protocol || 'http';
+        this.host = options.host;
+        this.port = options.port;
+        this.auth = options.auth;
+        this.timeout = options.timeout || 30000;
+        this.bypassList = new Set(options.bypassList || []);
+        this.validate();
+    }
+    validate() {
+        if (!this.host) {
+            throw new Error('Proxy host is required');
+        }
+        if (!this.port || this.port < 1 || this.port > 65535) {
+            throw new Error('Proxy port must be between 1 and 65535');
+        }
+        if (this.auth && (!this.auth.username || !this.auth.password)) {
+            throw new Error('Proxy auth requires both username and password');
+        }
+    }
+    getProxyUrl() {
+        let url = `${this.protocol}://`;
+        if (this.auth) {
+            url += `${encodeURIComponent(this.auth.username)}:${encodeURIComponent(this.auth.password)}@`;
+        }
+        url += `${this.host}:${this.port}`;
+        return url;
+    }
+    shouldBypass(url) {
+        try {
+            const urlObj = new URL(url);
+            const hostname = urlObj.hostname;
+            if (this.bypassList.has(hostname)) {
+                return true;
+            }
+            for (const pattern of this.bypassList) {
+                if (pattern.startsWith('*.')) {
+                    const domain = pattern.slice(2);
+                    if (hostname.endsWith(domain)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    getAgentConfig() {
+        const config = {
+            host: this.host,
+            port: this.port,
+            protocol: this.protocol,
+            timeout: this.timeout,
+        };
+        if (this.auth) {
+            config.auth = `${this.auth.username}:${this.auth.password}`;
+        }
+        return config;
+    }
+    getInfo() {
+        return {
+            protocol: this.protocol,
+            host: this.host,
+            port: this.port,
+            hasAuth: !!this.auth,
+            timeout: this.timeout,
+            bypassCount: this.bypassList.size,
+        };
+    }
+    addBypass(pattern) {
+        this.bypassList.add(pattern);
+    }
+    removeBypass(pattern) {
+        this.bypassList.delete(pattern);
+    }
+    getBypassList() {
+        return Array.from(this.bypassList);
+    }
+}

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

@@ -0,0 +1,102 @@
+import { RateLimitError } from '../../shared/errors';
+export class RateLimiter {
+    constructor(options = {}) {
+        this.enabled = options.enabled ?? false;
+        this.maxRequests = options.maxRequests || 100;
+        this.windowMs = options.windowMs || 60000;
+        this.requests = new Map();
+        if (this.enabled) {
+            this.cleanupInterval = setInterval(() => this.cleanup(), 60000);
+        }
+    }
+    async checkLimit(key = 'global') {
+        if (!this.enabled) {
+            return;
+        }
+        const now = Date.now();
+        const records = this.requests.get(key) || [];
+        const validRecords = records.filter((r) => now - r.timestamp < this.windowMs);
+        const totalRequests = validRecords.reduce((sum, r) => sum + r.count, 0);
+        if (totalRequests >= this.maxRequests) {
+            const oldestRecord = validRecords[0];
+            const retryAfter = oldestRecord
+                ? this.windowMs - (now - oldestRecord.timestamp)
+                : this.windowMs;
+            throw new RateLimitError(`Rate limit exceeded: ${totalRequests}/${this.maxRequests} requests in ${this.windowMs}ms`, {
+                key,
+                limit: this.maxRequests,
+                window: this.windowMs,
+                current: totalRequests,
+            }, retryAfter);
+        }
+        validRecords.push({ timestamp: now, count: 1 });
+        this.requests.set(key, validRecords);
+    }
+    getUsage(key = 'global') {
+        if (!this.enabled) {
+            return {
+                current: 0,
+                limit: this.maxRequests,
+                remaining: this.maxRequests,
+                resetAt: Date.now() + this.windowMs,
+            };
+        }
+        const now = Date.now();
+        const records = this.requests.get(key) || [];
+        const validRecords = records.filter((r) => now - r.timestamp < this.windowMs);
+        const current = validRecords.reduce((sum, r) => sum + r.count, 0);
+        const oldestRecord = validRecords[0];
+        return {
+            current,
+            limit: this.maxRequests,
+            remaining: Math.max(0, this.maxRequests - current),
+            resetAt: oldestRecord ? oldestRecord.timestamp + this.windowMs : now + this.windowMs,
+        };
+    }
+    reset(key = 'global') {
+        this.requests.delete(key);
+    }
+    resetAll() {
+        this.requests.clear();
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [key, records] of this.requests.entries()) {
+            const validRecords = records.filter((r) => now - r.timestamp < this.windowMs);
+            if (validRecords.length === 0) {
+                this.requests.delete(key);
+            }
+            else {
+                this.requests.set(key, validRecords);
+            }
+        }
+    }
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+        this.requests.clear();
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    getConfig() {
+        return { maxRequests: this.maxRequests, windowMs: this.windowMs };
+    }
+    getStats() {
+        const now = Date.now();
+        let totalRequests = 0;
+        for (const records of this.requests.values()) {
+            const validRecords = records.filter((r) => now - r.timestamp < this.windowMs);
+            totalRequests += validRecords.reduce((sum, r) => sum + r.count, 0);
+        }
+        return {
+            enabled: this.enabled,
+            maxRequests: this.maxRequests,
+            windowMs: this.windowMs,
+            activeKeys: this.requests.size,
+            totalRequests,
+        };
+    }
+}

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

@@ -0,0 +1,131 @@
+export class RetryStrategy {
+    constructor(options = {}) {
+        this.circuitState = 'closed';
+        this.failureCount = 0;
+        this.lastFailureTime = 0;
+        this.halfOpenAttempts = 0;
+        this.strategy = options.strategy || 'exponential-jitter';
+        this.maxAttempts = options.maxAttempts || 3;
+        this.initialDelay = options.initialDelay || 1000;
+        this.maxDelay = options.maxDelay || 30000;
+        this.factor = options.factor || 2;
+        this.jitter = options.jitter ?? true;
+        this.retryableErrors = new Set(options.retryableErrors || [
+            'ETIMEDOUT',
+            'ECONNRESET',
+            'ECONNREFUSED',
+            'ENOTFOUND',
+            'NetworkError',
+            'TimeoutError',
+        ]);
+        this.retryableStatusCodes = new Set(options.retryableStatusCodes || [500, 502, 503, 504, 429]);
+        const cb = options.circuitBreaker || {};
+        this.circuitBreakerEnabled = cb.enabled ?? false;
+        this.circuitBreakerThreshold = cb.threshold || 5;
+        this.circuitBreakerTimeout = cb.timeout || 60000;
+        this.halfOpenRequests = cb.halfOpenRequests || 1;
+    }
+    shouldRetry(context) {
+        if (this.circuitBreakerEnabled) {
+            this.updateCircuitState();
+            if (this.circuitState === 'open') {
+                return false;
+            }
+            if (this.circuitState === 'half-open') {
+                if (this.halfOpenAttempts >= this.halfOpenRequests) {
+                    return false;
+                }
+                this.halfOpenAttempts++;
+            }
+        }
+        if (context.attempt >= this.maxAttempts) {
+            return false;
+        }
+        const errorName = context.error.name;
+        const errorCode = context.error.code;
+        if (this.retryableErrors.has(errorName) || this.retryableErrors.has(errorCode)) {
+            return true;
+        }
+        if (context.statusCode && this.retryableStatusCodes.has(context.statusCode)) {
+            return true;
+        }
+        return false;
+    }
+    getDelay(attempt) {
+        let delay;
+        switch (this.strategy) {
+            case 'fixed':
+                delay = this.initialDelay;
+                break;
+            case 'linear':
+                delay = this.initialDelay * attempt;
+                break;
+            case 'exponential':
+            case 'exponential-jitter':
+                delay = Math.min(this.initialDelay * Math.pow(this.factor, attempt - 1), this.maxDelay);
+                break;
+            default:
+                delay = this.initialDelay;
+        }
+        if (this.jitter || this.strategy === 'exponential-jitter') {
+            const jitterAmount = delay * 0.1;
+            delay = delay + (Math.random() * jitterAmount * 2 - jitterAmount);
+        }
+        return Math.min(Math.max(delay, 0), this.maxDelay);
+    }
+    recordSuccess() {
+        if (this.circuitBreakerEnabled) {
+            if (this.circuitState === 'half-open') {
+                this.circuitState = 'closed';
+                this.failureCount = 0;
+                this.halfOpenAttempts = 0;
+            }
+            else if (this.circuitState === 'closed') {
+                this.failureCount = Math.max(0, this.failureCount - 1);
+            }
+        }
+    }
+    recordFailure() {
+        if (this.circuitBreakerEnabled) {
+            this.failureCount++;
+            this.lastFailureTime = Date.now();
+            if (this.circuitState === 'half-open') {
+                this.circuitState = 'open';
+                this.halfOpenAttempts = 0;
+            }
+            else if (this.circuitState === 'closed' &&
+                this.failureCount >= this.circuitBreakerThreshold) {
+                this.circuitState = 'open';
+            }
+        }
+    }
+    updateCircuitState() {
+        if (this.circuitState === 'open') {
+            const timeSinceLastFailure = Date.now() - this.lastFailureTime;
+            if (timeSinceLastFailure >= this.circuitBreakerTimeout) {
+                this.circuitState = 'half-open';
+                this.halfOpenAttempts = 0;
+            }
+        }
+    }
+    getCircuitState() {
+        if (this.circuitBreakerEnabled) {
+            this.updateCircuitState();
+            return this.circuitState;
+        }
+        return 'closed';
+    }
+    getStats() {
+        return {
+            circuitState: this.getCircuitState(),
+            failureCount: this.failureCount,
+            enabled: this.circuitBreakerEnabled,
+        };
+    }
+    reset() {
+        this.circuitState = 'closed';
+        this.failureCount = 0;
+        this.lastFailureTime = 0;
+        this.halfOpenAttempts = 0;
+    }
+}

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

@@ -0,0 +1,3 @@
+export { Fetcher } from './Fetcher';
+export { BootstrapDiscovery } from './BootstrapDiscovery';
+export { Normalizer } from './Normalizer';