@chez14/rdap-sdk 0.1.1-5

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 RdapOrgClient({
+  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 RdapOrgClient({
+  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,139 @@
+/**
+ * Base response interface for RDAP queries
+ */
+interface RdapResponse {
+    rdapConformance: string[];
+    notices?: Array<{
+        title?: string;
+        description: string[];
+        links?: Array<{
+            value: string;
+            rel: string;
+            href: string;
+            type?: string;
+        }>;
+    }>;
+}
+/**
+ * Domain response interface
+ */
+interface DomainResponse extends RdapResponse {
+    objectClassName: 'domain';
+    handle?: string;
+    ldhName: string;
+    links: Array<{
+        rel: string;
+        href: string;
+        type?: string;
+    }>;
+}
+/**
+ * IP Network response interface
+ */
+interface IpNetworkResponse extends RdapResponse {
+    objectClassName: 'ip network';
+    handle: string;
+    startAddress: string;
+    endAddress: string;
+    ipVersion: string;
+    name?: string;
+    type?: string;
+}
+/**
+ * Autonomous System Number response interface
+ */
+interface AutonomousSystemResponse extends RdapResponse {
+    objectClassName: 'autnum';
+    handle: string;
+    startAutnum: number;
+    endAutnum: number;
+    name?: string;
+    type?: string;
+}
+
+/**
+ * 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;
+}
+/**
+ * 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 RdapOrgClientOptions {
+    fetcher?: Fetcher;
+    baseDomain?: string;
+}
+declare class RdapClient {
+    private readonly fetcher;
+    private readonly baseDomain;
+    constructor(options?: RdapOrgClientOptions);
+    /**
+     * 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 RdapOrgClient();
+     * const domain = await client.domain('example.com');
+     * // IDN support
+     * const idn = await client.domain('münchen.de');
+     * ```
+     */
+    domain(domain: string): Promise<DomainResponse>;
+    /**
+     * Query IP address or network information
+     * @param ip IP address or CIDR notation
+     * @returns IP network information
+     * @example
+     * ```typescript
+     * const client = new RdapOrgClient();
+     * 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<IpNetworkResponse>;
+    /**
+     * Query Autonomous System Number information
+     * @param asn Autonomous System Number
+     * @returns ASN information
+     * @example
+     * ```typescript
+     * const client = new RdapOrgClient();
+     * const asn = await client.autnum(174);
+     * ```
+     */
+    autnum(asn: number): Promise<AutonomousSystemResponse>;
+}
+
+export { type AutonomousSystemResponse, DefaultFetcher, type DomainResponse, type FetchOptions, type FetchResponse, type Fetcher, type HttpMethod, type IpNetworkResponse, RdapClient, type RdapOrgClientOptions, type RdapResponse };

package/dist/index.js

@@ -0,0 +1,118 @@
+// 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
+    };
+  }
+};
+
+// 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 RdapOrgClient();
+   * 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 response = await this.fetcher.fetch({
+      method: "GET",
+      url: `https://${this.baseDomain}/domain/${encodeURIComponent(punyDomain)}`
+    });
+    return response.data;
+  }
+  /**
+   * Query IP address or network information
+   * @param ip IP address or CIDR notation
+   * @returns IP network information
+   * @example
+   * ```typescript
+   * const client = new RdapOrgClient();
+   * 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 RdapOrgClient();
+   * 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/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}\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    };\n  }\n}\n","import { AutonomousSystemResponse, DomainResponse, IpNetworkResponse } from './types';\nimport { DefaultFetcher, Fetcher } from './utils/fetcher';\n\nexport interface RdapOrgClientOptions {\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: RdapOrgClientOptions = {}) {\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 RdapOrgClient();\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<DomainResponse> {\n    const punyDomain = this.prepareDomain(domain);\n    const response = await this.fetcher.fetch<never, DomainResponse>({\n      method: 'GET',\n      url: `https://${this.baseDomain}/domain/${encodeURIComponent(punyDomain)}`,\n    });\n\n    return response.data;\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 RdapOrgClient();\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<IpNetworkResponse> {\n    const response = await this.fetcher.fetch<never, IpNetworkResponse>({\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 RdapOrgClient();\n   * const asn = await client.autnum(174);\n   * ```\n   */\n  async autnum(asn: number): Promise<AutonomousSystemResponse> {\n    const response = await this.fetcher.fetch<never, AutonomousSystemResponse>({\n      method: 'GET',\n      url: `https://${this.baseDomain}/autnum/${asn}`,\n    });\n\n    return response.data;\n  }\n}\n"],"mappings":";AAoCO,IAAM,iBAAN,MAAwC;AAAA,EAC7C,MAAM,MAA4C;AAAA,IAChD;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU,CAAC;AAAA,EACb,GAA2D;AACzD,UAAM,aAAa,IAAI,IAAI,GAAG;AAG9B,QAAI,WAAW,SAAS,MAAM;AAC5B,aAAO,QAAQ,IAA8B,EAAE,QAAQ,CAAC,CAAC,KAAK,KAAK,MAAM;AACvE,mBAAW,aAAa,OAAO,KAAK,KAAK;AAAA,MAC3C,CAAC;AAAA,IACH;AAEA,UAAM,cAA2B;AAAA,MAC/B;AAAA,MACA,SAAS;AAAA,QACP,gBAAgB;AAAA,QAChB,GAAG;AAAA,MACL;AAAA,IACF;AAGA,QAAI,WAAW,SAAS,MAAM;AAC5B,kBAAY,OAAO,KAAK,UAAU,IAAI;AAAA,IACxC;AAEA,UAAM,WAAW,MAAM,MAAM,YAAY,WAAW;AACpD,UAAM,OAAQ,MAAM,SAAS,KAAK;AAElC,WAAO;AAAA,MACL,QAAQ,SAAS;AAAA,MACjB;AAAA,MACA,SAAS,SAAS;AAAA,IACpB;AAAA,EACF;AACF;;;AClEO,IAAM,aAAN,MAAiB;AAAA,EAItB,YAAY,UAAgC,CAAC,GAAG;AAC9C,SAAK,UAAU,QAAQ,WAAW,IAAI,eAAe;AACrD,SAAK,aAAa,QAAQ,cAAc;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA,EAKQ,cAAc,QAAwB;AAC5C,WAAO,OACJ,YAAY,EACZ,MAAM,GAAG,EACT,IAAI,CAAC,SAAS;AACb,UAAI;AACF,YAAI,KAAK,SAAS,MAAM,GAAG;AACzB,iBAAO;AAAA,QACT;AAEA,cAAM,MAAM,IAAI,IAAI,WAAW,IAAI,EAAE;AACrC,eAAO,IAAI,SAAS,WAAW,MAAM,IAAI,IAAI,WAAW;AAAA,MAC1D,QAAQ;AACN,eAAO;AAAA,MACT;AAAA,IACF,CAAC,EACA,KAAK,GAAG;AAAA,EACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,MAAM,OAAO,QAAyC;AACpD,UAAM,aAAa,KAAK,cAAc,MAAM;AAC5C,UAAM,WAAW,MAAM,KAAK,QAAQ,MAA6B;AAAA,MAC/D,QAAQ;AAAA,MACR,KAAK,WAAW,KAAK,UAAU,WAAW,mBAAmB,UAAU,CAAC;AAAA,IAC1E,CAAC;AAED,WAAO,SAAS;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,MAAM,GAAG,IAAwC;AAC/C,UAAM,WAAW,MAAM,KAAK,QAAQ,MAAgC;AAAA,MAClE,QAAQ;AAAA,MACR,KAAK,WAAW,KAAK,UAAU,OAAO,mBAAmB,EAAE,CAAC;AAAA,IAC9D,CAAC;AAED,WAAO,SAAS;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAM,OAAO,KAAgD;AAC3D,UAAM,WAAW,MAAM,KAAK,QAAQ,MAAuC;AAAA,MACzE,QAAQ;AAAA,MACR,KAAK,WAAW,KAAK,UAAU,WAAW,GAAG;AAAA,IAC/C,CAAC;AAED,WAAO,SAAS;AAAA,EAClB;AACF;","names":[]}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@chez14/rdap-sdk",
+  "version": "0.1.1-5",
+  "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.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest --no-watch",
+    "test:watch": "vitest --watch",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write ."
+  },
+  "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": {},
+  "packageManager": "pnpm@9.15.1+sha256.9e534e70afef06374f6126b44bda5760947135ce16a30aef1010e965fb7e3e3e"
+}

package/src/client.ts

@@ -0,0 +1,101 @@
+import { AutonomousSystemResponse, DomainResponse, IpNetworkResponse } from './types';
+import { DefaultFetcher, Fetcher } from './utils/fetcher';
+
+export interface RdapOrgClientOptions {
+  fetcher?: Fetcher;
+  baseDomain?: string;
+}
+
+export class RdapClient {
+  private readonly fetcher: Fetcher;
+  private readonly baseDomain: string;
+
+  constructor(options: RdapOrgClientOptions = {}) {
+    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 RdapOrgClient();
+   * const domain = await client.domain('example.com');
+   * // IDN support
+   * const idn = await client.domain('münchen.de');
+   * ```
+   */
+  async domain(domain: string): Promise<DomainResponse> {
+    const punyDomain = this.prepareDomain(domain);
+    const response = await this.fetcher.fetch<never, DomainResponse>({
+      method: 'GET',
+      url: `https://${this.baseDomain}/domain/${encodeURIComponent(punyDomain)}`,
+    });
+
+    return response.data;
+  }
+
+  /**
+   * Query IP address or network information
+   * @param ip IP address or CIDR notation
+   * @returns IP network information
+   * @example
+   * ```typescript
+   * const client = new RdapOrgClient();
+   * 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<IpNetworkResponse> {
+    const response = await this.fetcher.fetch<never, IpNetworkResponse>({
+      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 RdapOrgClient();
+   * const asn = await client.autnum(174);
+   * ```
+   */
+  async autnum(asn: number): Promise<AutonomousSystemResponse> {
+    const response = await this.fetcher.fetch<never, AutonomousSystemResponse>({
+      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,55 @@
+/**
+ * Base response interface for RDAP queries
+ */
+export interface RdapResponse {
+  rdapConformance: string[];
+  notices?: Array<{
+    title?: string;
+    description: string[];
+    links?: Array<{
+      value: string;
+      rel: string;
+      href: string;
+      type?: string;
+    }>;
+  }>;
+}
+
+/**
+ * Domain response interface
+ */
+export interface DomainResponse extends RdapResponse {
+  objectClassName: 'domain';
+  handle?: string;
+  ldhName: string;
+  links: Array<{
+    rel: string;
+    href: string;
+    type?: string;
+  }>;
+}
+
+/**
+ * IP Network response interface
+ */
+export interface IpNetworkResponse extends RdapResponse {
+  objectClassName: 'ip network';
+  handle: string;
+  startAddress: string;
+  endAddress: string;
+  ipVersion: string;
+  name?: string;
+  type?: string;
+}
+
+/**
+ * Autonomous System Number response interface
+ */
+export interface AutonomousSystemResponse extends RdapResponse {
+  objectClassName: 'autnum';
+  handle: string;
+  startAutnum: number;
+  endAutnum: number;
+  name?: string;
+  type?: string;
+}

package/src/utils/fetcher.ts

@@ -0,0 +1,75 @@
+/**
+ * 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;
+}
+
+/**
+ * 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,
+    };
+  }
+}