@chez14/rdap-sdk 0.1.1-13

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Gunawan "chez14" Christianto <chris@christianto.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# RDAP.net SDK
+
+A TypeScript SDK for RDAP.net. Directly calls RDAP APIs from RDAP.net as the
+main RDAP Server Database.
+
+Support RDAP.net/RDAP.org here: https://about.rdap.org/
+
+References:
+- API Usage: \
+  https://www.openrdap.org/api
+
+## Installation
+
+```bash
+# Using pnpm
+pnpm add @chez14/rdap-sdk
+
+# Using npm
+npm install @chez14/rdap-sdk
+
+# Using yarn
+yarn add @chez14/rdap-sdk
+```
+
+## Usage
+
+```typescript
+import { RdapClient } from '@chez14/rdap-sdk';
+
+// Create a client
+const client = new RdapClient();
+
+// Query domain information
+const domain = await client.domain('example.com');
+console.log(domain.ldhName);
+
+// Query internationalized domain name (IDN)
+const idn = await client.domain('münchen.de');
+console.log(idn.ldhName); // Automatically converts to punycode
+
+// Query IP information
+const ip = await client.ip('8.8.8.8');
+console.log(ip.name);
+
+// Query IP network (CIDR notation)
+const network = await client.ip('2001:db8::1/128');
+console.log(network.startAddress, network.endAddress);
+
+// Query ASN information
+const asn = await client.autnum(174);
+console.log(asn.name);
+
+// Use custom base domain (default is www.rdap.net)
+const customClient = new RdapClient({
+  baseDomain: 'custom.rdap.example.com'
+});
+```
+
+## Advanced Usage
+
+### Custom Fetcher Implementation
+
+You can provide your own fetcher implementation to customize how HTTP requests
+are made. This is useful for:
+- Adding custom headers
+- Implementing custom retry logic
+- Using different HTTP clients
+- Adding request/response interceptors
+- Custom error handling
+
+```typescript
+import { RdapClient, Fetcher } from '@chez14/rdap-sdk';
+
+// Define your custom types
+interface CustomHeaders {
+  Accept: string;
+  'User-Agent': string;
+}
+
+// Implement a typed fetcher
+class CustomFetcher implements Fetcher {
+  constructor(private userAgent: string) {}
+
+  // Your implementation here
+}
+
+// Use your custom fetcher
+const client = new RdapClient({
+  fetcher: new CustomFetcher('MyApp/1.0 (https://example.com)'),
+});
+```
+
+### Type Safety
+
+The SDK is fully typed and provides interfaces for customizing request behavior.
+You can implement your own fetcher with custom types:
+
+The SDK exports these key types for customization:
+- `HttpMethod`: Supported HTTP methods ('GET' | 'POST' | 'PUT' | 'DELETE' |
+  'PATCH')
+- `FetchOptions`: Request configuration including method, URL, body, and headers
+- `FetchResponse`: Standardized response format with status, data, and headers
+- `Fetcher`: Interface for implementing custom HTTP clients
+
+Response types:
+- `DomainResponse`: Type for domain query responses
+- `IpNetworkResponse`: Type for IP network query responses
+- `AutonomousSystemResponse`: Type for ASN query responses
+
+For type safety, we recommend:
+1. Define interfaces for your request and response data
+2. Use TypeScript's strict mode
+3. Avoid using `unknown` or `any` types in your implementations
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm build
+
+# Run tests
+pnpm test
+
+# Lint
+pnpm lint
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,250 @@
+interface RdapLink {
+    value: string;
+    rel: string;
+    href: string;
+    hreflang?: string[];
+    type?: string;
+    media?: string;
+    title?: string;
+}
+interface RdapEvent {
+    eventAction: string;
+    eventActor?: string;
+    eventDate: string;
+    links?: RdapLink[];
+}
+interface RdapPublicID {
+    type: string;
+    identifier: string;
+}
+type RdapStatus = 'validated' | 'renew prohibited' | 'update prohibited' | 'transfer prohibited' | 'delete prohibited' | 'proxy' | 'private' | 'removed' | 'obscured' | 'associated' | 'active' | 'inactive' | 'locked' | 'pending create' | 'pending renew' | 'pending transfer' | 'pending update' | 'pending delete';
+type RdapNoticeAndRemarkTypes = 'result set truncated due to authorization' | 'result set truncated due to excessive load' | 'result set truncated due to unexplainable reasons' | 'object truncated due to authorization' | 'object truncated due to excessive load' | 'object truncated due to unexplainable reasons';
+interface RdapRemark {
+    title?: string;
+    type?: RdapNoticeAndRemarkTypes;
+    description: string[];
+    links?: RdapLink[];
+}
+interface RdapDsData {
+    keyTag?: number;
+    algorithm?: number;
+    digest?: string;
+    digestType?: string;
+    events?: RdapEvent[];
+    links?: RdapLink[];
+}
+interface RdapKeyData {
+    flags?: number;
+    protocol?: number;
+    publicKey?: string;
+    algorithm?: number;
+    events?: RdapEvent[];
+    links?: RdapLink[];
+}
+interface RdapSecureDNS {
+    zoneSigned?: boolean;
+    delegationSigned?: boolean;
+    maxSigLife?: number;
+    dsData?: RdapDsData[];
+    keyData?: RdapKeyData[];
+}
+type RdapNotice = RdapRemark;
+type RdapObjectClass = RdapEntityObjectClass | RdapNameserverObjectClass | RdapDomainObjectClass;
+interface RdapEntityObjectClass {
+    objectClassName: 'entity';
+    handle?: string;
+    vcardArray?: any[];
+    roles?: string[];
+    publicIds?: RdapPublicID[];
+    entities?: RdapEntityObjectClass[];
+    remarks?: RdapRemark[];
+    links?: RdapLink[];
+    events?: RdapEvent[];
+    asEventActor?: Omit<RdapEvent, 'eventActor'>[];
+    status?: RdapStatus[];
+    port43?: string;
+    networks?: RdapIPNetworkObjectClass[];
+    autnums?: RdapAutonomousSystemNumberObjectClass[];
+}
+interface RdapNameserverObjectClass {
+    objectClassName: 'nameserver';
+    handle?: string;
+    ldhName?: string;
+    unicodeName?: string;
+    ipAddresses?: {
+        v6: string[];
+        v4: string[];
+    };
+    entities?: RdapEntityObjectClass[];
+    status?: RdapStatus[];
+    remarks?: RdapRemark[];
+    links?: RdapLink[];
+    port43?: string;
+    events?: RdapEvent[];
+}
+interface RdapDomainObjectClass {
+    objectClassName: 'domain';
+    handle?: string;
+    ldhName?: string;
+    unicodeName?: string;
+    variants: {
+        relation: string[];
+        idnTable: string;
+        variantName: {
+            ldhName: string;
+            unicodeName: string;
+        }[];
+    }[];
+    nameservers: RdapNameserverObjectClass[];
+    secureDNS: RdapSecureDNS;
+    entities?: RdapEntityObjectClass[];
+    status?: RdapStatus[];
+    publicIds?: RdapPublicID[];
+    remarks: RdapRemark[];
+    links?: RdapLink[];
+    port43?: string;
+    events?: RdapEvent[];
+    network?: RdapIPNetworkObjectClass;
+}
+interface RdapIPNetworkObjectClass {
+    objectClassName: 'ip network';
+    handle?: string;
+    startAddress?: string;
+    endAddress?: string;
+    ipVersion?: 'v4' | 'v6';
+    name?: string;
+    type?: string;
+    country?: string;
+    parentHandle?: string;
+    status?: RdapStatus[];
+    entities?: RdapEntityObjectClass[];
+    remarks: RdapRemark[];
+    links?: RdapLink[];
+    port43?: string;
+    events?: RdapEvent[];
+}
+interface RdapAutonomousSystemNumberObjectClass {
+    objectClassName: 'autnum';
+    handle?: string;
+    startAutnum?: string;
+    endAutnum?: string;
+    name?: string;
+    type?: string;
+    status?: RdapStatus[];
+    country?: string;
+    entities?: RdapEntityObjectClass[];
+    remarks: RdapRemark[];
+    links?: RdapLink[];
+    port43?: string;
+    events?: RdapEvent[];
+}
+interface RdapDomainSuccessResponse extends RdapDomainObjectClass {
+    rdapConformance: string[];
+}
+interface RdapIpSuccessResponse extends RdapIPNetworkObjectClass {
+    rdapConformance: string[];
+}
+interface RdapAutnumSuccessResponse extends RdapAutonomousSystemNumberObjectClass {
+    rdapConformance: string[];
+}
+interface RdapHelpSuccessResponse {
+    rdapConformance: string[];
+    notices?: RdapNotice[];
+}
+interface RdapErrorResponse {
+    errorCode: number;
+    title?: string;
+    description?: string[];
+}
+type RdapDomainResponse = RdapErrorResponse & RdapDomainSuccessResponse;
+type RdapIpResponse = RdapErrorResponse & RdapIpSuccessResponse;
+type RdapAutnumResponse = RdapErrorResponse & RdapAutnumSuccessResponse;
+type RdapHelpResponse = RdapErrorResponse & RdapHelpSuccessResponse;
+
+/**
+ * HTTP methods supported by the fetcher
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+/**
+ * Options for the fetch request
+ */
+interface FetchOptions<T = unknown> {
+    method: HttpMethod;
+    url: string;
+    body?: T;
+    headers?: Record<string, string>;
+}
+/**
+ * Response from the fetch request
+ */
+interface FetchResponse<T = unknown> {
+    status: number;
+    data: T;
+    headers: Headers;
+    url: string;
+}
+/**
+ * Interface for the fetcher implementation
+ */
+interface Fetcher {
+    fetch<TBody = unknown, TResponse = unknown>(options: FetchOptions<TBody>): Promise<FetchResponse<TResponse>>;
+}
+/**
+ * Default fetcher implementation using node-fetch
+ */
+declare class DefaultFetcher implements Fetcher {
+    fetch<TBody = unknown, TResponse = unknown>({ method, url, body, headers, }: FetchOptions<TBody>): Promise<FetchResponse<TResponse>>;
+}
+
+interface RdapClientOptions {
+    fetcher?: Fetcher;
+    baseDomain?: string;
+}
+declare class RdapClient {
+    private readonly fetcher;
+    private readonly baseDomain;
+    constructor(options?: RdapClientOptions);
+    /**
+     * Convert domain to punycode if needed
+     */
+    private prepareDomain;
+    /**
+     * Query domain information
+     * @param domain Domain name to query (supports IDN/punycode)
+     * @returns Domain information
+     * @example
+     * ```typescript
+     * const client = new RdapClient();
+     * const domain = await client.domain('example.com');
+     * // IDN support
+     * const idn = await client.domain('münchen.de');
+     * ```
+     */
+    domain(domain: string): Promise<RdapDomainResponse>;
+    /**
+     * Query IP address or network information
+     * @param ip IP address or CIDR notation
+     * @returns IP network information
+     * @example
+     * ```typescript
+     * const client = new RdapClient();
+     * const ip = await client.ip('8.8.8.8');
+     * // or with CIDR notation
+     * const network = await client.ip('2001:db8::1/128');
+     * ```
+     */
+    ip(ip: string): Promise<RdapIpResponse>;
+    /**
+     * Query Autonomous System Number information
+     * @param asn Autonomous System Number
+     * @returns ASN information
+     * @example
+     * ```typescript
+     * const client = new RdapClient();
+     * const asn = await client.autnum(174);
+     * ```
+     */
+    autnum(asn: number): Promise<RdapAutnumResponse>;
+}
+
+export { DefaultFetcher, type FetchOptions, type FetchResponse, type Fetcher, type HttpMethod, type RdapAutnumResponse, type RdapAutnumSuccessResponse, type RdapAutonomousSystemNumberObjectClass, RdapClient, type RdapClientOptions, type RdapDomainObjectClass, type RdapDomainResponse, type RdapDomainSuccessResponse, type RdapDsData, type RdapEntityObjectClass, type RdapErrorResponse, type RdapEvent, type RdapHelpResponse, type RdapHelpSuccessResponse, type RdapIPNetworkObjectClass, type RdapIpResponse, type RdapIpSuccessResponse, type RdapKeyData, type RdapLink, type RdapNameserverObjectClass, type RdapNotice, type RdapNoticeAndRemarkTypes, type RdapObjectClass, type RdapPublicID, type RdapRemark, type RdapSecureDNS, type RdapStatus };

package/dist/index.js

@@ -0,0 +1,139 @@
+// src/utils/fetcher.ts
+var DefaultFetcher = class {
+  async fetch({
+    method,
+    url,
+    body,
+    headers = {}
+  }) {
+    const requestUrl = new URL(url);
+    if (method === "GET" && body) {
+      Object.entries(body).forEach(([key, value]) => {
+        requestUrl.searchParams.append(key, value);
+      });
+    }
+    const requestInit = {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      }
+    };
+    if (method !== "GET" && body) {
+      requestInit.body = JSON.stringify(body);
+    }
+    const response = await fetch(requestUrl, requestInit);
+    const data = await response.json();
+    return {
+      status: response.status,
+      data,
+      headers: response.headers,
+      url: response.url
+    };
+  }
+};
+
+// src/utils/throwables.ts
+var RdapNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RdapNotFoundError";
+  }
+};
+
+// src/client.ts
+var RdapClient = class {
+  constructor(options = {}) {
+    this.fetcher = options.fetcher ?? new DefaultFetcher();
+    this.baseDomain = options.baseDomain ?? "www.rdap.net";
+  }
+  /**
+   * Convert domain to punycode if needed
+   */
+  prepareDomain(domain) {
+    return domain.toLowerCase().split(".").map((part) => {
+      try {
+        if (part.includes("xn--")) {
+          return part;
+        }
+        const url = new URL(`https://${part}`);
+        return url.hostname.startsWith("xn--") ? url.hostname : part;
+      } catch {
+        return part;
+      }
+    }).join(".");
+  }
+  /**
+   * Query domain information
+   * @param domain Domain name to query (supports IDN/punycode)
+   * @returns Domain information
+   * @example
+   * ```typescript
+   * const client = new RdapClient();
+   * const domain = await client.domain('example.com');
+   * // IDN support
+   * const idn = await client.domain('münchen.de');
+   * ```
+   */
+  async domain(domain) {
+    const punyDomain = this.prepareDomain(domain);
+    const url = `https://${this.baseDomain}/domain/${encodeURIComponent(punyDomain)}`;
+    try {
+      const response = await this.fetcher.fetch({
+        method: "GET",
+        url
+      });
+      if (response.status === 404 && response.url === url) {
+        throw new RdapNotFoundError(`Domain ${domain} has no RDAP server for its TLD`);
+      }
+      return response.data;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new RdapNotFoundError(`Domain ${domain} has no RDAP server for its TLD`);
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Query IP address or network information
+   * @param ip IP address or CIDR notation
+   * @returns IP network information
+   * @example
+   * ```typescript
+   * const client = new RdapClient();
+   * const ip = await client.ip('8.8.8.8');
+   * // or with CIDR notation
+   * const network = await client.ip('2001:db8::1/128');
+   * ```
+   */
+  async ip(ip) {
+    const response = await this.fetcher.fetch({
+      method: "GET",
+      url: `https://${this.baseDomain}/ip/${encodeURIComponent(ip)}`
+    });
+    return response.data;
+  }
+  /**
+   * Query Autonomous System Number information
+   * @param asn Autonomous System Number
+   * @returns ASN information
+   * @example
+   * ```typescript
+   * const client = new RdapClient();
+   * const asn = await client.autnum(174);
+   * ```
+   */
+  async autnum(asn) {
+    const response = await this.fetcher.fetch({
+      method: "GET",
+      url: `https://${this.baseDomain}/autnum/${asn}`
+    });
+    return response.data;
+  }
+};
+export {
+  DefaultFetcher,
+  RdapClient
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/fetcher.ts","../src/utils/throwables.ts","../src/client.ts"],"sourcesContent":["/**\n * HTTP methods supported by the fetcher\n */\nexport type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';\n\n/**\n * Options for the fetch request\n */\nexport interface FetchOptions<T = unknown> {\n  method: HttpMethod;\n  url: string;\n  body?: T;\n  headers?: Record<string, string>;\n}\n\n/**\n * Response from the fetch request\n */\nexport interface FetchResponse<T = unknown> {\n  status: number;\n  data: T;\n  headers: Headers;\n  url: string;\n}\n\n/**\n * Interface for the fetcher implementation\n */\nexport interface Fetcher {\n  fetch<TBody = unknown, TResponse = unknown>(\n    options: FetchOptions<TBody>,\n  ): Promise<FetchResponse<TResponse>>;\n}\n\n/**\n * Default fetcher implementation using node-fetch\n */\nexport class DefaultFetcher implements Fetcher {\n  async fetch<TBody = unknown, TResponse = unknown>({\n    method,\n    url,\n    body,\n    headers = {},\n  }: FetchOptions<TBody>): Promise<FetchResponse<TResponse>> {\n    const requestUrl = new URL(url);\n\n    // For GET requests, convert body to query parameters\n    if (method === 'GET' && body) {\n      Object.entries(body as Record<string, string>).forEach(([key, value]) => {\n        requestUrl.searchParams.append(key, value);\n      });\n    }\n\n    const requestInit: RequestInit = {\n      method,\n      headers: {\n        'Content-Type': 'application/json',\n        ...headers,\n      },\n    };\n\n    // Add body for non-GET requests\n    if (method !== 'GET' && body) {\n      requestInit.body = JSON.stringify(body);\n    }\n\n    const response = await fetch(requestUrl, requestInit);\n    const data = (await response.json()) as TResponse;\n\n    return {\n      status: response.status,\n      data,\n      headers: response.headers,\n      url: response.url,\n    };\n  }\n}\n","export class RdapNotFoundError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'RdapNotFoundError';\n  }\n}\n","import { RdapAutnumResponse, RdapDomainResponse, RdapIpResponse } from './types';\nimport { DefaultFetcher, Fetcher } from './utils/fetcher';\nimport { RdapNotFoundError } from './utils/throwables';\n\nexport interface RdapClientOptions {\n  fetcher?: Fetcher;\n  baseDomain?: string;\n}\n\nexport class RdapClient {\n  private readonly fetcher: Fetcher;\n  private readonly baseDomain: string;\n\n  constructor(options: RdapClientOptions = {}) {\n    this.fetcher = options.fetcher ?? new DefaultFetcher();\n    this.baseDomain = options.baseDomain ?? 'www.rdap.net';\n  }\n\n  /**\n   * Convert domain to punycode if needed\n   */\n  private prepareDomain(domain: string): string {\n    return domain\n      .toLowerCase()\n      .split('.')\n      .map((part) => {\n        try {\n          if (part.includes('xn--')) {\n            return part;\n          }\n          // Use URL API to handle IDN conversion\n          const url = new URL(`https://${part}`);\n          return url.hostname.startsWith('xn--') ? url.hostname : part;\n        } catch {\n          return part;\n        }\n      })\n      .join('.');\n  }\n\n  /**\n   * Query domain information\n   * @param domain Domain name to query (supports IDN/punycode)\n   * @returns Domain information\n   * @example\n   * ```typescript\n   * const client = new RdapClient();\n   * const domain = await client.domain('example.com');\n   * // IDN support\n   * const idn = await client.domain('münchen.de');\n   * ```\n   */\n  async domain(domain: string): Promise<RdapDomainResponse> {\n    const punyDomain = this.prepareDomain(domain);\n    const url = `https://${this.baseDomain}/domain/${encodeURIComponent(punyDomain)}`;\n    try {\n      const response = await this.fetcher.fetch<never, RdapDomainResponse>({\n        method: 'GET',\n        url,\n      });\n\n      if (response.status === 404 && response.url === url) {\n        throw new RdapNotFoundError(`Domain ${domain} has no RDAP server for its TLD`);\n      }\n\n      return response.data;\n    } catch (error) {\n      if (error instanceof SyntaxError) {\n        throw new RdapNotFoundError(`Domain ${domain} has no RDAP server for its TLD`);\n      } else {\n        throw error;\n      }\n    }\n  }\n\n  /**\n   * Query IP address or network information\n   * @param ip IP address or CIDR notation\n   * @returns IP network information\n   * @example\n   * ```typescript\n   * const client = new RdapClient();\n   * const ip = await client.ip('8.8.8.8');\n   * // or with CIDR notation\n   * const network = await client.ip('2001:db8::1/128');\n   * ```\n   */\n  async ip(ip: string): Promise<RdapIpResponse> {\n    const response = await this.fetcher.fetch<never, RdapIpResponse>({\n      method: 'GET',\n      url: `https://${this.baseDomain}/ip/${encodeURIComponent(ip)}`,\n    });\n\n    return response.data;\n  }\n\n  /**\n   * Query Autonomous System Number information\n   * @param asn Autonomous System Number\n   * @returns ASN information\n   * @example\n   * ```typescript\n   * const client = new RdapClient();\n   * const asn = await client.autnum(174);\n   * ```\n   */\n  async autnum(asn: number): Promise<RdapAutnumResponse> {\n    const response = await this.fetcher.fetch<never, RdapAutnumResponse>({\n      method: 'GET',\n      url: `https://${this.baseDomain}/autnum/${asn}`,\n    });\n\n    return response.data;\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@chez14/rdap-sdk",
+  "version": "0.1.1-13",
+  "description": "A TypeScript SDK for RDAP.net. Directly calls RDAP APIs from RDAP.net as the main RDAP Server Database.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/chez14/rdap-sdk-ts.git"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./ts/*": "./src/*"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1.2.4",
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.17.0",
+    "@types/node": "^22.10.2",
+    "@typescript-eslint/eslint-plugin": "^8.18.1",
+    "@typescript-eslint/parser": "^8.18.1",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "globals": "^15.14.0",
+    "prettier": "^3.4.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "dependencies": {},
+  "publishConfig": {
+    "provenance": true,
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest --no-watch",
+    "test:watch": "vitest --watch",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write ."
+  }
+}

package/src/client.ts

@@ -0,0 +1,115 @@
+import { RdapAutnumResponse, RdapDomainResponse, RdapIpResponse } from './types';
+import { DefaultFetcher, Fetcher } from './utils/fetcher';
+import { RdapNotFoundError } from './utils/throwables';
+
+export interface RdapClientOptions {
+  fetcher?: Fetcher;
+  baseDomain?: string;
+}
+
+export class RdapClient {
+  private readonly fetcher: Fetcher;
+  private readonly baseDomain: string;
+
+  constructor(options: RdapClientOptions = {}) {
+    this.fetcher = options.fetcher ?? new DefaultFetcher();
+    this.baseDomain = options.baseDomain ?? 'www.rdap.net';
+  }
+
+  /**
+   * Convert domain to punycode if needed
+   */
+  private prepareDomain(domain: string): string {
+    return domain
+      .toLowerCase()
+      .split('.')
+      .map((part) => {
+        try {
+          if (part.includes('xn--')) {
+            return part;
+          }
+          // Use URL API to handle IDN conversion
+          const url = new URL(`https://${part}`);
+          return url.hostname.startsWith('xn--') ? url.hostname : part;
+        } catch {
+          return part;
+        }
+      })
+      .join('.');
+  }
+
+  /**
+   * Query domain information
+   * @param domain Domain name to query (supports IDN/punycode)
+   * @returns Domain information
+   * @example
+   * ```typescript
+   * const client = new RdapClient();
+   * const domain = await client.domain('example.com');
+   * // IDN support
+   * const idn = await client.domain('münchen.de');
+   * ```
+   */
+  async domain(domain: string): Promise<RdapDomainResponse> {
+    const punyDomain = this.prepareDomain(domain);
+    const url = `https://${this.baseDomain}/domain/${encodeURIComponent(punyDomain)}`;
+    try {
+      const response = await this.fetcher.fetch<never, RdapDomainResponse>({
+        method: 'GET',
+        url,
+      });
+
+      if (response.status === 404 && response.url === url) {
+        throw new RdapNotFoundError(`Domain ${domain} has no RDAP server for its TLD`);
+      }
+
+      return response.data;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new RdapNotFoundError(`Domain ${domain} has no RDAP server for its TLD`);
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Query IP address or network information
+   * @param ip IP address or CIDR notation
+   * @returns IP network information
+   * @example
+   * ```typescript
+   * const client = new RdapClient();
+   * const ip = await client.ip('8.8.8.8');
+   * // or with CIDR notation
+   * const network = await client.ip('2001:db8::1/128');
+   * ```
+   */
+  async ip(ip: string): Promise<RdapIpResponse> {
+    const response = await this.fetcher.fetch<never, RdapIpResponse>({
+      method: 'GET',
+      url: `https://${this.baseDomain}/ip/${encodeURIComponent(ip)}`,
+    });
+
+    return response.data;
+  }
+
+  /**
+   * Query Autonomous System Number information
+   * @param asn Autonomous System Number
+   * @returns ASN information
+   * @example
+   * ```typescript
+   * const client = new RdapClient();
+   * const asn = await client.autnum(174);
+   * ```
+   */
+  async autnum(asn: number): Promise<RdapAutnumResponse> {
+    const response = await this.fetcher.fetch<never, RdapAutnumResponse>({
+      method: 'GET',
+      url: `https://${this.baseDomain}/autnum/${asn}`,
+    });
+
+    return response.data;
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './types';
+export * from './utils/fetcher';

package/src/types.ts

@@ -0,0 +1,216 @@
+/*
+ * These files were copied directly from
+ * https://github.com/dcoffey-zengenti/node-rdap/blob/aa294812f01730f3ce5f1c384fb92cfbfeaf846f/src/types.ts.
+ */
+
+export interface RdapLink {
+  value: string;
+  rel: string;
+  href: string;
+  hreflang?: string[];
+  type?: string;
+  media?: string;
+  title?: string;
+}
+
+export interface RdapEvent {
+  eventAction: string;
+  eventActor?: string;
+  eventDate: string;
+  links?: RdapLink[];
+}
+
+export interface RdapPublicID {
+  type: string;
+  identifier: string;
+}
+
+export type RdapStatus =
+  | 'validated'
+  | 'renew prohibited'
+  | 'update prohibited'
+  | 'transfer prohibited'
+  | 'delete prohibited'
+  | 'proxy'
+  | 'private'
+  | 'removed'
+  | 'obscured'
+  | 'associated'
+  | 'active'
+  | 'inactive'
+  | 'locked'
+  | 'pending create'
+  | 'pending renew'
+  | 'pending transfer'
+  | 'pending update'
+  | 'pending delete';
+
+export type RdapNoticeAndRemarkTypes =
+  | 'result set truncated due to authorization'
+  | 'result set truncated due to excessive load'
+  | 'result set truncated due to unexplainable reasons'
+  | 'object truncated due to authorization'
+  | 'object truncated due to excessive load'
+  | 'object truncated due to unexplainable reasons';
+
+export interface RdapRemark {
+  title?: string;
+  type?: RdapNoticeAndRemarkTypes;
+  description: string[];
+  links?: RdapLink[];
+}
+
+export interface RdapDsData {
+  keyTag?: number;
+  algorithm?: number;
+  digest?: string;
+  digestType?: string;
+  events?: RdapEvent[];
+  links?: RdapLink[];
+}
+
+export interface RdapKeyData {
+  flags?: number;
+  protocol?: number;
+  publicKey?: string;
+  algorithm?: number;
+  events?: RdapEvent[];
+  links?: RdapLink[];
+}
+
+export interface RdapSecureDNS {
+  zoneSigned?: boolean;
+  delegationSigned?: boolean;
+  maxSigLife?: number;
+  dsData?: RdapDsData[];
+  keyData?: RdapKeyData[];
+}
+
+export type RdapNotice = RdapRemark;
+
+export type RdapObjectClass =
+  | RdapEntityObjectClass
+  | RdapNameserverObjectClass
+  | RdapDomainObjectClass;
+
+export interface RdapEntityObjectClass {
+  objectClassName: 'entity';
+  handle?: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  vcardArray?: any[];
+  roles?: string[];
+  publicIds?: RdapPublicID[];
+  entities?: RdapEntityObjectClass[];
+  remarks?: RdapRemark[];
+  links?: RdapLink[];
+  events?: RdapEvent[];
+  asEventActor?: Omit<RdapEvent, 'eventActor'>[];
+  status?: RdapStatus[];
+  port43?: string;
+  networks?: RdapIPNetworkObjectClass[];
+  autnums?: RdapAutonomousSystemNumberObjectClass[];
+}
+
+export interface RdapNameserverObjectClass {
+  objectClassName: 'nameserver';
+  handle?: string;
+  ldhName?: string;
+  unicodeName?: string;
+  ipAddresses?: {
+    v6: string[];
+    v4: string[];
+  };
+  entities?: RdapEntityObjectClass[];
+  status?: RdapStatus[];
+  remarks?: RdapRemark[];
+  links?: RdapLink[];
+  port43?: string;
+  events?: RdapEvent[];
+}
+
+export interface RdapDomainObjectClass {
+  objectClassName: 'domain';
+  handle?: string;
+  ldhName?: string;
+  unicodeName?: string;
+  variants: {
+    relation: string[];
+    idnTable: string;
+    variantName: {
+      ldhName: string;
+      unicodeName: string;
+    }[];
+  }[];
+  nameservers: RdapNameserverObjectClass[];
+  secureDNS: RdapSecureDNS;
+  entities?: RdapEntityObjectClass[];
+  status?: RdapStatus[];
+  publicIds?: RdapPublicID[];
+  remarks: RdapRemark[];
+  links?: RdapLink[];
+  port43?: string;
+  events?: RdapEvent[];
+  network?: RdapIPNetworkObjectClass;
+}
+
+export interface RdapIPNetworkObjectClass {
+  objectClassName: 'ip network';
+  handle?: string;
+  startAddress?: string;
+  endAddress?: string;
+  ipVersion?: 'v4' | 'v6';
+  name?: string;
+  type?: string;
+  country?: string;
+  parentHandle?: string;
+  status?: RdapStatus[];
+  entities?: RdapEntityObjectClass[];
+  remarks: RdapRemark[];
+  links?: RdapLink[];
+  port43?: string;
+  events?: RdapEvent[];
+}
+
+export interface RdapAutonomousSystemNumberObjectClass {
+  objectClassName: 'autnum';
+  handle?: string;
+  startAutnum?: string;
+  endAutnum?: string;
+  name?: string;
+  type?: string;
+  status?: RdapStatus[];
+  country?: string;
+  entities?: RdapEntityObjectClass[];
+  remarks: RdapRemark[];
+  links?: RdapLink[];
+  port43?: string;
+  events?: RdapEvent[];
+}
+
+export interface RdapDomainSuccessResponse extends RdapDomainObjectClass {
+  rdapConformance: string[];
+}
+
+export interface RdapIpSuccessResponse extends RdapIPNetworkObjectClass {
+  rdapConformance: string[];
+}
+
+export interface RdapAutnumSuccessResponse extends RdapAutonomousSystemNumberObjectClass {
+  rdapConformance: string[];
+}
+
+export interface RdapHelpSuccessResponse {
+  rdapConformance: string[];
+  notices?: RdapNotice[];
+}
+
+export interface RdapErrorResponse {
+  errorCode: number;
+  title?: string;
+  description?: string[];
+}
+
+export type RdapDomainResponse = RdapErrorResponse & RdapDomainSuccessResponse;
+export type RdapIpResponse = RdapErrorResponse & RdapIpSuccessResponse;
+export type RdapAutnumResponse = RdapErrorResponse & RdapAutnumSuccessResponse;
+export type RdapHelpResponse = RdapErrorResponse & RdapHelpSuccessResponse;

package/src/utils/fetcher.ts

@@ -0,0 +1,77 @@
+/**
+ * HTTP methods supported by the fetcher
+ */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+
+/**
+ * Options for the fetch request
+ */
+export interface FetchOptions<T = unknown> {
+  method: HttpMethod;
+  url: string;
+  body?: T;
+  headers?: Record<string, string>;
+}
+
+/**
+ * Response from the fetch request
+ */
+export interface FetchResponse<T = unknown> {
+  status: number;
+  data: T;
+  headers: Headers;
+  url: string;
+}
+
+/**
+ * Interface for the fetcher implementation
+ */
+export interface Fetcher {
+  fetch<TBody = unknown, TResponse = unknown>(
+    options: FetchOptions<TBody>,
+  ): Promise<FetchResponse<TResponse>>;
+}
+
+/**
+ * Default fetcher implementation using node-fetch
+ */
+export class DefaultFetcher implements Fetcher {
+  async fetch<TBody = unknown, TResponse = unknown>({
+    method,
+    url,
+    body,
+    headers = {},
+  }: FetchOptions<TBody>): Promise<FetchResponse<TResponse>> {
+    const requestUrl = new URL(url);
+
+    // For GET requests, convert body to query parameters
+    if (method === 'GET' && body) {
+      Object.entries(body as Record<string, string>).forEach(([key, value]) => {
+        requestUrl.searchParams.append(key, value);
+      });
+    }
+
+    const requestInit: RequestInit = {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers,
+      },
+    };
+
+    // Add body for non-GET requests
+    if (method !== 'GET' && body) {
+      requestInit.body = JSON.stringify(body);
+    }
+
+    const response = await fetch(requestUrl, requestInit);
+    const data = (await response.json()) as TResponse;
+
+    return {
+      status: response.status,
+      data,
+      headers: response.headers,
+      url: response.url,
+    };
+  }
+}

package/src/utils/throwables.ts

@@ -0,0 +1,6 @@
+export class RdapNotFoundError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'RdapNotFoundError';
+  }
+}