@gjsify/dns 0.1.0

package/src/index.spec.ts

@@ -0,0 +1,396 @@
+import { describe, it, expect } from '@gjsify/unit';
+import dns, {
+  lookup,
+  resolve4,
+  resolve6,
+  reverse,
+  resolve,
+  setDefaultResultOrder,
+  getDefaultResultOrder,
+  NODATA,
+  FORMERR,
+  SERVFAIL,
+  NOTFOUND,
+  NOTIMP,
+  REFUSED,
+  BADQUERY,
+  BADNAME,
+  BADFAMILY,
+  BADRESP,
+  CONNREFUSED,
+  TIMEOUT,
+  EOF,
+  FILE,
+  NOMEM,
+  DESTRUCTION,
+  BADSTR,
+  BADFLAGS,
+  NONAME,
+  BADHINTS,
+  NOTINITIALIZED,
+  CANCELLED,
+} from 'node:dns';
+
+export default async () => {
+  await describe('dns', async () => {
+
+    // --- Constants ---
+    await describe('constants', async () => {
+      await it('should export NOTFOUND as ENOTFOUND', async () => {
+        expect(NOTFOUND).toBe('ENOTFOUND');
+      });
+
+      await it('should export NODATA as ENODATA', async () => {
+        expect(NODATA).toBe('ENODATA');
+      });
+
+      await it('should export SERVFAIL as ESERVFAIL', async () => {
+        expect(SERVFAIL).toBe('ESERVFAIL');
+      });
+
+      await it('should export FORMERR as EFORMERR', async () => {
+        expect(FORMERR).toBe('EFORMERR');
+      });
+
+      await it('should export NOTIMP as ENOTIMP', async () => {
+        expect(NOTIMP).toBe('ENOTIMP');
+      });
+
+      await it('should export REFUSED as EREFUSED', async () => {
+        expect(REFUSED).toBe('EREFUSED');
+      });
+
+      await it('should export BADQUERY as EBADQUERY', async () => {
+        expect(BADQUERY).toBe('EBADQUERY');
+      });
+
+      await it('should export CONNREFUSED as ECONNREFUSED', async () => {
+        expect(CONNREFUSED).toBe('ECONNREFUSED');
+      });
+
+      await it('should export TIMEOUT as ETIMEOUT', async () => {
+        expect(TIMEOUT).toBe('ETIMEOUT');
+      });
+
+      await it('should export remaining error codes', async () => {
+        expect(BADNAME).toBe('EBADNAME');
+        expect(BADFAMILY).toBe('EBADFAMILY');
+        expect(BADRESP).toBe('EBADRESP');
+        expect(EOF).toBe('EOF');
+        expect(FILE).toBe('EFILE');
+        expect(NOMEM).toBe('ENOMEM');
+        expect(DESTRUCTION).toBe('EDESTRUCTION');
+        expect(BADSTR).toBe('EBADSTR');
+        expect(BADFLAGS).toBe('EBADFLAGS');
+        expect(NONAME).toBe('ENONAME');
+        expect(BADHINTS).toBe('EBADHINTS');
+        expect(NOTINITIALIZED).toBe('ENOTINITIALIZED');
+        expect(CANCELLED).toBe('ECANCELLED');
+      });
+    });
+
+    // --- Module exports ---
+    await describe('exports', async () => {
+      await it('should export lookup as a function', async () => {
+        expect(typeof lookup).toBe('function');
+      });
+
+      await it('should export resolve as a function', async () => {
+        expect(typeof resolve).toBe('function');
+      });
+
+      await it('should export resolve4 as a function', async () => {
+        expect(typeof resolve4).toBe('function');
+      });
+
+      await it('should export resolve6 as a function', async () => {
+        expect(typeof resolve6).toBe('function');
+      });
+
+      await it('should export reverse as a function', async () => {
+        expect(typeof reverse).toBe('function');
+      });
+
+      await it('should export setDefaultResultOrder and getDefaultResultOrder', async () => {
+        expect(typeof setDefaultResultOrder).toBe('function');
+        expect(typeof getDefaultResultOrder).toBe('function');
+      });
+
+      await it('should have all exports on the default export object', async () => {
+        expect(typeof dns.lookup).toBe('function');
+        expect(typeof dns.resolve).toBe('function');
+        expect(typeof dns.resolve4).toBe('function');
+        expect(typeof dns.resolve6).toBe('function');
+        expect(typeof dns.reverse).toBe('function');
+        expect(typeof dns.setDefaultResultOrder).toBe('function');
+        expect(typeof dns.getDefaultResultOrder).toBe('function');
+        expect(dns.NOTFOUND).toBe('ENOTFOUND');
+      });
+    });
+
+    // --- lookup ---
+    await describe('lookup', async () => {
+      await it('should resolve localhost', async () => {
+        await new Promise<void>((resolve, reject) => {
+          lookup('localhost', (err, address, family) => {
+            if (err) return reject(err);
+            expect(address).toBeDefined();
+            expect(typeof address).toBe('string');
+            expect(family === 4 || family === 6).toBe(true);
+            resolve();
+          });
+        });
+      });
+
+      await it('should return IPv4 address unchanged', async () => {
+        await new Promise<void>((resolve) => {
+          lookup('127.0.0.1', (err, address, family) => {
+            expect(err).toBeNull();
+            expect(address).toBe('127.0.0.1');
+            expect(family).toBe(4);
+            resolve();
+          });
+        });
+      });
+
+      await it('should return IPv6 address unchanged', async () => {
+        await new Promise<void>((resolve) => {
+          lookup('::1', (err, address, family) => {
+            expect(err).toBeNull();
+            expect(address).toBe('::1');
+            expect(family).toBe(6);
+            resolve();
+          });
+        });
+      });
+
+      await it('should accept family option as number', async () => {
+        await new Promise<void>((resolve) => {
+          lookup('127.0.0.1', 4, (err, address, family) => {
+            expect(err).toBeNull();
+            expect(address).toBe('127.0.0.1');
+            expect(family).toBe(4);
+            resolve();
+          });
+        });
+      });
+
+      await it('should accept family option in options object', async () => {
+        await new Promise<void>((resolve) => {
+          lookup('127.0.0.1', { family: 4 }, (err, address, family) => {
+            expect(err).toBeNull();
+            expect(address).toBe('127.0.0.1');
+            expect(family).toBe(4);
+            resolve();
+          });
+        });
+      });
+
+      await it('should return null for empty hostname', async () => {
+        await new Promise<void>((resolve) => {
+          lookup('', (err, address, family) => {
+            expect(err).toBeNull();
+            expect(address).toBeNull();
+            expect(family).toBe(4);
+            resolve();
+          });
+        });
+      });
+
+      await it('should return null for empty hostname with family 6', async () => {
+        await new Promise<void>((resolve) => {
+          lookup('', { family: 6 }, (err, address, family) => {
+            expect(err).toBeNull();
+            expect(address).toBeNull();
+            expect(family).toBe(6);
+            resolve();
+          });
+        });
+      });
+
+      await it('should return all addresses with all: true', async () => {
+        await new Promise<void>((resolve) => {
+          lookup('localhost', { all: true }, (err, addresses: any) => {
+            expect(err).toBeNull();
+            expect(Array.isArray(addresses)).toBe(true);
+            expect(addresses.length).toBeGreaterThan(0);
+            for (const entry of addresses) {
+              expect(typeof entry.address).toBe('string');
+              expect(entry.family === 4 || entry.family === 6).toBe(true);
+            }
+            resolve();
+          });
+        });
+      });
+
+      await it('should error on non-existent hostname', async () => {
+        await new Promise<void>((resolve) => {
+          lookup('this.hostname.does.not.exist.invalid', (err, address, family) => {
+            expect(err).toBeDefined();
+            expect((err as any).code).toBe('ENOTFOUND');
+            resolve();
+          });
+        });
+      });
+    });
+
+    // --- resolve4 / resolve6 ---
+    await describe('resolve4', async () => {
+      await it('should resolve localhost to IPv4 addresses', async () => {
+        await new Promise<void>((resolve, reject) => {
+          resolve4('localhost', (err, addresses) => {
+            if (err) return reject(err);
+            expect(Array.isArray(addresses)).toBe(true);
+            expect(addresses.length).toBeGreaterThan(0);
+            for (const addr of addresses) {
+              expect(typeof addr).toBe('string');
+            }
+            resolve();
+          });
+        });
+      });
+    });
+
+    await describe('resolve', async () => {
+      await it('should resolve with default rrtype (A record)', async () => {
+        await new Promise<void>((resolve, reject) => {
+          resolve('localhost', (err, records) => {
+            if (err) return reject(err);
+            expect(Array.isArray(records)).toBe(true);
+            resolve();
+          });
+        });
+      });
+
+      await it('should resolve with explicit A rrtype', async () => {
+        await new Promise<void>((res, reject) => {
+          resolve('localhost', 'A', (err, records) => {
+            if (err) return reject(err);
+            expect(Array.isArray(records)).toBe(true);
+            res();
+          });
+        });
+      });
+    });
+
+    // --- reverse ---
+    await describe('reverse', async () => {
+      await it('should reverse lookup 127.0.0.1', async () => {
+        await new Promise<void>((resolve) => {
+          reverse('127.0.0.1', (err, hostnames) => {
+            // May succeed or fail depending on system config
+            if (err) {
+              expect(typeof (err as any).code).toBe('string');
+            } else {
+              expect(Array.isArray(hostnames)).toBe(true);
+            }
+            resolve();
+          });
+        });
+      });
+    });
+
+    // --- setDefaultResultOrder / getDefaultResultOrder ---
+    await describe('setDefaultResultOrder', async () => {
+      await it('should return verbatim by default', async () => {
+        expect(getDefaultResultOrder()).toBe('verbatim');
+      });
+
+      await it('should set to ipv4first', async () => {
+        setDefaultResultOrder('ipv4first');
+        expect(getDefaultResultOrder()).toBe('ipv4first');
+      });
+
+      await it('should set back to verbatim', async () => {
+        setDefaultResultOrder('verbatim');
+        expect(getDefaultResultOrder()).toBe('verbatim');
+      });
+    });
+
+    // --- Additional export checks ---
+    await describe('additional exports', async () => {
+      await it('resolve6 should be a function', async () => {
+        expect(typeof resolve6).toBe('function');
+      });
+
+      await it('resolve6 should resolve localhost', async () => {
+        await new Promise<void>((resolve) => {
+          resolve6('localhost', (err, addresses) => {
+            // May fail if no IPv6 configured, but should not crash
+            if (err) {
+              expect(typeof (err as any).code).toBe('string');
+            } else {
+              expect(Array.isArray(addresses)).toBe(true);
+              expect(addresses.length).toBeGreaterThan(0);
+              for (const addr of addresses) {
+                expect(typeof addr).toBe('string');
+              }
+            }
+            resolve();
+          });
+        });
+      });
+
+      await it('dns.getServers should be a function if exported', async () => {
+        // getServers may or may not be implemented
+        expect(typeof dns.getServers === 'function' || typeof dns.getServers === 'undefined').toBe(true);
+      });
+
+      await it('dns.setServers should be a function if exported', async () => {
+        // setServers may or may not be implemented
+        expect(typeof dns.setServers === 'function' || typeof dns.setServers === 'undefined').toBe(true);
+      });
+
+      await it('dns.Resolver should be a constructor if exported', async () => {
+        // Resolver class may or may not be implemented
+        expect(typeof dns.Resolver === 'function' || typeof dns.Resolver === 'undefined').toBe(true);
+      });
+    });
+
+    // --- lookup with hints option ---
+    await describe('lookup with hints', async () => {
+      await it('lookup with hints option should not throw', async () => {
+        await new Promise<void>((resolve) => {
+          lookup('127.0.0.1', { hints: 0 }, (err, address, family) => {
+            expect(err).toBeNull();
+            expect(address).toBe('127.0.0.1');
+            expect(family).toBe(4);
+            resolve();
+          });
+        });
+      });
+    });
+
+    // --- resolve with different rrtypes ---
+    await describe('resolve with rrtypes', async () => {
+      await it('resolve with MX rrtype should be supported', async () => {
+        // We just verify the function accepts the rrtype without crashing
+        await new Promise<void>((resolve) => {
+          dns.resolve('localhost', 'MX', (err: any, records: any) => {
+            // MX for localhost may return error (no MX records), that's fine
+            if (err) {
+              expect(typeof err.code === 'string' || typeof err.message === 'string').toBe(true);
+            } else {
+              expect(Array.isArray(records)).toBe(true);
+            }
+            resolve();
+          });
+        });
+      });
+
+      await it('resolve with TXT rrtype should be supported', async () => {
+        await new Promise<void>((resolve) => {
+          dns.resolve('localhost', 'TXT', (err: any, records: any) => {
+            // TXT for localhost may return error (no TXT records), that's fine
+            if (err) {
+              expect(typeof err.code === 'string' || typeof err.message === 'string').toBe(true);
+            } else {
+              expect(Array.isArray(records)).toBe(true);
+            }
+            resolve();
+          });
+        });
+      });
+    });
+  });
+};

package/src/index.ts

@@ -0,0 +1,314 @@
+// Reference: Node.js lib/dns.js
+// Reimplemented for GJS using Gio.Resolver
+
+import Gio from '@girs/gio-2.0';
+import GLib from '@girs/glib-2.0';
+import { createNodeError } from '@gjsify/utils';
+import type { ErrnoException } from '@gjsify/utils';
+import { isIP } from 'node:net';
+
+// Error codes
+export const NODATA = 'ENODATA';
+export const FORMERR = 'EFORMERR';
+export const SERVFAIL = 'ESERVFAIL';
+export const NOTFOUND = 'ENOTFOUND';
+export const NOTIMP = 'ENOTIMP';
+export const REFUSED = 'EREFUSED';
+export const BADQUERY = 'EBADQUERY';
+export const BADNAME = 'EBADNAME';
+export const BADFAMILY = 'EBADFAMILY';
+export const BADRESP = 'EBADRESP';
+export const CONNREFUSED = 'ECONNREFUSED';
+export const TIMEOUT = 'ETIMEOUT';
+export const EOF = 'EOF';
+export const FILE = 'EFILE';
+export const NOMEM = 'ENOMEM';
+export const DESTRUCTION = 'EDESTRUCTION';
+export const BADSTR = 'EBADSTR';
+export const BADFLAGS = 'EBADFLAGS';
+export const NONAME = 'ENONAME';
+export const BADHINTS = 'EBADHINTS';
+export const NOTINITIALIZED = 'ENOTINITIALIZED';
+export const LOADIPHLPAPI = 'ELOADIPHLPAPI';
+export const ADDRGETNETWORKPARAMS = 'EADDRGETNETWORKPARAMS';
+export const CANCELLED = 'ECANCELLED';
+
+export interface LookupOptions {
+  family?: 0 | 4 | 6;
+  hints?: number;
+  all?: boolean;
+  verbatim?: boolean;
+}
+
+export interface LookupAddress {
+  address: string;
+  family: 4 | 6;
+}
+
+function createDnsError(hostname: string, syscall: string, _err?: unknown): ErrnoException {
+  const code = NOTFOUND;
+  const message = `${syscall} ${code} ${hostname}`;
+  const error = new Error(message) as ErrnoException;
+  error.code = code;
+  error.syscall = syscall;
+  error.hostname = hostname;
+  error.errno = undefined;
+  return error;
+}
+
+/**
+ * Resolve a hostname to an IP address using the system DNS resolver.
+ */
+export function lookup(
+  hostname: string,
+  options: LookupOptions | number | null | undefined,
+  callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
+): void;
+export function lookup(
+  hostname: string,
+  callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
+): void;
+export function lookup(
+  hostname: string,
+  ...args: [LookupOptions | number | null | undefined, Function] | [Function]
+): void {
+  let options: LookupOptions = {};
+  let callback: Function;
+
+  if (typeof args[0] === 'function') {
+    callback = args[0];
+  } else {
+    if (typeof args[0] === 'number') {
+      options = { family: args[0] as 0 | 4 | 6 };
+    } else if (args[0]) {
+      options = args[0];
+    }
+    callback = args[1];
+  }
+
+  // Handle empty hostname — Node.js returns null for address
+  if (!hostname) {
+    const family = options.family || 4;
+    callback(null, null as unknown as string, family);
+    return;
+  }
+
+  // Handle IP addresses directly (no DNS needed)
+  const ipVersion = isIP(hostname);
+  if (ipVersion) {
+    callback(null, hostname, ipVersion);
+    return;
+  }
+
+  const resolver = Gio.Resolver.get_default();
+
+  resolver.lookup_by_name_async(
+    hostname,
+    null, // cancellable
+    (_source: Gio.Resolver | null, asyncResult: Gio.AsyncResult) => {
+      try {
+        const addresses = resolver.lookup_by_name_finish(asyncResult);
+
+        if (!addresses || addresses.length === 0) {
+          callback(createDnsError(hostname, 'getaddrinfo'), '', 0);
+          return;
+        }
+
+        // Filter by family if requested
+        const family = options.family || 0;
+        let results: Gio.InetAddress[] = [];
+
+        for (const addr of addresses) {
+          const addrFamily = addr.get_family();
+          if (family === 0 ||
+              (family === 4 && addrFamily === Gio.SocketFamily.IPV4) ||
+              (family === 6 && addrFamily === Gio.SocketFamily.IPV6)) {
+            results.push(addr);
+          }
+        }
+
+        if (results.length === 0) {
+          // Fall back to any available if no match for requested family
+          results = Array.from(addresses);
+        }
+
+        if (options.all) {
+          const allAddresses: LookupAddress[] = results.map((addr) => ({
+            address: addr.to_string(),
+            family: addr.get_family() === Gio.SocketFamily.IPV6 ? 6 as const : 4 as const,
+          }));
+          (callback as any)(null, allAddresses);
+        } else {
+          const first = results[0];
+          const addrStr = first.to_string();
+          const addrFamily = first.get_family() === Gio.SocketFamily.IPV6 ? 6 : 4;
+          callback(null, addrStr, addrFamily);
+        }
+      } catch (_err: unknown) {
+        callback(createDnsError(hostname, 'getaddrinfo'), '', 0);
+      }
+    },
+  );
+}
+
+/**
+ * Resolve a hostname to an array of IPv4 addresses.
+ */
+export function resolve4(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void {
+  lookup(hostname, { family: 4, all: true }, (err, addresses) => {
+    if (err) {
+      callback(err, []);
+      return;
+    }
+    callback(null, (addresses as unknown as LookupAddress[]).map((a) => a.address));
+  });
+}
+
+/**
+ * Resolve a hostname to an array of IPv6 addresses.
+ */
+export function resolve6(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void {
+  lookup(hostname, { family: 6, all: true }, (err, addresses) => {
+    if (err) {
+      callback(err, []);
+      return;
+    }
+    callback(null, (addresses as unknown as LookupAddress[]).map((a) => a.address));
+  });
+}
+
+/**
+ * Reverse DNS lookup.
+ */
+export function reverse(ip: string, callback: (err: NodeJS.ErrnoException | null, hostnames: string[]) => void): void {
+  const resolver = Gio.Resolver.get_default();
+  const addr = Gio.InetAddress.new_from_string(ip);
+
+  if (!addr) {
+    const err = new Error(`Invalid IP address: ${ip}`) as NodeJS.ErrnoException;
+    err.code = 'ERR_INVALID_ARG_VALUE';
+    callback(err, []);
+    return;
+  }
+
+  resolver.lookup_by_address_async(
+    addr,
+    null,
+    (_source: Gio.Resolver | null, asyncResult: Gio.AsyncResult) => {
+      try {
+        const hostname = resolver.lookup_by_address_finish(asyncResult);
+        callback(null, hostname ? [hostname] : []);
+      } catch (_err: unknown) {
+        callback(createDnsError(ip, 'getnameinfo'), []);
+      }
+    },
+  );
+}
+
+/**
+ * Resolve hostname using specified record type.
+ */
+export function resolve(hostname: string, rrtype: string, callback: (err: NodeJS.ErrnoException | null, records: unknown[]) => void): void;
+export function resolve(hostname: string, callback: (err: NodeJS.ErrnoException | null, records: string[]) => void): void;
+export function resolve(hostname: string, ...args: [string, Function] | [Function]): void {
+  let rrtype = 'A';
+  let callback: Function;
+
+  if (typeof args[0] === 'function') {
+    callback = args[0];
+  } else {
+    rrtype = args[0];
+    callback = args[1];
+  }
+
+  switch (rrtype.toUpperCase()) {
+    case 'A':
+      resolve4(hostname, callback as (err: NodeJS.ErrnoException | null, addresses: string[]) => void);
+      break;
+    case 'AAAA':
+      resolve6(hostname, callback as (err: NodeJS.ErrnoException | null, addresses: string[]) => void);
+      break;
+    default:
+      // For other record types (MX, TXT, SRV, etc.), use Gio.Resolver.lookup_records
+      _resolveRecords(hostname, rrtype, callback);
+  }
+}
+
+function _resolveRecords(hostname: string, rrtype: string, callback: Function): void {
+  const resolver = Gio.Resolver.get_default();
+
+  const recordTypeMap: Record<string, Gio.ResolverRecordType> = {
+    SRV: Gio.ResolverRecordType.SRV,
+    MX: Gio.ResolverRecordType.MX,
+    TXT: Gio.ResolverRecordType.TXT,
+    SOA: Gio.ResolverRecordType.SOA,
+    NS: Gio.ResolverRecordType.NS,
+  };
+
+  const gioType = recordTypeMap[rrtype.toUpperCase()];
+  if (!gioType) {
+    const err = new Error(`Unknown record type: ${rrtype}`) as NodeJS.ErrnoException;
+    err.code = 'ERR_INVALID_ARG_VALUE';
+    callback(err, []);
+    return;
+  }
+
+  resolver.lookup_records_async(
+    hostname,
+    gioType,
+    null,
+    (_source: Gio.Resolver | null, asyncResult: Gio.AsyncResult) => {
+      try {
+        const records = resolver.lookup_records_finish(asyncResult);
+        // Records are GLib.Variant arrays — convert to JS
+        const results = records.map((r: GLib.Variant) => r.deep_unpack());
+        callback(null, results as unknown[]);
+      } catch (_err: unknown) {
+        callback(createDnsError(hostname, 'queryDns'), []);
+      }
+    },
+  );
+}
+
+// Default result order
+let _defaultResultOrder: 'ipv4first' | 'verbatim' = 'verbatim';
+
+export function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void {
+  _defaultResultOrder = order;
+}
+
+export function getDefaultResultOrder(): string {
+  return _defaultResultOrder;
+}
+
+export default {
+  lookup,
+  resolve,
+  resolve4,
+  resolve6,
+  reverse,
+  setDefaultResultOrder,
+  getDefaultResultOrder,
+  NODATA,
+  FORMERR,
+  SERVFAIL,
+  NOTFOUND,
+  NOTIMP,
+  REFUSED,
+  BADQUERY,
+  BADNAME,
+  BADFAMILY,
+  BADRESP,
+  CONNREFUSED,
+  TIMEOUT,
+  EOF,
+  FILE,
+  NOMEM,
+  DESTRUCTION,
+  BADSTR,
+  BADFLAGS,
+  NONAME,
+  BADHINTS,
+  NOTINITIALIZED,
+  CANCELLED,
+};