rdapify 0.2.3 → 0.3.1

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

@@ -0,0 +1,46 @@
+import { NetworkError, RDAPServerError, TimeoutError, RDAPifyError } from '../../shared/errors';
+export class BunFetcher {
+    constructor(options = {}) {
+        this.timeout = options.timeout ?? 10000;
+        this.userAgent = options.userAgent ?? 'RDAPify/0.2.1 (Bun) (https://rdapify.com)';
+        this.headers = options.headers ?? {};
+        this.ssrfProtection = options.ssrfProtection;
+    }
+    async fetch(url) {
+        if (this.ssrfProtection) {
+            await this.ssrfProtection.validateUrl(url);
+        }
+        try {
+            const nativeFetch = BunFetcher.resolveFetch();
+            const response = await nativeFetch(url, {
+                method: 'GET',
+                headers: {
+                    'User-Agent': this.userAgent,
+                    Accept: 'application/rdap+json, application/json',
+                    ...this.headers,
+                },
+                signal: AbortSignal.timeout(this.timeout),
+            });
+            if (!response.ok) {
+                throw new RDAPServerError(`RDAP server returned ${response.status}`, response.status, { url });
+            }
+            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(`Request timed out after ${this.timeout}ms`, { url });
+            }
+            throw new NetworkError(`BunFetcher: failed to fetch ${url}: ${err instanceof Error ? err.message : String(err)}`, undefined, { url, originalError: err });
+        }
+    }
+    static resolveFetch() {
+        const bun = globalThis['Bun'];
+        if (bun && typeof bun['fetch'] === 'function') {
+            return bun['fetch'];
+        }
+        return globalThis.fetch;
+    }
+}

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

@@ -0,0 +1,98 @@
+export class CircuitOpenError extends Error {
+    constructor(state = 'open') {
+        super(`Circuit is ${state} — request rejected`);
+        this.state = state;
+        this.name = 'CircuitOpenError';
+    }
+}
+export class CircuitBreaker {
+    constructor(options = {}) {
+        this.state = 'closed';
+        this.failureCount = 0;
+        this.successCount = 0;
+        this.failureTimes = [];
+        this.failureThreshold = options.failureThreshold ?? 5;
+        this.successThreshold = options.successThreshold ?? 1;
+        this.halfOpenTimeout = options.halfOpenTimeout ?? 30000;
+        this.window = options.window ?? 60000;
+    }
+    getState() {
+        this.maybeTransitionToHalfOpen();
+        return this.state;
+    }
+    async execute(fn) {
+        this.maybeTransitionToHalfOpen();
+        if (this.state === 'open') {
+            throw new CircuitOpenError('open');
+        }
+        try {
+            const result = await fn();
+            this.onSuccess();
+            return result;
+        }
+        catch (err) {
+            this.onFailure();
+            throw err;
+        }
+    }
+    recordSuccess() {
+        this.onSuccess();
+    }
+    recordFailure() {
+        this.onFailure();
+    }
+    reset() {
+        this.state = 'closed';
+        this.failureCount = 0;
+        this.successCount = 0;
+        this.lastOpenedAt = undefined;
+        this.failureTimes = [];
+    }
+    maybeTransitionToHalfOpen() {
+        if (this.state === 'open' &&
+            this.lastOpenedAt !== undefined &&
+            Date.now() - this.lastOpenedAt >= this.halfOpenTimeout) {
+            this.state = 'half-open';
+            this.successCount = 0;
+            this.failureCount = 0;
+        }
+    }
+    onSuccess() {
+        if (this.state === 'half-open') {
+            this.successCount += 1;
+            if (this.successCount >= this.successThreshold) {
+                this.state = 'closed';
+                this.failureCount = 0;
+                this.successCount = 0;
+                this.failureTimes = [];
+                this.lastOpenedAt = undefined;
+            }
+        }
+        else if (this.state === 'closed') {
+            this.failureCount = 0;
+            this.failureTimes = [];
+        }
+    }
+    onFailure() {
+        const now = Date.now();
+        if (this.state === 'half-open') {
+            this.state = 'open';
+            this.lastOpenedAt = now;
+            this.successCount = 0;
+            return;
+        }
+        if (this.state === 'closed') {
+            this.failureTimes.push(now);
+            this.pruneOldFailures();
+            this.failureCount = this.failureTimes.length;
+            if (this.failureCount >= this.failureThreshold) {
+                this.state = 'open';
+                this.lastOpenedAt = now;
+            }
+        }
+    }
+    pruneOldFailures() {
+        const cutoff = Date.now() - this.window;
+        this.failureTimes = this.failureTimes.filter((t) => t > cutoff);
+    }
+}

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

@@ -0,0 +1,39 @@
+import { NetworkError, RDAPServerError, TimeoutError, RDAPifyError } from '../../shared/errors';
+export class CloudflareWorkersFetcher {
+    constructor(options = {}) {
+        this.timeout = options.timeout ?? 10000;
+        this.userAgent =
+            options.userAgent ?? 'RDAPify/0.2.2 (Cloudflare-Workers) (https://rdapify.com)';
+        this.headers = options.headers ?? {};
+        this.ssrfProtection = options.ssrfProtection;
+    }
+    async fetch(url) {
+        if (this.ssrfProtection) {
+            await this.ssrfProtection.validateUrl(url);
+        }
+        try {
+            const response = await globalThis.fetch(url, {
+                method: 'GET',
+                headers: {
+                    'User-Agent': this.userAgent,
+                    Accept: 'application/rdap+json, application/json',
+                    ...this.headers,
+                },
+                signal: AbortSignal.timeout(this.timeout),
+            });
+            if (!response.ok) {
+                throw new RDAPServerError(`RDAP server returned ${response.status}`, response.status, { url });
+            }
+            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(`Request timed out after ${this.timeout}ms`, { url });
+            }
+            throw new NetworkError(`CloudflareWorkersFetcher: failed to fetch ${url}: ${err instanceof Error ? err.message : String(err)}`, undefined, { url, originalError: err });
+        }
+    }
+}

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

@@ -0,0 +1,80 @@
+import * as zlib from 'zlib';
+import { promisify } from 'util';
+const gunzip = promisify(zlib.gunzip);
+const brotliDecompress = promisify(zlib.brotliDecompress);
+export class CompressionManager {
+    constructor(options = {}) {
+        this.enabled = options.enabled ?? true;
+        this.types = new Set(options.types || ['gzip', 'br']);
+        this.threshold = options.threshold || 1024;
+    }
+    getAcceptEncodingHeader() {
+        if (!this.enabled || this.types.size === 0) {
+            return undefined;
+        }
+        const encodings = [];
+        if (this.types.has('br')) {
+            encodings.push('br;q=1.0');
+        }
+        if (this.types.has('gzip')) {
+            encodings.push('gzip;q=0.9');
+        }
+        if (this.types.has('deflate')) {
+            encodings.push('deflate;q=0.8');
+        }
+        return encodings.length > 0 ? encodings.join(', ') : undefined;
+    }
+    async decompress(data, encoding) {
+        if (!encoding || !this.enabled) {
+            return data;
+        }
+        const normalizedEncoding = encoding.toLowerCase().trim();
+        try {
+            switch (normalizedEncoding) {
+                case 'gzip':
+                    return await gunzip(data);
+                case 'br':
+                    return await brotliDecompress(data);
+                case 'deflate':
+                    return await promisify(zlib.inflate)(data);
+                default:
+                    return data;
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to decompress ${encoding}:`, error);
+            return data;
+        }
+    }
+    shouldCompress(size) {
+        return this.enabled && size >= this.threshold;
+    }
+    getSupportedTypes() {
+        return Array.from(this.types);
+    }
+    isSupported(type) {
+        return this.types.has(type);
+    }
+    getInfo() {
+        return {
+            enabled: this.enabled,
+            types: this.getSupportedTypes(),
+            threshold: this.threshold,
+        };
+    }
+    estimateRatio(originalSize, compressedSize) {
+        if (originalSize === 0)
+            return 0;
+        return ((originalSize - compressedSize) / originalSize) * 100;
+    }
+    getStats(originalSize, compressedSize) {
+        const savedBytes = originalSize - compressedSize;
+        const savedPercentage = this.estimateRatio(originalSize, compressedSize);
+        return {
+            originalSize,
+            compressedSize,
+            savedBytes,
+            savedPercentage,
+        };
+    }
+}

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

@@ -0,0 +1,101 @@
+export class ConnectionPool {
+    constructor(options = {}) {
+        this.maxConnections = options.maxConnections || 10;
+        this.keepAlive = options.keepAlive ?? true;
+        this.maxIdleTime = options.maxIdleTime || 300000;
+        this.connections = new Map();
+        if (this.keepAlive) {
+            this.cleanupInterval = setInterval(() => this.cleanup(), 30000);
+        }
+    }
+    async acquire(host, timeout) {
+        const hostConnections = this.connections.get(host) || [];
+        const available = hostConnections.find((conn) => !conn.inUse);
+        if (available) {
+            available.inUse = true;
+            available.lastUsed = Date.now();
+            return available.id;
+        }
+        if (hostConnections.length < this.maxConnections) {
+            const connection = {
+                id: `${host}-${Date.now()}-${Math.random()}`,
+                inUse: true,
+                lastUsed: Date.now(),
+                keepAlive: this.keepAlive,
+            };
+            hostConnections.push(connection);
+            this.connections.set(host, hostConnections);
+            return connection.id;
+        }
+        return this.waitForConnection(host, timeout ?? 5000);
+    }
+    release(connectionId) {
+        for (const [, connections] of this.connections.entries()) {
+            const connection = connections.find((c) => c.id === connectionId);
+            if (connection) {
+                connection.inUse = false;
+                connection.lastUsed = Date.now();
+                return;
+            }
+        }
+    }
+    async waitForConnection(host, timeout = 5000) {
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            const checkInterval = setInterval(() => {
+                const hostConnections = this.connections.get(host) || [];
+                const available = hostConnections.find((conn) => !conn.inUse);
+                if (available) {
+                    clearInterval(checkInterval);
+                    available.inUse = true;
+                    available.lastUsed = Date.now();
+                    resolve(available.id);
+                }
+                if (Date.now() - startTime >= timeout) {
+                    clearInterval(checkInterval);
+                    reject(new Error(`Timeout waiting for connection to ${host} after ${timeout}ms`));
+                }
+            }, 100);
+        });
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [host, connections] of this.connections.entries()) {
+            const activeConnections = connections.filter((conn) => {
+                if (conn.inUse)
+                    return true;
+                const idleTime = now - conn.lastUsed;
+                return idleTime < this.maxIdleTime;
+            });
+            if (activeConnections.length === 0) {
+                this.connections.delete(host);
+            }
+            else {
+                this.connections.set(host, activeConnections);
+            }
+        }
+    }
+    getStats() {
+        let total = 0;
+        let active = 0;
+        let idle = 0;
+        for (const connections of this.connections.values()) {
+            total += connections.length;
+            active += connections.filter((c) => c.inUse).length;
+            idle += connections.filter((c) => !c.inUse).length;
+        }
+        return {
+            totalConnections: total,
+            activeConnections: active,
+            idleConnections: idle,
+            hosts: this.connections.size,
+        };
+    }
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+        this.connections.clear();
+    }
+}

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

@@ -0,0 +1,38 @@
+import { NetworkError, RDAPServerError, TimeoutError, RDAPifyError } from '../../shared/errors';
+export class DenoFetcher {
+    constructor(options = {}) {
+        this.timeout = options.timeout ?? 10000;
+        this.userAgent = options.userAgent ?? 'RDAPify/0.2.2 (Deno) (https://rdapify.com)';
+        this.headers = options.headers ?? {};
+        this.ssrfProtection = options.ssrfProtection;
+    }
+    async fetch(url) {
+        if (this.ssrfProtection) {
+            await this.ssrfProtection.validateUrl(url);
+        }
+        try {
+            const response = await globalThis.fetch(url, {
+                method: 'GET',
+                headers: {
+                    'User-Agent': this.userAgent,
+                    Accept: 'application/rdap+json, application/json',
+                    ...this.headers,
+                },
+                signal: AbortSignal.timeout(this.timeout),
+            });
+            if (!response.ok) {
+                throw new RDAPServerError(`RDAP server returned ${response.status}`, response.status, { url });
+            }
+            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(`Request timed out after ${this.timeout}ms`, { url });
+            }
+            throw new NetworkError(`DenoFetcher: failed to fetch ${url}: ${err instanceof Error ? err.message : String(err)}`, undefined, { url, originalError: err });
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import { RateLimiter } from './RateLimiter';
+import { RateLimitError } from '../../shared/errors';
+export class DistributedRateLimiter extends RateLimiter {
+    constructor(redis, options = {}) {
+        super(options);
+        this.redis = redis;
+    }
+    async checkLimit(key = 'default') {
+        if (!this.isEnabled())
+            return;
+        const config = this.getConfig();
+        const windowId = Math.floor(Date.now() / config.windowMs);
+        const windowKey = `rdapify:rl:${key}:${windowId}`;
+        const current = await this.redis.incr(windowKey);
+        if (current === 1) {
+            await this.redis.pexpire(windowKey, config.windowMs);
+        }
+        if (current > config.maxRequests) {
+            throw new RateLimitError(`Rate limit exceeded (${current}/${config.maxRequests}) for key: ${key}`, { key, limit: config.maxRequests, current });
+        }
+    }
+}

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

@@ -0,0 +1,127 @@
+import { NetworkError, TimeoutError, RDAPServerError, RDAPifyError, QueryAbortedError } from '../../shared/errors';
+import { withTimeout } from '../../shared/utils/helpers';
+export class Fetcher {
+    constructor(options = {}) {
+        this.timeout = {
+            connect: options.timeout?.connect || 5000,
+            request: options.timeout?.request || 10000,
+            dns: options.timeout?.dns || 3000,
+        };
+        this.userAgent = options.userAgent || 'RDAPify/0.1.7 (https://rdapify.com)';
+        this.headers = options.headers || {};
+        this.followRedirects = options.followRedirects ?? true;
+        this.maxRedirects = options.maxRedirects || 5;
+        this.ssrfProtection = options.ssrfProtection;
+        this.logRedirect = options.logRedirect;
+        this.http2 = options.http2 ?? false;
+        this.signal = options.signal;
+    }
+    async fetch(url) {
+        if (this.ssrfProtection) {
+            await this.ssrfProtection.validateUrl(url);
+        }
+        try {
+            const response = await this.makeRequest(url);
+            return response;
+        }
+        catch (error) {
+            if (error instanceof RDAPifyError) {
+                throw error;
+            }
+            throw new NetworkError(`Failed to fetch RDAP data: ${error instanceof Error ? error.message : 'Unknown error'}`, undefined, { url, originalError: error });
+        }
+    }
+    async makeRequest(url, redirectCount = 0) {
+        if (redirectCount > this.maxRedirects) {
+            throw new NetworkError(`Too many redirects (max: ${this.maxRedirects})`, undefined, { url });
+        }
+        const requestHeaders = {
+            'User-Agent': this.userAgent,
+            Accept: 'application/rdap+json, application/json',
+            ...this.headers,
+        };
+        if (this.http2) {
+            requestHeaders['Upgrade'] = 'h2c';
+            requestHeaders['HTTP2-Settings'] = '';
+        }
+        let response;
+        try {
+            response = await withTimeout(fetch(url, {
+                method: 'GET',
+                headers: requestHeaders,
+                redirect: 'manual',
+                signal: this.signal,
+            }), this.timeout.request, `Request timeout after ${this.timeout.request}ms`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new QueryAbortedError(url);
+            }
+            if (error instanceof Error && error.message.includes('timeout')) {
+                throw new TimeoutError(`Request timed out after ${this.timeout.request}ms`, { url });
+            }
+            throw error;
+        }
+        if (response.status >= 300 && response.status < 400) {
+            const fromUrl = url;
+            if (!this.followRedirects) {
+                throw new NetworkError(`Redirect not allowed (status: ${response.status})`, response.status, { url });
+            }
+            const location = response.headers.get('Location');
+            if (!location) {
+                throw new NetworkError('Redirect without Location header', response.status, { url });
+            }
+            let redirectUrl;
+            try {
+                redirectUrl = new URL(location, url).toString();
+            }
+            catch {
+                throw new NetworkError('Invalid redirect URL', response.status, { url, location });
+            }
+            if (this.ssrfProtection) {
+                await this.ssrfProtection.validateUrl(redirectUrl);
+            }
+            this.logRedirect?.(fromUrl, redirectUrl);
+            return this.makeRequest(redirectUrl, redirectCount + 1);
+        }
+        if (!response.ok) {
+            let errorBody;
+            try {
+                errorBody = await response.json();
+            }
+            catch {
+                try {
+                    errorBody = await response.text();
+                }
+                catch {
+                    errorBody = null;
+                }
+            }
+            throw new RDAPServerError(`RDAP server error: ${response.status} ${response.statusText}`, response.status, { url, body: errorBody });
+        }
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch (error) {
+            throw new NetworkError('Failed to parse RDAP response as JSON', response.status, {
+                url,
+                originalError: error,
+            });
+        }
+        if (!data || typeof data !== 'object') {
+            throw new NetworkError('Invalid RDAP response: not an object', response.status, {
+                url,
+            });
+        }
+        return data;
+    }
+    getConfig() {
+        return {
+            timeout: { ...this.timeout },
+            userAgent: this.userAgent,
+            followRedirects: this.followRedirects,
+            maxRedirects: this.maxRedirects,
+        };
+    }
+}