rdapify 0.3.0 → 0.3.1

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

@@ -0,0 +1,162 @@
+import * as dns from 'dns';
+import { SSRFProtectionError } from '../../shared/types/errors';
+import { isPrivateIP, isLocalhost, isLinkLocal, validateIP } from '../../shared/utils/validators';
+export class SSRFProtection {
+    constructor(options = {}) {
+        this.options = {
+            enabled: options.enabled ?? true,
+            blockPrivateIPs: options.blockPrivateIPs ?? true,
+            blockLocalhost: options.blockLocalhost ?? true,
+            blockLinkLocal: options.blockLinkLocal ?? true,
+            blockedDomains: options.blockedDomains || [],
+            allowedDomains: options.allowedDomains || [],
+            dnsRebinding: options.dnsRebinding ?? false,
+        };
+    }
+    async validateUrl(url) {
+        if (!this.options.enabled) {
+            return;
+        }
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(url);
+        }
+        catch {
+            throw new SSRFProtectionError(`Invalid URL: ${url}`);
+        }
+        if (parsedUrl.protocol !== 'https:') {
+            throw new SSRFProtectionError(`Only HTTPS protocol is allowed, got: ${parsedUrl.protocol}`, {
+                url,
+            });
+        }
+        const hostname = parsedUrl.hostname.toLowerCase();
+        if (this.options.allowedDomains.length > 0) {
+            const isAllowed = this.options.allowedDomains.some((domain) => hostname === domain.toLowerCase() || hostname.endsWith(`.${domain.toLowerCase()}`));
+            if (!isAllowed) {
+                throw new SSRFProtectionError(`Domain not in allowed list: ${hostname}`, { url, hostname });
+            }
+            return;
+        }
+        if (this.options.blockedDomains.length > 0) {
+            const isBlocked = this.options.blockedDomains.some((domain) => hostname === domain.toLowerCase() || hostname.endsWith(`.${domain.toLowerCase()}`));
+            if (isBlocked) {
+                throw new SSRFProtectionError(`Domain is blocked: ${hostname}`, { url, hostname });
+            }
+        }
+        if (this.isIPAddress(hostname)) {
+            await this.validateIPAddress(hostname, url);
+        }
+        else {
+            await this.validateDomain(hostname, url);
+        }
+    }
+    async validateIPAddress(ip, url) {
+        const zoneIndex = ip.indexOf('%');
+        const ipWithoutZone = zoneIndex > 0 ? ip.substring(0, zoneIndex) : ip;
+        const ipClean = ipWithoutZone.replace(/^\[|\]$/g, '');
+        try {
+            validateIP(ipClean);
+        }
+        catch {
+            throw new SSRFProtectionError(`Invalid IP address: ${ip}`, { url, ip });
+        }
+        if (this.options.blockLocalhost && isLocalhost(ipClean)) {
+            throw new SSRFProtectionError(`Localhost IP addresses are blocked: ${ip}`, {
+                url,
+                ip,
+                reason: 'localhost',
+            });
+        }
+        if (this.options.blockPrivateIPs && isPrivateIP(ipClean)) {
+            throw new SSRFProtectionError(`Private IP addresses are blocked: ${ip}`, {
+                url,
+                ip,
+                reason: 'private',
+            });
+        }
+        if (this.options.blockLinkLocal && isLinkLocal(ipClean)) {
+            throw new SSRFProtectionError(`Link-local IP addresses are blocked: ${ip}`, {
+                url,
+                ip,
+                reason: 'link-local',
+            });
+        }
+    }
+    async validateDomain(hostname, url) {
+        if (this.options.blockLocalhost) {
+            const localhostPatterns = ['localhost', 'localhost.localdomain', '*.localhost'];
+            for (const pattern of localhostPatterns) {
+                if (this.matchesPattern(hostname, pattern)) {
+                    throw new SSRFProtectionError(`Localhost domains are blocked: ${hostname}`, {
+                        url,
+                        hostname,
+                        reason: 'localhost',
+                    });
+                }
+            }
+        }
+        const internalDomains = [
+            'internal',
+            'corp',
+            'local',
+            'lan',
+            'intranet',
+            '*.internal',
+            '*.corp',
+            '*.local',
+            '*.lan',
+            '*.intranet',
+        ];
+        for (const pattern of internalDomains) {
+            if (this.matchesPattern(hostname, pattern)) {
+                throw new SSRFProtectionError(`Internal domains are blocked: ${hostname}`, {
+                    url,
+                    hostname,
+                    reason: 'internal',
+                });
+            }
+        }
+        if (this.options.dnsRebinding) {
+            await this.validateDnsRebinding(hostname, url);
+        }
+    }
+    async validateDnsRebinding(hostname, url) {
+        let ipv4Addresses = [];
+        let ipv6Addresses = [];
+        try {
+            ipv4Addresses = await dns.promises.resolve4(hostname);
+        }
+        catch {
+        }
+        try {
+            ipv6Addresses = await dns.promises.resolve6(hostname);
+        }
+        catch {
+        }
+        for (const ip of [...ipv4Addresses, ...ipv6Addresses]) {
+            await this.validateIPAddress(ip, url);
+        }
+    }
+    isIPAddress(hostname) {
+        if (/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(hostname)) {
+            return true;
+        }
+        if (hostname.includes(':')) {
+            return true;
+        }
+        return false;
+    }
+    matchesPattern(hostname, pattern) {
+        if (pattern.startsWith('*.')) {
+            const suffix = pattern.substring(2);
+            return hostname === suffix || hostname.endsWith(`.${suffix}`);
+        }
+        return hostname === pattern;
+    }
+    getConfig() {
+        return { ...this.options };
+    }
+    isEnabled() {
+        return this.options.enabled;
+    }
+}

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

@@ -0,0 +1,2 @@
+export { SSRFProtection } from './SSRFProtection';
+export { PIIRedactor } from './PIIRedactor';

package/dist/esm/infrastructure/telemetry/UsageTelemetry.js

@@ -0,0 +1,84 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+export class UsageTelemetry {
+    static getPayload() {
+        const cfg = UsageTelemetry.loadConfig();
+        return {
+            installId: cfg.installId,
+            rdapifyVersion: '0.3.1',
+            nodeVersion: process.version,
+            platform: process.platform,
+            queryTypesUsed: cfg.queryTypesUsed,
+            sessionCount: cfg.sessionCount,
+        };
+    }
+    static async ping(queryType, endpoint) {
+        const cfg = UsageTelemetry.loadConfig();
+        if (!cfg.enabled)
+            return;
+        if (!cfg.queryTypesUsed.includes(queryType)) {
+            cfg.queryTypesUsed.push(queryType);
+        }
+        UsageTelemetry.saveConfig(cfg);
+        try {
+            const url = endpoint ?? UsageTelemetry.DEFAULT_ENDPOINT;
+            const payload = UsageTelemetry.getPayload();
+            fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal: AbortSignal.timeout(5000),
+            }).catch(() => { });
+        }
+        catch { }
+    }
+    static enable() {
+        const cfg = UsageTelemetry.loadConfig();
+        cfg.enabled = true;
+        UsageTelemetry.saveConfig(cfg);
+    }
+    static disable() {
+        const cfg = UsageTelemetry.loadConfig();
+        cfg.enabled = false;
+        UsageTelemetry.saveConfig(cfg);
+    }
+    static reset() {
+        try {
+            fs.rmSync(UsageTelemetry.CONFIG_PATH, { force: true });
+        }
+        catch { }
+        UsageTelemetry.config = null;
+    }
+    static loadConfig() {
+        if (UsageTelemetry.config)
+            return UsageTelemetry.config;
+        try {
+            const raw = fs.readFileSync(UsageTelemetry.CONFIG_PATH, 'utf-8');
+            UsageTelemetry.config = JSON.parse(raw);
+        }
+        catch {
+            UsageTelemetry.config = {
+                installId: crypto.randomUUID(),
+                sessionCount: 0,
+                queryTypesUsed: [],
+                enabled: false,
+            };
+            UsageTelemetry.saveConfig(UsageTelemetry.config);
+        }
+        return UsageTelemetry.config;
+    }
+    static saveConfig(cfg) {
+        try {
+            const dir = path.dirname(UsageTelemetry.CONFIG_PATH);
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(UsageTelemetry.CONFIG_PATH, JSON.stringify(cfg, null, 2));
+            UsageTelemetry.config = cfg;
+        }
+        catch { }
+    }
+}
+UsageTelemetry.CONFIG_PATH = path.join(os.homedir(), '.rdapify', 'telemetry.json');
+UsageTelemetry.DEFAULT_ENDPOINT = 'https://telemetry.rdapify.com/v1/ping';
+UsageTelemetry.config = null;

package/dist/esm/infrastructure/validation/ResponseValidator.js

@@ -0,0 +1,194 @@
+import { RDAPifyError } from '../../shared/errors/base.error';
+export class ResponseValidationError extends RDAPifyError {
+    constructor(validationResult) {
+        const errorMessages = validationResult.errors.map((e) => e.message).join('; ');
+        super(`RDAP response validation failed: ${errorMessages}`, 'RESPONSE_VALIDATION_ERROR', 422, { errorCount: validationResult.errors.length });
+        this.validationResult = validationResult;
+    }
+}
+export class ResponseValidator {
+    constructor(options) {
+        this.mode = options?.mode ?? 'lenient';
+        this.onViolation = options?.onViolation ?? 'warn';
+    }
+    validateDomain(response) {
+        const result = { valid: true, errors: [], warnings: [] };
+        if (this.mode === 'off') {
+            return result;
+        }
+        if (response.objectClass !== 'domain') {
+            result.errors.push({
+                field: 'objectClass',
+                message: `Expected objectClass 'domain', got '${response.objectClass}'`,
+                severity: 'error',
+            });
+        }
+        if (!response.query || typeof response.query !== 'string' || response.query.trim() === '') {
+            result.errors.push({
+                field: 'query',
+                message: 'Field "query" must be a non-empty string',
+                severity: 'error',
+            });
+        }
+        if (response.ldhName === undefined || response.ldhName === null) {
+            result.warnings.push({
+                field: 'ldhName',
+                message: 'Field "ldhName" is recommended for domain responses (RFC 7483 §5.3)',
+                severity: 'warning',
+            });
+        }
+        if (response.status !== undefined && !Array.isArray(response.status)) {
+            result.warnings.push({
+                field: 'status',
+                message: 'Field "status" should be an array',
+                severity: 'warning',
+            });
+        }
+        if (response.events !== undefined) {
+            response.events.forEach((event, index) => {
+                if (!event.type) {
+                    result.errors.push({
+                        field: `events[${index}].type`,
+                        message: `Event at index ${index} is missing required field "type" (eventAction)`,
+                        severity: 'error',
+                    });
+                }
+                if (!event.date) {
+                    result.errors.push({
+                        field: `events[${index}].date`,
+                        message: `Event at index ${index} is missing required field "date" (eventDate)`,
+                        severity: 'error',
+                    });
+                }
+            });
+        }
+        if (response.nameservers !== undefined) {
+            response.nameservers.forEach((ns, index) => {
+                if (!ns || typeof ns !== 'string' || ns.trim() === '') {
+                    result.errors.push({
+                        field: `nameservers[${index}]`,
+                        message: `Nameserver at index ${index} must be a non-empty ldhName string`,
+                        severity: 'error',
+                    });
+                }
+            });
+        }
+        if (response.entities !== undefined) {
+            response.entities.forEach((entity, index) => {
+                if (!entity.roles || !Array.isArray(entity.roles)) {
+                    result.warnings.push({
+                        field: `entities[${index}].roles`,
+                        message: `Entity at index ${index} should have a "roles" array`,
+                        severity: 'warning',
+                    });
+                }
+            });
+        }
+        result.valid = result.errors.length === 0;
+        return this.handleResult(result);
+    }
+    validateIP(response) {
+        const result = { valid: true, errors: [], warnings: [] };
+        if (this.mode === 'off') {
+            return result;
+        }
+        if (response.objectClass !== 'ip network') {
+            result.errors.push({
+                field: 'objectClass',
+                message: `Expected objectClass 'ip network', got '${response.objectClass}'`,
+                severity: 'error',
+            });
+        }
+        if (response.startAddress === undefined || response.startAddress === null) {
+            result.warnings.push({
+                field: 'startAddress',
+                message: 'Field "startAddress" is recommended for IP network responses (RFC 7483 §5.4)',
+                severity: 'warning',
+            });
+        }
+        if (response.endAddress === undefined || response.endAddress === null) {
+            result.warnings.push({
+                field: 'endAddress',
+                message: 'Field "endAddress" is recommended for IP network responses (RFC 7483 §5.4)',
+                severity: 'warning',
+            });
+        }
+        if (response.ipVersion !== undefined && response.ipVersion !== 'v4' && response.ipVersion !== 'v6') {
+            result.errors.push({
+                field: 'ipVersion',
+                message: `Field "ipVersion" must be 'v4' or 'v6', got '${response.ipVersion}'`,
+                severity: 'error',
+            });
+        }
+        result.valid = result.errors.length === 0;
+        return this.handleResult(result);
+    }
+    validateASN(response) {
+        const result = { valid: true, errors: [], warnings: [] };
+        if (this.mode === 'off') {
+            return result;
+        }
+        if (response.objectClass !== 'autnum') {
+            result.errors.push({
+                field: 'objectClass',
+                message: `Expected objectClass 'autnum', got '${response.objectClass}'`,
+                severity: 'error',
+            });
+        }
+        if (response.startAutnum === undefined || response.startAutnum === null) {
+            result.warnings.push({
+                field: 'startAutnum',
+                message: 'Field "startAutnum" is recommended for ASN responses (RFC 7483 §5.5)',
+                severity: 'warning',
+            });
+        }
+        result.valid = result.errors.length === 0;
+        return this.handleResult(result);
+    }
+    validate(response) {
+        if (this.mode === 'off') {
+            return { valid: true, errors: [], warnings: [] };
+        }
+        switch (response.objectClass) {
+            case 'domain':
+                return this.validateDomain(response);
+            case 'ip network':
+                return this.validateIP(response);
+            case 'autnum':
+                return this.validateASN(response);
+            default: {
+                const result = {
+                    valid: false,
+                    errors: [
+                        {
+                            field: 'objectClass',
+                            message: `Unknown objectClass: '${response.objectClass}'`,
+                            severity: 'error',
+                        },
+                    ],
+                    warnings: [],
+                };
+                return this.handleResult(result);
+            }
+        }
+    }
+    getMode() {
+        return this.mode;
+    }
+    handleResult(result) {
+        if (result.errors.length === 0) {
+            return result;
+        }
+        switch (this.onViolation) {
+            case 'throw':
+                throw new ResponseValidationError(result);
+            case 'warn':
+                result.errors.forEach((e) => {
+                    console.warn(`[RDAPify] Validation error on field "${e.field}": ${e.message}`);
+                });
+                return result;
+            case 'ignore':
+                return result;
+        }
+    }
+}

package/dist/esm/integrations/express.js

@@ -0,0 +1,43 @@
+export class MinimalRouter {
+    constructor() {
+        this.routes = [];
+    }
+    get(path, handler) {
+        this.routes.push({ path, handler });
+        return this;
+    }
+}
+export function rdapifyExpress(client, router) {
+    const r = router ?? new MinimalRouter();
+    r.get('/domain/:name', async (req, res) => {
+        try {
+            const result = await client.domain(req.params['name'] ?? '');
+            res.json(result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ error: message });
+        }
+    });
+    r.get('/ip/:address', async (req, res) => {
+        try {
+            const result = await client.ip(req.params['address'] ?? '');
+            res.json(result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ error: message });
+        }
+    });
+    r.get('/asn/:number', async (req, res) => {
+        try {
+            const result = await client.asn(req.params['number'] ?? '');
+            res.json(result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ error: message });
+        }
+    });
+    return r;
+}

package/dist/esm/integrations/graphql.js

@@ -0,0 +1,80 @@
+export const RDAPIFY_TYPE_DEFS = `
+  type DomainResponse {
+    query:         String!
+    ldhName:       String
+    registrar:     String
+    status:        [String!]!
+    expiresAt:     String
+    createdAt:     String
+    updatedAt:     String
+  }
+
+  type IpResponse {
+    query:         String!
+    country:       String
+    name:          String
+    status:        [String!]!
+    startAddress:  String
+    endAddress:    String
+  }
+
+  type AsnResponse {
+    query:         String!
+    name:          String
+    status:        [String!]!
+    startAutnum:   Int
+    endAutnum:     Int
+  }
+
+  type Query {
+    """Query RDAP information for a domain name."""
+    domain(name: String!): DomainResponse
+
+    """Query RDAP information for an IP address (IPv4 or IPv6)."""
+    ip(address: String!): IpResponse
+
+    """Query RDAP information for an Autonomous System Number."""
+    asn(number: String!): AsnResponse
+  }
+`;
+export function createRdapifySchema(client) {
+    const resolvers = {
+        Query: {
+            domain: async (_, args) => {
+                const r = await client.domain(args.name);
+                const findEvent = (type) => r.events?.find((e) => e.type === type)?.date ?? null;
+                return {
+                    query: r.query,
+                    ldhName: r.ldhName ?? null,
+                    registrar: r.registrar?.name ?? null,
+                    status: r.status ?? [],
+                    expiresAt: findEvent('expiration'),
+                    createdAt: findEvent('registration'),
+                    updatedAt: findEvent('last changed'),
+                };
+            },
+            ip: async (_, args) => {
+                const r = await client.ip(args.address);
+                return {
+                    query: r.query,
+                    country: r.country ?? null,
+                    name: r.name ?? null,
+                    status: r.status ?? [],
+                    startAddress: r.startAddress ?? null,
+                    endAddress: r.endAddress ?? null,
+                };
+            },
+            asn: async (_, args) => {
+                const r = await client.asn(args.number);
+                return {
+                    query: String(r.query),
+                    name: r.name ?? null,
+                    status: r.status ?? [],
+                    startAutnum: r.startAutnum ?? null,
+                    endAutnum: r.endAutnum ?? null,
+                };
+            },
+        },
+    };
+    return { typeDefs: RDAPIFY_TYPE_DEFS, resolvers };
+}

package/dist/esm/integrations/nestjs.js

@@ -0,0 +1,23 @@
+import { RDAPClient } from '../application/client';
+export const RDAPIFY_CLIENT_TOKEN = Symbol('RDAPIFY_CLIENT');
+export class RdapifyModule {
+    static forRoot(options = {}) {
+        const provider = {
+            provide: RDAPIFY_CLIENT_TOKEN,
+            useFactory: () => new RDAPClient(options),
+        };
+        return {
+            module: RdapifyModule,
+            providers: [provider],
+            exports: [RDAPIFY_CLIENT_TOKEN],
+        };
+    }
+}
+export function InjectRdapClient() {
+    return (_target, _propertyKey, _index) => {
+        if (typeof Reflect !== 'undefined' && typeof Reflect['defineMetadata'] === 'function') {
+            const defineMetadata = Reflect['defineMetadata'];
+            defineMetadata('self:paramtypes', RDAPIFY_CLIENT_TOKEN, _target, _propertyKey);
+        }
+    };
+}

package/dist/esm/shared/constants/http.constants.js

@@ -0,0 +1,25 @@
+export const DEFAULT_TIMEOUTS = {
+    connect: 5000,
+    request: 10000,
+    dns: 3000,
+};
+export const DEFAULT_RETRY_CONFIG = {
+    maxAttempts: 3,
+    initialDelay: 1000,
+    maxDelay: 10000,
+    backoff: 'exponential',
+};
+export const DEFAULT_REDIRECT_CONFIG = {
+    followRedirects: true,
+    maxRedirects: 5,
+};
+export const HTTP_STATUS = {
+    OK: 200,
+    BAD_REQUEST: 400,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    TIMEOUT: 408,
+    TOO_MANY_REQUESTS: 429,
+    INTERNAL_SERVER_ERROR: 500,
+    SERVICE_UNAVAILABLE: 503,
+};

package/dist/esm/shared/constants/index.js

@@ -0,0 +1,2 @@
+export * from './rdap.constants';
+export * from './http.constants';

package/dist/esm/shared/constants/rdap.constants.js

@@ -0,0 +1,17 @@
+export const DEFAULT_BOOTSTRAP_URL = 'https://data.iana.org/rdap';
+export const DEFAULT_CACHE_TTL = 3600;
+export const DEFAULT_CACHE_MAX_SIZE = 1000;
+export const BOOTSTRAP_CACHE_TTL = 86400000;
+export const DEFAULT_USER_AGENT = 'RDAPify/0.1.7 (https://github.com/rdapify/rdapify)';
+export const RDAP_CONTENT_TYPES = [
+    'application/rdap+json',
+    'application/json',
+];
+export const RDAP_OBJECT_CLASSES = [
+    'domain',
+    'ip network',
+    'autnum',
+    'nameserver',
+    'entity',
+];
+export const BOOTSTRAP_TYPES = ['dns', 'ipv4', 'ipv6', 'asn'];