rdapify 0.2.3 → 0.3.1

package/dist/esm/infrastructure/monitoring/MetricsCollector.js

@@ -0,0 +1,284 @@
+export class MetricsCollector {
+    constructor(options = {}) {
+        this.metrics = [];
+        this.enabled = options.enabled ?? true;
+        this.maxMetrics = options.maxMetrics || 10000;
+    }
+    record(metric) {
+        if (!this.enabled)
+            return;
+        this.metrics.push(metric);
+        if (this.metrics.length > this.maxMetrics) {
+            this.metrics = this.metrics.slice(-this.maxMetrics);
+        }
+    }
+    calculatePercentile(sorted, p) {
+        if (sorted.length === 0)
+            return 0;
+        if (sorted.length === 1)
+            return sorted[0];
+        const index = p * (sorted.length - 1);
+        const lower = Math.floor(index);
+        const upper = Math.ceil(index);
+        const fraction = index - lower;
+        const lowerVal = sorted[lower] ?? 0;
+        const upperVal = sorted[upper] ?? 0;
+        return lowerVal + fraction * (upperVal - lowerVal);
+    }
+    getSummary(since) {
+        const relevantMetrics = since
+            ? this.metrics.filter((m) => m.timestamp >= since)
+            : this.metrics;
+        if (relevantMetrics.length === 0) {
+            return this.getEmptySummary();
+        }
+        const successful = relevantMetrics.filter((m) => m.success).length;
+        const failed = relevantMetrics.length - successful;
+        const cached = relevantMetrics.filter((m) => m.cached).length;
+        const durations = relevantMetrics.map((m) => m.duration);
+        const totalDuration = durations.reduce((a, b) => a + b, 0);
+        const avgResponseTime = durations.length > 0 ? totalDuration / durations.length : 0;
+        const minResponseTime = durations.length > 0 ? Math.min(...durations) : 0;
+        const maxResponseTime = durations.length > 0 ? Math.max(...durations) : 0;
+        const sorted = [...durations].sort((a, b) => a - b);
+        const p50ResponseTime = this.calculatePercentile(sorted, 0.5);
+        const p90ResponseTime = this.calculatePercentile(sorted, 0.9);
+        const p99ResponseTime = this.calculatePercentile(sorted, 0.99);
+        const queriesByType = {
+            domain: relevantMetrics.filter((m) => m.type === 'domain').length,
+            ip: relevantMetrics.filter((m) => m.type === 'ip').length,
+            asn: relevantMetrics.filter((m) => m.type === 'asn').length,
+        };
+        const errorsByType = {};
+        relevantMetrics
+            .filter((m) => !m.success && m.error)
+            .forEach((m) => {
+            const errorType = m.error;
+            errorsByType[errorType] = (errorsByType[errorType] || 0) + 1;
+        });
+        return {
+            total: relevantMetrics.length,
+            successful,
+            failed,
+            successRate: relevantMetrics.length > 0 ? (successful / relevantMetrics.length) * 100 : 0,
+            avgResponseTime,
+            minResponseTime,
+            maxResponseTime,
+            p50ResponseTime,
+            p90ResponseTime,
+            p99ResponseTime,
+            cacheHitRate: relevantMetrics.length > 0 ? (cached / relevantMetrics.length) * 100 : 0,
+            totalDuration,
+            queriesByType,
+            errorsByType,
+        };
+    }
+    getPercentiles(since) {
+        const relevantMetrics = since
+            ? this.metrics.filter((m) => m.timestamp >= since)
+            : this.metrics;
+        if (relevantMetrics.length === 0) {
+            return { p50: 0, p75: 0, p90: 0, p95: 0, p99: 0, p999: 0 };
+        }
+        const sorted = relevantMetrics.map((m) => m.duration).sort((a, b) => a - b);
+        return {
+            p50: this.calculatePercentile(sorted, 0.5),
+            p75: this.calculatePercentile(sorted, 0.75),
+            p90: this.calculatePercentile(sorted, 0.9),
+            p95: this.calculatePercentile(sorted, 0.95),
+            p99: this.calculatePercentile(sorted, 0.99),
+            p999: this.calculatePercentile(sorted, 0.999),
+        };
+    }
+    getRegistryStats() {
+        const groups = new Map();
+        for (const m of this.metrics) {
+            const key = m.serverUrl ?? 'unknown';
+            const group = groups.get(key);
+            if (group) {
+                group.push(m);
+            }
+            else {
+                groups.set(key, [m]);
+            }
+        }
+        const result = {};
+        for (const [key, group] of groups) {
+            const successful = group.filter((m) => m.success).length;
+            const cached = group.filter((m) => m.cached).length;
+            const durations = group.map((m) => m.duration);
+            const totalDuration = durations.reduce((a, b) => a + b, 0);
+            const sorted = [...durations].sort((a, b) => a - b);
+            result[key] = {
+                server: key,
+                total: group.length,
+                successful,
+                failed: group.length - successful,
+                avgDuration: group.length > 0 ? totalDuration / group.length : 0,
+                p90Duration: this.calculatePercentile(sorted, 0.9),
+                cacheHitRate: group.length > 0 ? (cached / group.length) * 100 : 0,
+            };
+        }
+        return result;
+    }
+    getTopQueries(limit = 10, since) {
+        const relevantMetrics = since
+            ? this.metrics.filter((m) => m.timestamp >= since)
+            : this.metrics;
+        const groups = new Map();
+        for (const m of relevantMetrics) {
+            const group = groups.get(m.query);
+            if (group) {
+                group.push(m);
+            }
+            else {
+                groups.set(m.query, [m]);
+            }
+        }
+        return Array.from(groups.entries())
+            .map(([query, group]) => {
+            const totalDuration = group.reduce((a, m) => a + m.duration, 0);
+            const failed = group.filter((m) => !m.success).length;
+            return {
+                query,
+                type: group[0].type,
+                count: group.length,
+                avgDuration: totalDuration / group.length,
+                errorRate: (failed / group.length) * 100,
+            };
+        })
+            .sort((a, b) => b.count - a.count)
+            .slice(0, limit);
+    }
+    getErrorHistogram(since) {
+        const relevantMetrics = since
+            ? this.metrics.filter((m) => m.timestamp >= since)
+            : this.metrics;
+        const failures = relevantMetrics.filter((m) => !m.success && m.error);
+        if (failures.length === 0)
+            return [];
+        const groups = new Map();
+        for (const m of failures) {
+            const key = m.error;
+            const group = groups.get(key);
+            if (group) {
+                group.push(m);
+            }
+            else {
+                groups.set(key, [m]);
+            }
+        }
+        return Array.from(groups.entries())
+            .map(([errorType, group]) => ({
+            errorType,
+            count: group.length,
+            percentage: (group.length / failures.length) * 100,
+            affectedQueries: [...new Set(group.map((m) => m.query))],
+        }))
+            .sort((a, b) => b.count - a.count);
+    }
+    exportPrometheus(prefix = 'rdapify') {
+        const summary = this.getSummary();
+        const percentiles = this.getPercentiles();
+        const errorHistogram = this.getErrorHistogram();
+        const cached = this.metrics.filter((m) => m.cached).length;
+        const lines = [];
+        lines.push(`# HELP ${prefix}_queries_total Total number of RDAP queries`);
+        lines.push(`# TYPE ${prefix}_queries_total counter`);
+        lines.push(`${prefix}_queries_total{type="domain"} ${summary.queriesByType.domain}`);
+        lines.push(`${prefix}_queries_total{type="ip"} ${summary.queriesByType.ip}`);
+        lines.push(`${prefix}_queries_total{type="asn"} ${summary.queriesByType.asn}`);
+        lines.push('');
+        lines.push(`# HELP ${prefix}_query_duration_seconds Query duration in seconds`);
+        lines.push(`# TYPE ${prefix}_query_duration_seconds summary`);
+        lines.push(`${prefix}_query_duration_seconds{quantile="0.5"} ${(percentiles.p50 / 1000).toFixed(3)}`);
+        lines.push(`${prefix}_query_duration_seconds{quantile="0.9"} ${(percentiles.p90 / 1000).toFixed(3)}`);
+        lines.push(`${prefix}_query_duration_seconds{quantile="0.99"} ${(percentiles.p99 / 1000).toFixed(3)}`);
+        lines.push('');
+        lines.push(`# HELP ${prefix}_cache_hits_total Total cache hits`);
+        lines.push(`# TYPE ${prefix}_cache_hits_total counter`);
+        lines.push(`${prefix}_cache_hits_total ${cached}`);
+        lines.push('');
+        lines.push(`# HELP ${prefix}_errors_total Total errors by type`);
+        lines.push(`# TYPE ${prefix}_errors_total counter`);
+        for (const entry of errorHistogram) {
+            lines.push(`${prefix}_errors_total{type="${entry.errorType}"} ${entry.count}`);
+        }
+        return lines.join('\n');
+    }
+    exportCSV() {
+        const header = 'timestamp,type,query,success,duration,cached,serverUrl,error';
+        const escapeCSV = (val) => {
+            if (val.includes(',') || val.includes('"') || val.includes('\n')) {
+                return `"${val.replace(/"/g, '""')}"`;
+            }
+            return val;
+        };
+        const rows = this.metrics.map((m) => {
+            const fields = [
+                String(m.timestamp),
+                m.type,
+                escapeCSV(m.query),
+                String(m.success),
+                String(m.duration),
+                String(m.cached),
+                m.serverUrl ?? '',
+                m.error ?? '',
+            ];
+            return fields.join(',');
+        });
+        return [header, ...rows].join('\n');
+    }
+    getRecent(count = 10) {
+        return this.metrics.slice(-count);
+    }
+    getWindow(startTime, endTime) {
+        return this.metrics.filter((m) => m.timestamp >= startTime && m.timestamp <= endTime);
+    }
+    getByType(type) {
+        return this.metrics.filter((m) => m.type === type);
+    }
+    getFailures() {
+        return this.metrics.filter((m) => !m.success);
+    }
+    clear() {
+        this.metrics = [];
+    }
+    getEmptySummary() {
+        return {
+            total: 0,
+            successful: 0,
+            failed: 0,
+            successRate: 0,
+            avgResponseTime: 0,
+            minResponseTime: 0,
+            maxResponseTime: 0,
+            p50ResponseTime: 0,
+            p90ResponseTime: 0,
+            p99ResponseTime: 0,
+            cacheHitRate: 0,
+            totalDuration: 0,
+            queriesByType: {
+                domain: 0,
+                ip: 0,
+                asn: 0,
+            },
+            errorsByType: {},
+        };
+    }
+    export() {
+        return [...this.metrics];
+    }
+    import(metrics) {
+        this.metrics = metrics.slice(-this.maxMetrics);
+    }
+    getStats() {
+        return {
+            enabled: this.enabled,
+            totalMetrics: this.metrics.length,
+            maxMetrics: this.maxMetrics,
+            oldestMetric: this.metrics[0]?.timestamp,
+            newestMetric: this.metrics[this.metrics.length - 1]?.timestamp,
+        };
+    }
+}

package/dist/esm/infrastructure/monitoring/PrometheusExporter.js

@@ -0,0 +1,72 @@
+const CONTENT_TYPE = 'text/plain; version=0.0.4; charset=utf-8';
+export class PrometheusExporter {
+    constructor(getMetrics, options = {}) {
+        this.getMetrics = getMetrics;
+        this.prefix = options.prefix ?? 'rdapify';
+        this.labels = options.labels ?? {};
+    }
+    export() {
+        const m = this.getMetrics();
+        const lbl = this.formatLabels(this.labels);
+        const p = this.prefix;
+        const lines = [];
+        const gauge = (name, help, value, extraLabels = {}) => {
+            const fullName = `${p}_${name}`;
+            lines.push(`# HELP ${fullName} ${help}`);
+            lines.push(`# TYPE ${fullName} gauge`);
+            lines.push(`${fullName}${this.formatLabels({ ...this.labels, ...extraLabels })} ${value}`);
+        };
+        const counter = (name, help, value, extraLabels = {}) => {
+            const fullName = `${p}_${name}`;
+            lines.push(`# HELP ${fullName} ${help}`);
+            lines.push(`# TYPE ${fullName} counter`);
+            lines.push(`${fullName}_total${this.formatLabels({ ...this.labels, ...extraLabels })} ${value}`);
+        };
+        counter('queries', 'Total number of RDAP queries executed', m.total);
+        counter('queries_successful', 'Total number of successful RDAP queries', m.successful);
+        counter('queries_failed', 'Total number of failed RDAP queries', m.failed);
+        const types = Object.entries(m.queriesByType);
+        const fullTypeName = `${p}_queries_by_type_total`;
+        lines.push(`# HELP ${fullTypeName} Total RDAP queries broken down by query type`);
+        lines.push(`# TYPE ${fullTypeName} counter`);
+        for (const [type, count] of types) {
+            lines.push(`${fullTypeName}${this.formatLabels({ ...this.labels, type })} ${count}`);
+        }
+        gauge('success_rate', 'Fraction of successful queries (0–1)', m.successRate);
+        gauge('cache_hit_rate', 'Fraction of queries served from cache (0–1)', m.cacheHitRate);
+        gauge('response_time_avg_ms', 'Average RDAP query response time in milliseconds', m.avgResponseTime);
+        gauge('response_time_min_ms', 'Minimum RDAP query response time in milliseconds', m.minResponseTime);
+        gauge('response_time_max_ms', 'Maximum RDAP query response time in milliseconds', m.maxResponseTime);
+        gauge('response_time_p50_ms', 'P50 (median) RDAP query response time in milliseconds', m.p50ResponseTime);
+        gauge('response_time_p90_ms', 'P90 RDAP query response time in milliseconds', m.p90ResponseTime);
+        gauge('response_time_p99_ms', 'P99 RDAP query response time in milliseconds', m.p99ResponseTime);
+        const errorEntries = Object.entries(m.errorsByType);
+        if (errorEntries.length > 0) {
+            const fullErrName = `${p}_errors_by_type_total`;
+            lines.push(`# HELP ${fullErrName} Total RDAP errors broken down by error type`);
+            lines.push(`# TYPE ${fullErrName} counter`);
+            for (const [errorType, count] of errorEntries) {
+                lines.push(`${fullErrName}${this.formatLabels({ ...this.labels, error_type: errorType })} ${count}`);
+            }
+        }
+        void lbl;
+        return lines.join('\n') + '\n';
+    }
+    createHttpHandler() {
+        return (_req, res) => {
+            res.setHeader('Content-Type', CONTENT_TYPE);
+            res.end(this.export());
+        };
+    }
+    formatLabels(labels) {
+        const entries = Object.entries(labels);
+        if (entries.length === 0)
+            return '';
+        const pairs = entries.map(([k, v]) => `${k}="${this.escapeLabel(v)}"`).join(',');
+        return `{${pairs}}`;
+    }
+    escapeLabel(value) {
+        return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+    }
+}
+PrometheusExporter.CONTENT_TYPE = CONTENT_TYPE;

package/dist/esm/infrastructure/monitoring/TelemetryExporter.js

@@ -0,0 +1,112 @@
+const RDAPIFY_VERSION = '0.2.3';
+export class TelemetryExporter {
+    constructor(options) {
+        this.endpoint = options.endpoint ?? '';
+        this.serviceName = options.serviceName ?? 'rdapify';
+        this.serviceVersion = options.serviceVersion ?? RDAPIFY_VERSION;
+        this.resourceAttributes = options.resourceAttributes ?? {};
+        this.enabled = options.enabled !== false && Boolean(this.endpoint);
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    async exportSpans(spans) {
+        if (!this.enabled || spans.length === 0)
+            return;
+        const payload = this.buildOtlpPayload(spans);
+        try {
+            const body = JSON.stringify(payload);
+            await this.sendRequest(body);
+        }
+        catch {
+        }
+    }
+    startSpan(name, attributes, parentSpanId) {
+        const span = {
+            traceId: this.generateId(16),
+            spanId: this.generateId(8),
+            parentSpanId,
+            name,
+            startTimeUnixNano: this.nowNano(),
+            endTimeUnixNano: '0',
+            attributes: attributes ? this.encodeAttributes(attributes) : [],
+        };
+        return span;
+    }
+    async endSpan(span, status = { code: 0 }) {
+        span.endTimeUnixNano = this.nowNano();
+        span.status = status;
+        await this.exportSpans([span]);
+    }
+    buildOtlpPayload(spans) {
+        const resourceAttrs = this.encodeAttributes({
+            'service.name': this.serviceName,
+            'service.version': this.serviceVersion,
+            'telemetry.sdk.name': 'rdapify',
+            'telemetry.sdk.language': 'javascript',
+            ...this.resourceAttributes,
+        });
+        return {
+            resourceSpans: [
+                {
+                    resource: { attributes: resourceAttrs },
+                    scopeSpans: [
+                        {
+                            scope: { name: 'rdapify', version: this.serviceVersion },
+                            spans: spans.map((s) => ({
+                                traceId: s.traceId,
+                                spanId: s.spanId,
+                                parentSpanId: s.parentSpanId,
+                                name: s.name,
+                                kind: 3,
+                                startTimeUnixNano: s.startTimeUnixNano,
+                                endTimeUnixNano: s.endTimeUnixNano,
+                                attributes: s.attributes ?? [],
+                                status: s.status ?? { code: 0 },
+                            })),
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    encodeAttributes(attrs) {
+        return Object.entries(attrs).map(([key, value]) => {
+            if (typeof value === 'boolean') {
+                return { key, value: { boolValue: value } };
+            }
+            else if (typeof value === 'number') {
+                return { key, value: { intValue: value } };
+            }
+            else {
+                return { key, value: { stringValue: String(value) } };
+            }
+        });
+    }
+    async sendRequest(body) {
+        const fetchFn = typeof globalThis !== 'undefined' && typeof globalThis['fetch'] === 'function'
+            ? globalThis['fetch']
+            : (() => { throw new Error('No fetch available'); })();
+        const response = await fetchFn(this.endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            },
+            body,
+        });
+        if (!response.ok) {
+            throw new Error(`OTLP export failed: ${response.status} ${response.statusText}`);
+        }
+    }
+    generateId(bytes) {
+        const hex = [];
+        for (let i = 0; i < bytes * 2; i++) {
+            hex.push(Math.floor(Math.random() * 16).toString(16));
+        }
+        return hex.join('');
+    }
+    nowNano() {
+        return (BigInt(Date.now()) * BigInt(1000000)).toString();
+    }
+}

package/dist/esm/infrastructure/native/NativeBackend.js

@@ -0,0 +1,86 @@
+let _module;
+function tryLoadCore() {
+    if (_module !== undefined)
+        return _module;
+    try {
+        _module = require('rdapify-nd');
+    }
+    catch {
+        _module = null;
+    }
+    return _module;
+}
+export function isNativeAvailable() {
+    return tryLoadCore() !== null;
+}
+function adaptMeta(raw) {
+    const meta = (raw['meta'] ?? {});
+    return {
+        source: meta['source'] ?? '',
+        timestamp: meta['queried_at'] ?? '',
+        cached: meta['cached'] ?? false,
+    };
+}
+function strippedFields(raw) {
+    const { meta: _meta, objectClass: _oc, ...rest } = raw;
+    void _meta;
+    void _oc;
+    return rest;
+}
+export class NativeBackend {
+    constructor(core) {
+        this.core = core;
+    }
+    static create(mode) {
+        const core = tryLoadCore();
+        if (!core) {
+            if (mode === 'native') {
+                throw new Error('rdapify-nd is not installed. Run: npm install rdapify-nd\n' +
+                    'Or use backend: "auto" to fall back to the TypeScript backend.');
+            }
+            return null;
+        }
+        return new NativeBackend(core);
+    }
+    async domain(query) {
+        const raw = (await this.core.domain(query));
+        return {
+            ...strippedFields(raw),
+            objectClass: 'domain',
+            metadata: adaptMeta(raw),
+        };
+    }
+    async ip(query) {
+        const raw = (await this.core.ip(query));
+        return {
+            ...strippedFields(raw),
+            objectClass: 'ip network',
+            metadata: adaptMeta(raw),
+        };
+    }
+    async asn(query) {
+        const raw = (await this.core.asn(String(query)));
+        return {
+            ...strippedFields(raw),
+            query: String(raw['query']),
+            objectClass: 'autnum',
+            metadata: adaptMeta(raw),
+        };
+    }
+    async nameserver(query) {
+        const raw = (await this.core.nameserver(query));
+        return {
+            ...strippedFields(raw),
+            objectClass: 'nameserver',
+            metadata: adaptMeta(raw),
+        };
+    }
+    async entity(handle, serverUrl) {
+        const raw = (await this.core.entity(handle, serverUrl));
+        return {
+            ...strippedFields(raw),
+            objectClass: 'entity',
+            metadata: adaptMeta(raw),
+        };
+    }
+}

package/dist/esm/infrastructure/security/PIIRedactor.js

@@ -0,0 +1,85 @@
+export class PIIRedactor {
+    constructor(options = {}) {
+        this.options = {
+            redactPII: options.redactPII ?? true,
+            redactFields: options.redactFields || ['email', 'phone', 'fax'],
+            redactionText: options.redactionText || '[REDACTED]',
+        };
+    }
+    redact(response) {
+        if (!this.options.redactPII) {
+            return response;
+        }
+        let redacted;
+        try {
+            redacted = structuredClone(response);
+        }
+        catch {
+            const jsonString = JSON.stringify(response);
+            redacted = JSON.parse(jsonString);
+        }
+        if (redacted.entities && Array.isArray(redacted.entities)) {
+            redacted.entities = redacted.entities.map((entity) => this.redactEntity(entity));
+        }
+        return redacted;
+    }
+    redactEntity(entity) {
+        const redacted = { ...entity };
+        if (redacted.vcardArray && Array.isArray(redacted.vcardArray)) {
+            redacted.vcardArray = this.redactVCard(redacted.vcardArray);
+        }
+        if (redacted.entities && Array.isArray(redacted.entities)) {
+            redacted.entities = redacted.entities.map((e) => this.redactEntity(e));
+        }
+        return redacted;
+    }
+    redactVCard(vcardArray) {
+        if (!Array.isArray(vcardArray) || vcardArray.length < 2) {
+            return vcardArray;
+        }
+        const [version, fields] = vcardArray;
+        if (!Array.isArray(fields)) {
+            return vcardArray;
+        }
+        const redactedFields = fields.map((field) => {
+            if (!Array.isArray(field) || field.length < 4) {
+                return field;
+            }
+            const [fieldName, params, type] = field;
+            if (this.shouldRedactField(fieldName)) {
+                return [fieldName, params, type, this.options.redactionText];
+            }
+            return field;
+        });
+        return [version, redactedFields];
+    }
+    shouldRedactField(fieldName) {
+        const normalizedName = fieldName.toLowerCase();
+        for (const field of this.options.redactFields) {
+            if (normalizedName === field.toLowerCase() || normalizedName.includes(field.toLowerCase())) {
+                return true;
+            }
+        }
+        const piiPatterns = [
+            'email',
+            'tel',
+            'phone',
+            'fax',
+            'adr',
+            'address',
+            'geo',
+            'key',
+            'photo',
+            'sound',
+            'uid',
+            'url',
+        ];
+        return piiPatterns.some((pattern) => normalizedName === pattern || normalizedName.includes(pattern));
+    }
+    getConfig() {
+        return { ...this.options, redactFields: [...this.options.redactFields] };
+    }
+    isEnabled() {
+        return this.options.redactPII;
+    }
+}