rdapify 0.2.3 → 0.3.1

package/dist/esm/application/services/QueryPriority.js

@@ -0,0 +1,109 @@
+export class QueryPriorityQueue {
+    constructor(concurrency = 5, processor) {
+        this.highPriorityQueue = [];
+        this.normalPriorityQueue = [];
+        this.lowPriorityQueue = [];
+        this.processing = false;
+        this.activeCount = 0;
+        this.concurrency = concurrency;
+        this.processor = processor;
+    }
+    async enqueue(data, priority = 'normal') {
+        return new Promise((resolve, reject) => {
+            const item = {
+                id: `${Date.now()}-${Math.random()}`,
+                priority,
+                data,
+                timestamp: Date.now(),
+                resolve,
+                reject,
+            };
+            switch (priority) {
+                case 'high':
+                    this.highPriorityQueue.push(item);
+                    break;
+                case 'low':
+                    this.lowPriorityQueue.push(item);
+                    break;
+                case 'normal':
+                default:
+                    this.normalPriorityQueue.push(item);
+                    break;
+            }
+            this.processQueue();
+        });
+    }
+    async processQueue() {
+        if (this.processing)
+            return;
+        this.processing = true;
+        while (this.hasItems() && this.activeCount < this.concurrency) {
+            const item = this.dequeue();
+            if (!item)
+                break;
+            this.activeCount++;
+            this.processor(item.data)
+                .then((result) => {
+                item.resolve(result);
+            })
+                .catch((error) => {
+                item.reject(error);
+            })
+                .finally(() => {
+                this.activeCount--;
+                this.processQueue();
+            });
+        }
+        this.processing = false;
+    }
+    dequeue() {
+        if (this.highPriorityQueue.length > 0) {
+            return this.highPriorityQueue.shift();
+        }
+        if (this.normalPriorityQueue.length > 0) {
+            return this.normalPriorityQueue.shift();
+        }
+        if (this.lowPriorityQueue.length > 0) {
+            return this.lowPriorityQueue.shift();
+        }
+        return undefined;
+    }
+    hasItems() {
+        return (this.highPriorityQueue.length > 0 ||
+            this.normalPriorityQueue.length > 0 ||
+            this.lowPriorityQueue.length > 0);
+    }
+    getStats() {
+        return {
+            high: this.highPriorityQueue.length,
+            normal: this.normalPriorityQueue.length,
+            low: this.lowPriorityQueue.length,
+            total: this.highPriorityQueue.length +
+                this.normalPriorityQueue.length +
+                this.lowPriorityQueue.length,
+            active: this.activeCount,
+            concurrency: this.concurrency,
+        };
+    }
+    clear() {
+        const rejectAll = (queue) => {
+            queue.forEach((item) => {
+                item.reject(new Error('Queue cleared'));
+            });
+        };
+        rejectAll(this.highPriorityQueue);
+        rejectAll(this.normalPriorityQueue);
+        rejectAll(this.lowPriorityQueue);
+        this.highPriorityQueue = [];
+        this.normalPriorityQueue = [];
+        this.lowPriorityQueue = [];
+    }
+    size() {
+        return (this.highPriorityQueue.length +
+            this.normalPriorityQueue.length +
+            this.lowPriorityQueue.length);
+    }
+    isEmpty() {
+        return this.size() === 0;
+    }
+}

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

@@ -0,0 +1,2 @@
+export { QueryOrchestrator } from './QueryOrchestrator';
+export { BatchProcessor } from './BatchProcessor';

package/dist/esm/cli/index.js

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+import { RDAPClient, VERSION } from '../index';
+const HELP_TEXT = `
+RDAPify v${VERSION} — RDAP client CLI
+
+Usage:
+  rdapify domain <name>              Query domain registration info
+  rdapify ip <address>               Query IP address info
+  rdapify asn <number>               Query ASN info
+  rdapify nameserver <hostname>      Query nameserver info
+  rdapify entity <handle> --server <url>  Query entity (contact/registrar) info
+
+Options:
+  --json                      Output raw JSON
+  --no-cache                  Disable cache for this query
+  --timeout <ms>              Request timeout in milliseconds (default: 10000)
+  --server <url>              RDAP server base URL (required for entity queries)
+  --version, -v               Show version
+  --help, -h                  Show this help message
+
+Examples:
+  rdapify domain example.com
+  rdapify ip 8.8.8.8
+  rdapify asn 15169
+  rdapify nameserver ns1.example.com
+  rdapify entity ARIN-HN-1 --server https://rdap.arin.net/registry
+  rdapify domain example.com --json
+  rdapify ip 1.1.1.1 --no-cache --timeout 5000
+`.trimStart();
+function parseArgs(argv) {
+    const result = {
+        command: null,
+        query: null,
+        json: false,
+        noCache: false,
+        timeout: 10000,
+        version: false,
+        help: false,
+        server: null,
+    };
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg === undefined) {
+            i++;
+            continue;
+        }
+        switch (arg) {
+            case '--json':
+                result.json = true;
+                break;
+            case '--no-cache':
+                result.noCache = true;
+                break;
+            case '--timeout': {
+                const next = argv[i + 1];
+                if (next === undefined || next.startsWith('-')) {
+                    fatal('--timeout requires a numeric value in milliseconds');
+                }
+                const ms = parseInt(next, 10);
+                if (isNaN(ms) || ms <= 0) {
+                    fatal(`--timeout value must be a positive integer, got: ${next}`);
+                }
+                result.timeout = ms;
+                i++;
+                break;
+            }
+            case '--server': {
+                const next = argv[i + 1];
+                if (next === undefined || next.startsWith('-')) {
+                    fatal('--server requires a URL value');
+                }
+                result.server = next;
+                i++;
+                break;
+            }
+            case '--version':
+            case '-v':
+                result.version = true;
+                break;
+            case '--help':
+            case '-h':
+                result.help = true;
+                break;
+            default:
+                if (!arg.startsWith('-')) {
+                    if (result.command === null) {
+                        if (arg !== 'domain' && arg !== 'ip' && arg !== 'asn' && arg !== 'nameserver' && arg !== 'entity') {
+                            fatal(`Unknown command: "${arg}". Valid commands are: domain, ip, asn, nameserver, entity`);
+                        }
+                        result.command = arg;
+                    }
+                    else if (result.query === null) {
+                        result.query = arg;
+                    }
+                }
+                else {
+                    fatal(`Unknown option: "${arg}". Run rdapify --help for usage.`);
+                }
+                break;
+        }
+        i++;
+    }
+    return result;
+}
+function label(text, width = 13) {
+    return `${text}:`.padEnd(width);
+}
+function formatDate(iso) {
+    const d = new Date(iso);
+    if (isNaN(d.getTime()))
+        return iso;
+    return d.toISOString().slice(0, 10);
+}
+function getEventDate(events, eventType) {
+    if (!events)
+        return undefined;
+    const ev = events.find((e) => e.type === eventType);
+    return ev ? formatDate(ev.date) : undefined;
+}
+function printDomain(res) {
+    const name = res.ldhName ?? res.unicodeName ?? res.query;
+    const registrar = res.registrar?.name ?? '—';
+    const status = res.status?.join(', ') ?? '—';
+    const created = getEventDate(res.events, 'registration') ?? '—';
+    const expires = getEventDate(res.events, 'expiration') ?? '—';
+    const updated = getEventDate(res.events, 'last changed') ?? '—';
+    const nameservers = res.nameservers?.join(', ') ?? '—';
+    process.stdout.write([
+        `${label('Domain')}${name}`,
+        `${label('Registrar')}${registrar}`,
+        `${label('Status')}${status}`,
+        `${label('Created')}${created}`,
+        `${label('Expires')}${expires}`,
+        `${label('Updated')}${updated}`,
+        `${label('Nameservers')}${nameservers}`,
+    ].join('\n') + '\n');
+}
+function printIP(res) {
+    const ip = res.query;
+    const type = res.ipVersion ? `IPv${res.ipVersion.slice(1)}` : '—';
+    const handle = res.handle ?? '—';
+    const name = res.name ?? '—';
+    const country = res.country ?? '—';
+    const status = res.status?.join(', ') ?? '—';
+    process.stdout.write([
+        `${label('IP Address')}${ip}`,
+        `${label('Type')}${type}`,
+        `${label('Handle')}${handle}`,
+        `${label('Name')}${name}`,
+        `${label('Country')}${country}`,
+        `${label('Status')}${status}`,
+    ].join('\n') + '\n');
+}
+function printASN(res) {
+    const asn = res.startAutnum ?? res.query;
+    const handle = res.handle ?? '—';
+    const name = res.name ?? '—';
+    const country = res.country ?? '—';
+    const status = res.status?.join(', ') ?? '—';
+    process.stdout.write([
+        `${label('ASN')}${asn}`,
+        `${label('Handle')}${handle}`,
+        `${label('Name')}${name}`,
+        `${label('Country')}${country}`,
+        `${label('Status')}${status}`,
+    ].join('\n') + '\n');
+}
+function printNameserver(res) {
+    const name = res.ldhName ?? res.unicodeName ?? res.query;
+    const handle = res.handle ?? '—';
+    const status = res.status?.join(', ') ?? '—';
+    const v4 = res.ipAddresses?.v4?.join(', ') || '—';
+    const v6 = res.ipAddresses?.v6?.join(', ') || '—';
+    process.stdout.write([
+        `${label('Nameserver')}${name}`,
+        `${label('Handle')}${handle}`,
+        `${label('Status')}${status}`,
+        `${label('IPv4')}${v4}`,
+        `${label('IPv6')}${v6}`,
+    ].join('\n') + '\n');
+}
+function printEntity(res) {
+    const handle = res.handle ?? res.query;
+    const roles = res.roles?.join(', ') ?? '—';
+    const status = res.status?.join(', ') ?? '—';
+    let name = '—';
+    if (res.vcardArray && Array.isArray(res.vcardArray) && res.vcardArray.length >= 2) {
+        const vcard = res.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] ?? '—';
+            }
+        }
+    }
+    process.stdout.write([
+        `${label('Handle')}${handle}`,
+        `${label('Name')}${name}`,
+        `${label('Roles')}${roles}`,
+        `${label('Status')}${status}`,
+    ].join('\n') + '\n');
+}
+function fatal(message, code = 1) {
+    process.stderr.write(`Error: ${message}\n`);
+    process.exit(code);
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const args = parseArgs(argv);
+    if (args.version) {
+        process.stdout.write(`rdapify v${VERSION}\n`);
+        return;
+    }
+    if (args.help) {
+        process.stdout.write(HELP_TEXT);
+        return;
+    }
+    if (args.command === null) {
+        process.stdout.write(HELP_TEXT);
+        process.exit(0);
+    }
+    if (args.query === null || args.query.trim() === '') {
+        fatal(`Missing argument for command "${args.command}". Example: rdapify ${args.command} <value>`);
+    }
+    const client = new RDAPClient({
+        cache: args.noCache ? false : true,
+        timeout: args.timeout,
+    });
+    const query = args.query.trim();
+    try {
+        switch (args.command) {
+            case 'domain': {
+                const result = await client.domain(query);
+                if (args.json) {
+                    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                }
+                else {
+                    printDomain(result);
+                }
+                break;
+            }
+            case 'ip': {
+                const result = await client.ip(query);
+                if (args.json) {
+                    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                }
+                else {
+                    printIP(result);
+                }
+                break;
+            }
+            case 'asn': {
+                const result = await client.asn(query);
+                if (args.json) {
+                    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                }
+                else {
+                    printASN(result);
+                }
+                break;
+            }
+            case 'nameserver': {
+                const result = await client.nameserver(query);
+                if (args.json) {
+                    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                }
+                else {
+                    printNameserver(result);
+                }
+                break;
+            }
+            case 'entity': {
+                if (!args.server) {
+                    fatal('Entity queries require --server <url>. Example: rdapify entity ARIN-HN-1 --server https://rdap.arin.net/registry');
+                }
+                const result = await client.entity(query, args.server);
+                if (args.json) {
+                    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                }
+                else {
+                    printEntity(result);
+                }
+                break;
+            }
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        fatal(message);
+    }
+}
+main().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`Fatal: ${message}\n`);
+    process.exit(1);
+});

package/dist/esm/core/ports/bootstrap.port.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/ports/cache.port.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/ports/fetcher.port.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/ports/index.js

@@ -0,0 +1,5 @@
+export * from './cache.port';
+export * from './fetcher.port';
+export * from './normalizer.port';
+export * from './bootstrap.port';
+export * from './pii-redactor.port';

package/dist/esm/core/ports/normalizer.port.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/ports/pii-redactor.port.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/index.js

@@ -0,0 +1,40 @@
+export { RDAPClient } from './application/client';
+export { RDAPifyError, SSRFProtectionError, NetworkError, TimeoutError, RDAPServerError, NoServerFoundError, ValidationError, ParseError, CacheError, RateLimitError, SearchNotSupportedError, isRDAPifyError, isSSRFProtectionError, isNetworkError, isTimeoutError, isRateLimitError, } from './shared/errors';
+export { validateDomain, validateIP, validateIPv4, validateIPv6, validateASN, validateNameserver, validateEntityHandle, isPrivateIP, isLocalhost, isLinkLocal, normalizeDomain, normalizeIP, normalizeASN, normalizeNameserver, normalizeEntityHandle, } from './shared/utils/validators';
+export { UsageTelemetry } from './infrastructure/telemetry/UsageTelemetry';
+export const VERSION = '0.3.1';
+export { BatchProcessor } from './application/services/BatchProcessor';
+export { RateLimiter } from './infrastructure/http/RateLimiter';
+export { DistributedRateLimiter } from './infrastructure/http/DistributedRateLimiter';
+export { ConnectionPool } from './infrastructure/http/ConnectionPool';
+export { MetricsCollector } from './infrastructure/monitoring/MetricsCollector';
+export { Logger } from './infrastructure/logging/Logger';
+export { RetryStrategy } from './infrastructure/http/RetryStrategy';
+export { QueryPriorityQueue } from './application/services/QueryPriority';
+export { PersistentCache } from './infrastructure/cache/PersistentCache';
+export { validateIdnDomain, validateIpv6WithZone, validateAsnRange, isIdnDomain, isPunycodeDomain, idnToAscii, asciiToIdn, } from './shared/utils/enhanced-validators';
+export { AuthenticationManager } from './infrastructure/http/AuthenticationManager';
+export { ProxyManager } from './infrastructure/http/ProxyManager';
+export { CompressionManager } from './infrastructure/http/CompressionManager';
+export { RedisCache } from './infrastructure/cache/RedisCache';
+export { MiddlewareManager } from './application/hooks/MiddlewareHooks';
+export { QueryDeduplicator } from './application/deduplication/QueryDeduplicator';
+export { AuditLogger, InMemoryAuditAdapter, FileAuditAdapter, } from './infrastructure/logging/AuditLogger';
+export { ResponseValidator } from './infrastructure/validation/ResponseValidator';
+export { isNode, isBrowser, isDeno, isBun, isCloudflareWorkers, getRuntimeName, } from './shared/utils/helpers/runtime';
+export { isNativeAvailable } from './infrastructure/native/NativeBackend';
+export { CircuitBreaker, CircuitOpenError } from './infrastructure/http/CircuitBreaker';
+export { QueryAbortedError } from './shared/errors';
+export { BunFetcher } from './infrastructure/http/BunFetcher';
+export { DenoFetcher } from './infrastructure/http/DenoFetcher';
+export { CloudflareWorkersFetcher } from './infrastructure/http/CloudflareWorkersFetcher';
+export { BrowserFetcher } from './infrastructure/http/BrowserFetcher';
+export { createRdapifySchema, RDAPIFY_TYPE_DEFS } from './integrations/graphql';
+export { rdapifyExpress, MinimalRouter } from './integrations/express';
+export { RdapifyModule, InjectRdapClient, RDAPIFY_CLIENT_TOKEN } from './integrations/nestjs';
+export { PrometheusExporter } from './infrastructure/monitoring/PrometheusExporter';
+export { TelemetryExporter } from './infrastructure/monitoring/TelemetryExporter';
+export { RDAPIFY_GRAFANA_DASHBOARD } from './infrastructure/monitoring/GrafanaDashboard';
+export { deprecated } from './shared/utils/deprecation';
+import { RDAPClient as RDAPClientClass } from './application/client';
+export default RDAPClientClass;

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

@@ -0,0 +1,123 @@
+import { CacheError } from '../../shared/errors';
+import { InMemoryCache } from './InMemoryCache';
+import { RedisCache } from './RedisCache';
+import { StaleWhileRevalidateCache } from './StaleWhileRevalidateCache';
+export class CacheManager {
+    constructor(options = {}) {
+        this.ttl = options.ttl || 3600;
+        this.enabled = options.strategy !== 'none';
+        switch (options.strategy) {
+            case 'memory':
+            default:
+                this.cache = new InMemoryCache(options.maxSize || 1000);
+                break;
+            case 'redis':
+                if (!options.redisClient) {
+                    throw new CacheError('Redis strategy requires a "redisClient" option. Pass your Redis client instance (ioredis, redis, etc.).');
+                }
+                this.cache = new RedisCache(options.redisClient, {
+                    keyPrefix: options.keyPrefix,
+                });
+                break;
+            case 'custom':
+                if (!options.customCache) {
+                    throw new CacheError('Custom cache implementation required');
+                }
+                this.cache = options.customCache;
+                break;
+            case 'none':
+                this.cache = new NoOpCache();
+                break;
+            case 'stale-while-revalidate':
+                this.cache = new StaleWhileRevalidateCache(options.maxSize || 1000, options.revalidateCallback);
+                break;
+        }
+    }
+    async get(key) {
+        if (!this.enabled)
+            return null;
+        try {
+            return await this.cache.get(key);
+        }
+        catch (error) {
+            console.warn('Cache get error:', error);
+            return null;
+        }
+    }
+    async set(key, value, ttl) {
+        if (!this.enabled)
+            return;
+        try {
+            await this.cache.set(key, value, ttl || this.ttl);
+        }
+        catch (error) {
+            console.warn('Cache set error:', error);
+        }
+    }
+    async delete(key) {
+        if (!this.enabled)
+            return;
+        try {
+            await this.cache.delete(key);
+        }
+        catch (error) {
+            console.warn('Cache delete error:', error);
+        }
+    }
+    async clear() {
+        if (!this.enabled)
+            return;
+        try {
+            await this.cache.clear();
+        }
+        catch (error) {
+            console.warn('Cache clear error:', error);
+        }
+    }
+    async has(key) {
+        if (!this.enabled)
+            return false;
+        try {
+            return await this.cache.has(key);
+        }
+        catch (error) {
+            console.warn('Cache has error:', error);
+            return false;
+        }
+    }
+    async size() {
+        if (!this.enabled)
+            return 0;
+        try {
+            return await this.cache.size();
+        }
+        catch (error) {
+            console.warn('Cache size error:', error);
+            return 0;
+        }
+    }
+    async getStats() {
+        return {
+            size: await this.size(),
+            enabled: this.enabled,
+            ttl: this.ttl,
+        };
+    }
+}
+class NoOpCache {
+    async get() {
+        return null;
+    }
+    async set() {
+    }
+    async delete() {
+    }
+    async clear() {
+    }
+    async has() {
+        return false;
+    }
+    async size() {
+        return 0;
+    }
+}

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

@@ -0,0 +1,91 @@
+export class InMemoryCache {
+    constructor(maxSize = 1000) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+        this.accessOrder = [];
+    }
+    async get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return null;
+        }
+        if (Date.now() > entry.expiresAt) {
+            await this.delete(key);
+            return null;
+        }
+        this.updateAccessOrder(key);
+        return entry.value;
+    }
+    async set(key, value, ttl = 3600) {
+        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+            await this.evictLRU();
+        }
+        const expiresAt = Date.now() + ttl * 1000;
+        this.cache.set(key, {
+            value,
+            expiresAt,
+        });
+        this.updateAccessOrder(key);
+    }
+    async delete(key) {
+        this.cache.delete(key);
+        this.removeFromAccessOrder(key);
+    }
+    async clear() {
+        this.cache.clear();
+        this.accessOrder = [];
+    }
+    async has(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return false;
+        }
+        if (Date.now() > entry.expiresAt) {
+            await this.delete(key);
+            return false;
+        }
+        return true;
+    }
+    async size() {
+        await this.cleanupExpired();
+        return this.cache.size;
+    }
+    updateAccessOrder(key) {
+        this.removeFromAccessOrder(key);
+        this.accessOrder.push(key);
+    }
+    removeFromAccessOrder(key) {
+        const index = this.accessOrder.indexOf(key);
+        if (index > -1) {
+            this.accessOrder.splice(index, 1);
+        }
+    }
+    async evictLRU() {
+        if (this.accessOrder.length === 0) {
+            return;
+        }
+        const lruKey = this.accessOrder[0];
+        if (lruKey) {
+            await this.delete(lruKey);
+        }
+    }
+    async cleanupExpired() {
+        const now = Date.now();
+        const expiredKeys = [];
+        for (const [key, entry] of this.cache.entries()) {
+            if (now > entry.expiresAt) {
+                expiredKeys.push(key);
+            }
+        }
+        for (const key of expiredKeys) {
+            await this.delete(key);
+        }
+    }
+    async getStats() {
+        await this.cleanupExpired();
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+        };
+    }
+}