rdapify 0.2.3 → 0.3.1

package/dist/{shared → cjs/shared}/utils/helpers/string.js

@@ -26,4 +26,3 @@ function truncate(str, maxLength) {
         return str;
     return str.substring(0, maxLength - 3) + '...';
 }
-//# sourceMappingURL=string.js.map

package/dist/{shared → cjs/shared}/utils/validators/asn.js

@@ -27,4 +27,3 @@ function normalizeASN(asn) {
     const asnNumber = validateASN(asn);
     return `AS${asnNumber}`;
 }
-//# sourceMappingURL=asn.js.map

package/dist/{shared → cjs/shared}/utils/validators/config-validation.js

@@ -94,4 +94,3 @@ function validateClientOptions(options) {
         }
     }
 }
-//# sourceMappingURL=config-validation.js.map

package/dist/{shared → cjs/shared}/utils/validators/domain.js

@@ -31,4 +31,3 @@ function validateDomain(domain) {
 function normalizeDomain(domain) {
     return domain.trim().toLowerCase().replace(/\.$/, '');
 }
-//# sourceMappingURL=domain.js.map

package/dist/{shared → cjs/shared}/utils/validators/entity.js

@@ -24,4 +24,3 @@ function validateEntityHandle(handle) {
 function normalizeEntityHandle(handle) {
     return handle.trim();
 }
-//# sourceMappingURL=entity.js.map

package/dist/{shared → cjs/shared}/utils/validators/index.js

@@ -24,4 +24,3 @@ Object.defineProperty(exports, "isLocalhost", { enumerable: true, get: function
 Object.defineProperty(exports, "isLinkLocal", { enumerable: true, get: function () { return network_1.isLinkLocal; } });
 var config_validation_1 = require("./config-validation");
 Object.defineProperty(exports, "validateClientOptions", { enumerable: true, get: function () { return config_validation_1.validateClientOptions; } });
-//# sourceMappingURL=index.js.map

package/dist/{shared → cjs/shared}/utils/validators/ip.js

@@ -52,4 +52,3 @@ function validateIP(ip) {
 function normalizeIP(ip) {
     return ip.trim().toLowerCase();
 }
-//# sourceMappingURL=ip.js.map

package/dist/{shared → cjs/shared}/utils/validators/nameserver.js

@@ -46,4 +46,3 @@ function validateNameserver(nameserver) {
 function normalizeNameserver(nameserver) {
     return nameserver.trim().toLowerCase();
 }
-//# sourceMappingURL=nameserver.js.map

package/dist/{shared → cjs/shared}/utils/validators/network.js

@@ -45,4 +45,3 @@ function isLinkLocal(ip) {
         return true;
     return false;
 }
-//# sourceMappingURL=network.js.map

package/dist/esm/application/client/RDAPClient.js

@@ -0,0 +1,439 @@
+import { CacheManager } from '../../infrastructure/cache';
+import { BootstrapDiscovery, Fetcher, Normalizer } from '../../infrastructure/http';
+import { BunFetcher } from '../../infrastructure/http/BunFetcher';
+import { DenoFetcher } from '../../infrastructure/http/DenoFetcher';
+import { CloudflareWorkersFetcher } from '../../infrastructure/http/CloudflareWorkersFetcher';
+import { RateLimiter } from '../../infrastructure/http/RateLimiter';
+import { ConnectionPool } from '../../infrastructure/http/ConnectionPool';
+import { isBun, isDeno, isCloudflareWorkers } from '../../shared/utils/helpers/runtime';
+import { SSRFProtection, PIIRedactor } from '../../infrastructure/security';
+import { MetricsCollector } from '../../infrastructure/monitoring/MetricsCollector';
+import { Logger } from '../../infrastructure/logging/Logger';
+import { ValidationError, RDAPServerError, SearchNotSupportedError } from '../../shared/errors';
+import { UsageTelemetry } from '../../infrastructure/telemetry/UsageTelemetry';
+import { validateDomain as _validateDomainFn, validateIP as _validateIPFn, validateASN as _validateASNFn } from '../../shared/utils/validators';
+import { DEFAULT_OPTIONS } from '../../shared/types/options';
+import { deepMerge, calculateBackoff, sleep } from '../../shared/utils/helpers';
+import { QueryOrchestrator } from '../services';
+import { BatchProcessor } from '../services/BatchProcessor';
+import { MiddlewareManager } from '../hooks/MiddlewareHooks';
+import { QueryDeduplicator } from '../deduplication/QueryDeduplicator';
+import { NativeBackend } from '../../infrastructure/native/NativeBackend';
+export class RDAPClient {
+    constructor(options = {}) {
+        this.options = this.normalizeOptions(options);
+        const ssrfOptions = typeof this.options.ssrfProtection === 'boolean'
+            ? { enabled: this.options.ssrfProtection }
+            : this.options.ssrfProtection;
+        this.ssrfProtection = new SSRFProtection(ssrfOptions);
+        const timeoutMs = typeof this.options.timeout === 'number'
+            ? this.options.timeout
+            : this.options.timeout?.request ?? 10000;
+        if (isCloudflareWorkers()) {
+            this.fetcher = new CloudflareWorkersFetcher({
+                timeout: timeoutMs,
+                userAgent: this.options.userAgent,
+                headers: this.options.headers,
+                ssrfProtection: this.ssrfProtection,
+            });
+        }
+        else if (isDeno()) {
+            this.fetcher = new DenoFetcher({
+                timeout: timeoutMs,
+                userAgent: this.options.userAgent,
+                headers: this.options.headers,
+                ssrfProtection: this.ssrfProtection,
+            });
+        }
+        else if (isBun()) {
+            this.fetcher = new BunFetcher({
+                timeout: timeoutMs,
+                userAgent: this.options.userAgent,
+                headers: this.options.headers,
+                ssrfProtection: this.ssrfProtection,
+            });
+        }
+        else {
+            this.fetcher = new Fetcher({
+                timeout: typeof this.options.timeout === 'number'
+                    ? {
+                        request: this.options.timeout,
+                        connect: this.options.timeout,
+                        dns: this.options.timeout,
+                    }
+                    : this.options.timeout,
+                userAgent: this.options.userAgent,
+                headers: this.options.headers,
+                followRedirects: this.options.followRedirects,
+                maxRedirects: this.options.maxRedirects,
+                ssrfProtection: this.ssrfProtection,
+                http2: this.options.http2,
+                signal: this.options.signal,
+                logRedirect: (fromUrl, toUrl) => {
+                    this.logger?.warn(`Redirect: ${fromUrl} → ${toUrl}`);
+                    if (this.debugEnabled && this.debugLogger) {
+                        this.debugLogger.debug('Redirect occurred', {
+                            fromUrl,
+                            toUrl,
+                        });
+                    }
+                },
+            });
+        }
+        const bootstrapOpts = this.options.bootstrap && typeof this.options.bootstrap === 'object'
+            ? this.options.bootstrap
+            : undefined;
+        this.bootstrap = new BootstrapDiscovery(this.options.bootstrapUrl, this.fetcher, bootstrapOpts);
+        const cacheOptions = typeof this.options.cache === 'boolean'
+            ? this.options.cache
+                ? DEFAULT_OPTIONS.cache
+                : { strategy: 'none' }
+            : this.options.cache;
+        this.cache = new CacheManager(cacheOptions);
+        this.normalizer = new Normalizer();
+        const privacyOptions = typeof this.options.privacy === 'boolean'
+            ? { redactPII: this.options.privacy }
+            : this.options.privacy;
+        this.piiRedactor = new PIIRedactor(privacyOptions);
+        const rateLimitOptions = typeof this.options.rateLimit === 'boolean'
+            ? this.options.rateLimit
+                ? DEFAULT_OPTIONS.rateLimit
+                : { enabled: false }
+            : this.options.rateLimit;
+        this.rateLimiter = new RateLimiter(rateLimitOptions);
+        this.connectionPool = new ConnectionPool({
+            maxConnections: 10,
+            keepAlive: true,
+        });
+        this.metricsCollector = new MetricsCollector({
+            enabled: true,
+            maxMetrics: 10000,
+        });
+        const validLogLevels = ['debug', 'info', 'warn', 'error'];
+        const configuredLevel = this.options.logging?.level;
+        const logLevel = configuredLevel && validLogLevels.includes(configuredLevel)
+            ? configuredLevel
+            : 'info';
+        this.logger = new Logger({
+            level: logLevel,
+            enabled: true,
+            logRequests: true,
+            logResponses: true,
+        });
+        const debugOptions = this.options.debug;
+        this.debugEnabled = typeof debugOptions === 'boolean' ? debugOptions : debugOptions?.enabled ?? false;
+        this.debugLogger = typeof debugOptions === 'object' && debugOptions?.logger ? debugOptions.logger : undefined;
+        const middlewareOpts = this.options.middleware;
+        this.middlewareManager = new MiddlewareManager(middlewareOpts);
+        const dedupOpts = this.options.deduplication;
+        this.queryDeduplicator = new QueryDeduplicator(typeof dedupOpts === 'boolean'
+            ? { enabled: dedupOpts }
+            : dedupOpts);
+        this.batchProcessor = new BatchProcessor(this);
+        this.orchestrator = new QueryOrchestrator({
+            cache: this.cache,
+            bootstrap: this.bootstrap,
+            fetcher: this.fetcher,
+            normalizer: this.normalizer,
+            piiRedactor: this.piiRedactor,
+            includeRaw: this.options.includeRaw,
+            fetchWithRetry: this.fetchWithRetry.bind(this),
+            rateLimiter: this.rateLimiter,
+            metricsCollector: this.metricsCollector,
+            logger: this.logger,
+            debugEnabled: this.debugEnabled,
+            debugLogger: this.debugLogger,
+            middleware: this.middlewareManager,
+            deduplicator: this.queryDeduplicator,
+        });
+        const backendMode = this.options.backend;
+        this.nativeBackend =
+            backendMode === 'typescript'
+                ? null
+                : NativeBackend.create(backendMode === 'native' ? 'native' : 'auto');
+    }
+    async domain(domain) {
+        if (this.nativeBackend)
+            return this.nativeBackend.domain(domain);
+        const result = await this.orchestrator.queryDomain(domain);
+        this.pingTelemetry('domain');
+        return result;
+    }
+    async ip(ip) {
+        if (this.nativeBackend)
+            return this.nativeBackend.ip(ip);
+        const result = await this.orchestrator.queryIP(ip);
+        this.pingTelemetry('ip');
+        return result;
+    }
+    async asn(asn) {
+        if (this.nativeBackend)
+            return this.nativeBackend.asn(asn);
+        const result = await this.orchestrator.queryASN(asn);
+        this.pingTelemetry('asn');
+        return result;
+    }
+    async nameserver(nameserver) {
+        if (this.nativeBackend)
+            return this.nativeBackend.nameserver(nameserver);
+        const result = await this.orchestrator.queryNameserver(nameserver);
+        this.pingTelemetry('nameserver');
+        return result;
+    }
+    async entity(handle, serverUrl) {
+        if (this.nativeBackend)
+            return this.nativeBackend.entity(handle, serverUrl);
+        const result = await this.orchestrator.queryEntity(handle, serverUrl);
+        this.pingTelemetry('entity');
+        return result;
+    }
+    async checkAvailability(domain) {
+        try {
+            const response = await this.domain(domain);
+            const expirationEvent = response.events?.find(e => e.type === 'expiration');
+            const expiresAt = expirationEvent ? new Date(expirationEvent.date) : undefined;
+            return { domain: response.query, available: false, expiresAt };
+        }
+        catch (error) {
+            if (error instanceof RDAPServerError && error.statusCode === 404) {
+                return { domain, available: true };
+            }
+            throw error;
+        }
+    }
+    async checkAvailabilityBatch(domains) {
+        const entries = await Promise.all(domains.map(async (domain) => {
+            const result = await this.checkAvailability(domain);
+            return [domain, result];
+        }));
+        return new Map(entries);
+    }
+    async searchDomains(pattern, serverUrl) {
+        const server = serverUrl ?? (await this.bootstrap.discoverDomain('example.com'));
+        const url = `${server}/domains?name=${encodeURIComponent(pattern)}`;
+        let raw;
+        try {
+            raw = await this.fetchWithRetry(url);
+        }
+        catch (error) {
+            if (error instanceof RDAPServerError &&
+                (error.statusCode === 404 || error.statusCode === 501)) {
+                throw new SearchNotSupportedError(`RDAP server does not support domain search: ${server}`, { pattern, serverUrl: server });
+            }
+            throw error;
+        }
+        const domainSearchResults = raw['domainSearchResults'] ?? [];
+        const results = domainSearchResults.map((item) => this.normalizer.normalize(item, pattern, server, false, this.options.includeRaw));
+        return { results, totalCount: results.length, query: pattern };
+    }
+    async searchEntities(pattern, serverUrl) {
+        if (!serverUrl) {
+            throw new SearchNotSupportedError('searchEntities requires an explicit serverUrl — there is no global bootstrap for entities', { pattern });
+        }
+        const url = `${serverUrl}/entities?fn=${encodeURIComponent(pattern)}`;
+        let raw;
+        try {
+            raw = await this.fetchWithRetry(url);
+        }
+        catch (error) {
+            if (error instanceof RDAPServerError &&
+                (error.statusCode === 404 || error.statusCode === 501)) {
+                throw new SearchNotSupportedError(`RDAP server does not support entity search: ${serverUrl}`, { pattern, serverUrl });
+            }
+            throw error;
+        }
+        const entitySearchResults = raw['entitySearchResults'] ?? [];
+        const results = entitySearchResults.map((item) => this.normalizer.normalize(item, pattern, serverUrl, false, this.options.includeRaw));
+        return { results, totalCount: results.length, query: pattern };
+    }
+    async explain(query) {
+        const startTime = Date.now();
+        let queryType = 'domain';
+        let detectedType = 'unknown';
+        try {
+            if (/^\d+$/.test(query) || /^AS\d+$/i.test(query)) {
+                _validateASNFn(query);
+                queryType = 'asn';
+                detectedType = 'asn';
+            }
+            else if (query.includes('.') && /^\d/.test(query)) {
+                _validateIPFn(query);
+                queryType = 'ip';
+                detectedType = 'ipv4';
+            }
+            else if (query.includes(':')) {
+                _validateIPFn(query);
+                queryType = 'ip';
+                detectedType = 'ipv6';
+            }
+            else {
+                _validateDomainFn(query);
+                queryType = 'domain';
+                detectedType = 'domain';
+            }
+        }
+        catch {
+            queryType = 'domain';
+            detectedType = 'unknown';
+        }
+        const cacheEnabled = this.options.cache !== false;
+        let cacheStatus = cacheEnabled ? 'miss' : 'disabled';
+        if (cacheEnabled) {
+            const { generateCacheKey } = await import('../../shared/utils/helpers');
+            const cacheKey = generateCacheKey(queryType, query.toLowerCase());
+            const cached = await this.cache.get(cacheKey);
+            if (cached)
+                cacheStatus = 'hit';
+        }
+        let bootstrapServer = null;
+        let builtUrl = null;
+        let error;
+        try {
+            if (queryType === 'domain') {
+                bootstrapServer = await this.bootstrap.discoverDomain(query.toLowerCase());
+                builtUrl = `${bootstrapServer}/domain/${query.toLowerCase()}`;
+            }
+            else if (queryType === 'ip') {
+                const version = _validateIPFn(query);
+                bootstrapServer =
+                    version === 'v4'
+                        ? await this.bootstrap.discoverIPv4(query)
+                        : await this.bootstrap.discoverIPv6(query);
+                builtUrl = `${bootstrapServer}/ip/${query}`;
+            }
+            else if (queryType === 'asn') {
+                const asnNum = _validateASNFn(query);
+                bootstrapServer = await this.bootstrap.discoverASN(asnNum);
+                builtUrl = `${bootstrapServer}/autnum/${asnNum}`;
+            }
+        }
+        catch (err) {
+            error = err instanceof Error ? err.message : String(err);
+        }
+        return {
+            query,
+            queryType,
+            detectedType,
+            bootstrapServer,
+            builtUrl,
+            cacheStatus,
+            latencyMs: Date.now() - startTime,
+            error,
+        };
+    }
+    pingTelemetry(queryType) {
+        const telemetryOpts = this.options.usageTelemetry;
+        if (telemetryOpts?.enabled === true) {
+            UsageTelemetry.ping(queryType, telemetryOpts.endpoint);
+        }
+    }
+    async fetchWithRetry(url) {
+        const retryOptions = typeof this.options.retry === 'boolean'
+            ? this.options.retry
+                ? DEFAULT_OPTIONS.retry
+                : { maxAttempts: 1 }
+            : this.options.retry;
+        let lastError;
+        for (let attempt = 1; attempt <= (retryOptions.maxAttempts || 1); attempt++) {
+            try {
+                return await this.fetcher.fetch(url);
+            }
+            catch (error) {
+                lastError = error;
+                if (error instanceof ValidationError) {
+                    throw error;
+                }
+                if (attempt < (retryOptions.maxAttempts || 1)) {
+                    const delay = calculateBackoff(attempt, retryOptions.backoff || 'exponential', retryOptions.initialDelay || 1000, retryOptions.maxDelay || 10000);
+                    await sleep(delay);
+                    continue;
+                }
+            }
+        }
+        throw lastError;
+    }
+    normalizeOptions(options) {
+        return deepMerge(DEFAULT_OPTIONS, options);
+    }
+    async validate() {
+        const errors = [];
+        const warnings = [];
+        const bootstrapUrl = this.options.bootstrapUrl;
+        if (bootstrapUrl && bootstrapUrl !== 'https://data.iana.org/rdap') {
+            try {
+                await this.fetcher.fetch(`${bootstrapUrl}/dns.json`);
+            }
+            catch {
+                errors.push(`Bootstrap URL unreachable: ${bootstrapUrl}`);
+            }
+        }
+        const cacheOpts = this.options.cache;
+        if (cacheOpts?.strategy === 'redis' && cacheOpts?.redisClient) {
+            try {
+                await cacheOpts.redisClient.ping();
+            }
+            catch {
+                errors.push('Redis connection failed');
+            }
+        }
+        const ssrfOpts = this.options.ssrfProtection;
+        if (ssrfOpts?.enabled === false) {
+            warnings.push('SSRF protection disabled — not safe for production');
+        }
+        return { valid: errors.length === 0, errors, warnings };
+    }
+    async clearCache() {
+        await this.cache.clear();
+        this.bootstrap.clearCache();
+    }
+    async getStats() {
+        return {
+            cache: await this.cache.getStats(),
+            bootstrap: this.bootstrap.getCacheStats(),
+        };
+    }
+    getConfig() {
+        return { ...this.options };
+    }
+    getRateLimiter() {
+        return this.rateLimiter;
+    }
+    getBatchProcessor() {
+        return this.batchProcessor;
+    }
+    streamBatch(requests, options) {
+        return this.batchProcessor.streamBatch(requests, options);
+    }
+    getMetrics(since) {
+        return this.metricsCollector.getSummary(since);
+    }
+    getConnectionPoolStats() {
+        return this.connectionPool.getStats();
+    }
+    use(hooks) {
+        this.middlewareManager.use(hooks);
+        return this;
+    }
+    getMiddlewareManager() {
+        return this.middlewareManager;
+    }
+    getDeduplicatorStats() {
+        return this.queryDeduplicator.getStats();
+    }
+    getLogger() {
+        return this.logger;
+    }
+    getLogs(count) {
+        return this.logger.getLogs(count);
+    }
+    async clearAll() {
+        await this.cache.clear();
+        this.bootstrap.clearCache();
+        this.metricsCollector.clear();
+        this.logger.clear();
+    }
+    destroy() {
+        this.rateLimiter.destroy();
+        this.connectionPool.destroy();
+    }
+}

package/dist/esm/application/client/index.js

@@ -0,0 +1 @@
+export { RDAPClient } from './RDAPClient';

package/dist/esm/application/deduplication/QueryDeduplicator.js

@@ -0,0 +1,41 @@
+export class QueryDeduplicator {
+    constructor(options) {
+        this.inflight = new Map();
+        this.windowMs = options?.windowMs ?? 100;
+        this.enabled = options?.enabled ?? true;
+    }
+    deduplicate(key, fn) {
+        if (!this.enabled) {
+            return fn();
+        }
+        const existing = this.inflight.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const promise = fn().finally(() => {
+            setTimeout(() => {
+                if (this.inflight.get(key) === promise) {
+                    this.inflight.delete(key);
+                }
+            }, this.windowMs);
+        });
+        this.inflight.set(key, promise);
+        return promise;
+    }
+    getInflightCount() {
+        return this.inflight.size;
+    }
+    getInflightKeys() {
+        return Array.from(this.inflight.keys());
+    }
+    clear() {
+        this.inflight.clear();
+    }
+    getStats() {
+        return {
+            enabled: this.enabled,
+            inflight: this.inflight.size,
+            windowMs: this.windowMs,
+        };
+    }
+}

package/dist/esm/application/hooks/MiddlewareHooks.js

@@ -0,0 +1,79 @@
+export class MiddlewareManager {
+    constructor(hooks) {
+        this.priorityEntries = [];
+        this.hooks = hooks ?? {};
+    }
+    async safeRun(fn, ctx) {
+        if (!fn)
+            return;
+        try {
+            await fn(ctx);
+        }
+        catch {
+        }
+    }
+    async runBeforeQuery(ctx) {
+        let aborted = false;
+        const enrichedCtx = {
+            ...ctx,
+            abort: () => {
+                aborted = true;
+            },
+        };
+        for (const entry of this.priorityEntries) {
+            if (entry.hooks.beforeQuery) {
+                await this.safeRun(entry.hooks.beforeQuery, enrichedCtx);
+                if (aborted)
+                    return true;
+            }
+        }
+        await this.safeRun(this.hooks.beforeQuery, enrichedCtx);
+        return aborted;
+    }
+    async runAfterQuery(ctx) {
+        for (const entry of this.priorityEntries) {
+            await this.safeRun(entry.hooks.afterQuery, ctx);
+        }
+        await this.safeRun(this.hooks.afterQuery, ctx);
+    }
+    async runOnError(ctx) {
+        for (const entry of this.priorityEntries) {
+            await this.safeRun(entry.hooks.onError, ctx);
+        }
+        await this.safeRun(this.hooks.onError, ctx);
+    }
+    async runOnCacheHit(ctx) {
+        for (const entry of this.priorityEntries) {
+            await this.safeRun(entry.hooks.onCacheHit, ctx);
+        }
+        await this.safeRun(this.hooks.onCacheHit, ctx);
+    }
+    async runOnCacheMiss(ctx) {
+        for (const entry of this.priorityEntries) {
+            await this.safeRun(entry.hooks.onCacheMiss, ctx);
+        }
+        await this.safeRun(this.hooks.onCacheMiss, ctx);
+    }
+    async runOnRetry(ctx) {
+        for (const entry of this.priorityEntries) {
+            await this.safeRun(entry.hooks.onRetry, ctx);
+        }
+        await this.safeRun(this.hooks.onRetry, ctx);
+    }
+    use(hooks, priority) {
+        if (priority !== undefined) {
+            this.priorityEntries.push({ priority, hooks });
+            this.priorityEntries.sort((a, b) => a.priority - b.priority);
+        }
+        else {
+            this.hooks = { ...this.hooks, ...hooks };
+        }
+    }
+    clear() {
+        this.hooks = {};
+        this.priorityEntries = [];
+    }
+    getRegisteredHooks() {
+        return Object.keys(this.hooks).filter((k) => this.hooks[k] !== undefined);
+    }
+}