@gjsify/dns 0.1.0

package/README.md

@@ -0,0 +1,29 @@
+# @gjsify/dns
+
+GJS implementation of the Node.js `dns` module using Gio.Resolver. Supports lookup, resolve4/6, reverse, and promises API.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/dns
+# or
+yarn add @gjsify/dns
+```
+
+## Usage
+
+```typescript
+import { lookup, promises } from '@gjsify/dns';
+
+lookup('example.com', (err, address, family) => {
+  console.log(`Address: ${address}, Family: ${family}`);
+});
+
+const result = await promises.resolve4('example.com');
+```
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -0,0 +1,263 @@
+import Gio from "@girs/gio-2.0";
+import { isIP } from "node:net";
+const NODATA = "ENODATA";
+const FORMERR = "EFORMERR";
+const SERVFAIL = "ESERVFAIL";
+const NOTFOUND = "ENOTFOUND";
+const NOTIMP = "ENOTIMP";
+const REFUSED = "EREFUSED";
+const BADQUERY = "EBADQUERY";
+const BADNAME = "EBADNAME";
+const BADFAMILY = "EBADFAMILY";
+const BADRESP = "EBADRESP";
+const CONNREFUSED = "ECONNREFUSED";
+const TIMEOUT = "ETIMEOUT";
+const EOF = "EOF";
+const FILE = "EFILE";
+const NOMEM = "ENOMEM";
+const DESTRUCTION = "EDESTRUCTION";
+const BADSTR = "EBADSTR";
+const BADFLAGS = "EBADFLAGS";
+const NONAME = "ENONAME";
+const BADHINTS = "EBADHINTS";
+const NOTINITIALIZED = "ENOTINITIALIZED";
+const LOADIPHLPAPI = "ELOADIPHLPAPI";
+const ADDRGETNETWORKPARAMS = "EADDRGETNETWORKPARAMS";
+const CANCELLED = "ECANCELLED";
+function createDnsError(hostname, syscall, _err) {
+  const code = NOTFOUND;
+  const message = `${syscall} ${code} ${hostname}`;
+  const error = new Error(message);
+  error.code = code;
+  error.syscall = syscall;
+  error.hostname = hostname;
+  error.errno = void 0;
+  return error;
+}
+function lookup(hostname, ...args) {
+  let options = {};
+  let callback;
+  if (typeof args[0] === "function") {
+    callback = args[0];
+  } else {
+    if (typeof args[0] === "number") {
+      options = { family: args[0] };
+    } else if (args[0]) {
+      options = args[0];
+    }
+    callback = args[1];
+  }
+  if (!hostname) {
+    const family = options.family || 4;
+    callback(null, null, family);
+    return;
+  }
+  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, asyncResult) => {
+      try {
+        const addresses = resolver.lookup_by_name_finish(asyncResult);
+        if (!addresses || addresses.length === 0) {
+          callback(createDnsError(hostname, "getaddrinfo"), "", 0);
+          return;
+        }
+        const family = options.family || 0;
+        let results = [];
+        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) {
+          results = Array.from(addresses);
+        }
+        if (options.all) {
+          const allAddresses = results.map((addr) => ({
+            address: addr.to_string(),
+            family: addr.get_family() === Gio.SocketFamily.IPV6 ? 6 : 4
+          }));
+          callback(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) {
+        callback(createDnsError(hostname, "getaddrinfo"), "", 0);
+      }
+    }
+  );
+}
+function resolve4(hostname, callback) {
+  lookup(hostname, { family: 4, all: true }, (err, addresses) => {
+    if (err) {
+      callback(err, []);
+      return;
+    }
+    callback(null, addresses.map((a) => a.address));
+  });
+}
+function resolve6(hostname, callback) {
+  lookup(hostname, { family: 6, all: true }, (err, addresses) => {
+    if (err) {
+      callback(err, []);
+      return;
+    }
+    callback(null, addresses.map((a) => a.address));
+  });
+}
+function reverse(ip, callback) {
+  const resolver = Gio.Resolver.get_default();
+  const addr = Gio.InetAddress.new_from_string(ip);
+  if (!addr) {
+    const err = new Error(`Invalid IP address: ${ip}`);
+    err.code = "ERR_INVALID_ARG_VALUE";
+    callback(err, []);
+    return;
+  }
+  resolver.lookup_by_address_async(
+    addr,
+    null,
+    (_source, asyncResult) => {
+      try {
+        const hostname = resolver.lookup_by_address_finish(asyncResult);
+        callback(null, hostname ? [hostname] : []);
+      } catch (_err) {
+        callback(createDnsError(ip, "getnameinfo"), []);
+      }
+    }
+  );
+}
+function resolve(hostname, ...args) {
+  let rrtype = "A";
+  let callback;
+  if (typeof args[0] === "function") {
+    callback = args[0];
+  } else {
+    rrtype = args[0];
+    callback = args[1];
+  }
+  switch (rrtype.toUpperCase()) {
+    case "A":
+      resolve4(hostname, callback);
+      break;
+    case "AAAA":
+      resolve6(hostname, callback);
+      break;
+    default:
+      _resolveRecords(hostname, rrtype, callback);
+  }
+}
+function _resolveRecords(hostname, rrtype, callback) {
+  const resolver = Gio.Resolver.get_default();
+  const recordTypeMap = {
+    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}`);
+    err.code = "ERR_INVALID_ARG_VALUE";
+    callback(err, []);
+    return;
+  }
+  resolver.lookup_records_async(
+    hostname,
+    gioType,
+    null,
+    (_source, asyncResult) => {
+      try {
+        const records = resolver.lookup_records_finish(asyncResult);
+        const results = records.map((r) => r.deep_unpack());
+        callback(null, results);
+      } catch (_err) {
+        callback(createDnsError(hostname, "queryDns"), []);
+      }
+    }
+  );
+}
+let _defaultResultOrder = "verbatim";
+function setDefaultResultOrder(order) {
+  _defaultResultOrder = order;
+}
+function getDefaultResultOrder() {
+  return _defaultResultOrder;
+}
+var index_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
+};
+export {
+  ADDRGETNETWORKPARAMS,
+  BADFAMILY,
+  BADFLAGS,
+  BADHINTS,
+  BADNAME,
+  BADQUERY,
+  BADRESP,
+  BADSTR,
+  CANCELLED,
+  CONNREFUSED,
+  DESTRUCTION,
+  EOF,
+  FILE,
+  FORMERR,
+  LOADIPHLPAPI,
+  NODATA,
+  NOMEM,
+  NONAME,
+  NOTFOUND,
+  NOTIMP,
+  NOTINITIALIZED,
+  REFUSED,
+  SERVFAIL,
+  TIMEOUT,
+  index_default as default,
+  getDefaultResultOrder,
+  lookup,
+  resolve,
+  resolve4,
+  resolve6,
+  reverse,
+  setDefaultResultOrder
+};

package/lib/esm/promises.js

@@ -0,0 +1,61 @@
+import { lookup as _lookup, resolve4 as _resolve4, resolve6 as _resolve6, reverse as _reverse, resolve as _resolve } from "./index.js";
+function lookup(hostname, options) {
+  return new Promise((resolve2, reject) => {
+    _lookup(hostname, options, (err, address, family) => {
+      if (err) return reject(err);
+      if (Array.isArray(address)) {
+        resolve2(address);
+      } else {
+        resolve2({ address, family });
+      }
+    });
+  });
+}
+function resolve4(hostname) {
+  return new Promise((resolve2, reject) => {
+    _resolve4(hostname, (err, addresses) => {
+      if (err) return reject(err);
+      resolve2(addresses);
+    });
+  });
+}
+function resolve6(hostname) {
+  return new Promise((resolve2, reject) => {
+    _resolve6(hostname, (err, addresses) => {
+      if (err) return reject(err);
+      resolve2(addresses);
+    });
+  });
+}
+function reverse(ip) {
+  return new Promise((resolve2, reject) => {
+    _reverse(ip, (err, hostnames) => {
+      if (err) return reject(err);
+      resolve2(hostnames);
+    });
+  });
+}
+function resolve(hostname, rrtype) {
+  return new Promise((res, reject) => {
+    if (rrtype) {
+      _resolve(hostname, rrtype, (err, records) => {
+        if (err) return reject(err);
+        res(records);
+      });
+    } else {
+      _resolve(hostname, (err, records) => {
+        if (err) return reject(err);
+        res(records);
+      });
+    }
+  });
+}
+var promises_default = { lookup, resolve, resolve4, resolve6, reverse };
+export {
+  promises_default as default,
+  lookup,
+  resolve,
+  resolve4,
+  resolve6,
+  reverse
+};

package/lib/types/index.d.ts

@@ -0,0 +1,90 @@
+export declare const NODATA = "ENODATA";
+export declare const FORMERR = "EFORMERR";
+export declare const SERVFAIL = "ESERVFAIL";
+export declare const NOTFOUND = "ENOTFOUND";
+export declare const NOTIMP = "ENOTIMP";
+export declare const REFUSED = "EREFUSED";
+export declare const BADQUERY = "EBADQUERY";
+export declare const BADNAME = "EBADNAME";
+export declare const BADFAMILY = "EBADFAMILY";
+export declare const BADRESP = "EBADRESP";
+export declare const CONNREFUSED = "ECONNREFUSED";
+export declare const TIMEOUT = "ETIMEOUT";
+export declare const EOF = "EOF";
+export declare const FILE = "EFILE";
+export declare const NOMEM = "ENOMEM";
+export declare const DESTRUCTION = "EDESTRUCTION";
+export declare const BADSTR = "EBADSTR";
+export declare const BADFLAGS = "EBADFLAGS";
+export declare const NONAME = "ENONAME";
+export declare const BADHINTS = "EBADHINTS";
+export declare const NOTINITIALIZED = "ENOTINITIALIZED";
+export declare const LOADIPHLPAPI = "ELOADIPHLPAPI";
+export declare const ADDRGETNETWORKPARAMS = "EADDRGETNETWORKPARAMS";
+export declare const CANCELLED = "ECANCELLED";
+export interface LookupOptions {
+    family?: 0 | 4 | 6;
+    hints?: number;
+    all?: boolean;
+    verbatim?: boolean;
+}
+export interface LookupAddress {
+    address: string;
+    family: 4 | 6;
+}
+/**
+ * Resolve a hostname to an IP address using the system DNS resolver.
+ */
+export declare function lookup(hostname: string, options: LookupOptions | number | null | undefined, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
+export declare function lookup(hostname: string, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
+/**
+ * Resolve a hostname to an array of IPv4 addresses.
+ */
+export declare function resolve4(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
+/**
+ * Resolve a hostname to an array of IPv6 addresses.
+ */
+export declare function resolve6(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
+/**
+ * Reverse DNS lookup.
+ */
+export declare function reverse(ip: string, callback: (err: NodeJS.ErrnoException | null, hostnames: string[]) => void): void;
+/**
+ * Resolve hostname using specified record type.
+ */
+export declare function resolve(hostname: string, rrtype: string, callback: (err: NodeJS.ErrnoException | null, records: unknown[]) => void): void;
+export declare function resolve(hostname: string, callback: (err: NodeJS.ErrnoException | null, records: string[]) => void): void;
+export declare function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void;
+export declare function getDefaultResultOrder(): string;
+declare const _default: {
+    lookup: typeof lookup;
+    resolve: typeof resolve;
+    resolve4: typeof resolve4;
+    resolve6: typeof resolve6;
+    reverse: typeof reverse;
+    setDefaultResultOrder: typeof setDefaultResultOrder;
+    getDefaultResultOrder: typeof getDefaultResultOrder;
+    NODATA: string;
+    FORMERR: string;
+    SERVFAIL: string;
+    NOTFOUND: string;
+    NOTIMP: string;
+    REFUSED: string;
+    BADQUERY: string;
+    BADNAME: string;
+    BADFAMILY: string;
+    BADRESP: string;
+    CONNREFUSED: string;
+    TIMEOUT: string;
+    EOF: string;
+    FILE: string;
+    NOMEM: string;
+    DESTRUCTION: string;
+    BADSTR: string;
+    BADFLAGS: string;
+    NONAME: string;
+    BADHINTS: string;
+    NOTINITIALIZED: string;
+    CANCELLED: string;
+};
+export default _default;

package/lib/types/promises.d.ts

@@ -0,0 +1,14 @@
+import type { LookupOptions, LookupAddress } from './index.js';
+export declare function lookup(hostname: string, options?: LookupOptions | number): Promise<LookupAddress | LookupAddress[]>;
+export declare function resolve4(hostname: string): Promise<string[]>;
+export declare function resolve6(hostname: string): Promise<string[]>;
+export declare function reverse(ip: string): Promise<string[]>;
+export declare function resolve(hostname: string, rrtype?: string): Promise<any[]>;
+declare const _default: {
+    lookup: typeof lookup;
+    resolve: typeof resolve;
+    resolve4: typeof resolve4;
+    resolve6: typeof resolve6;
+    reverse: typeof reverse;
+};
+export default _default;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@gjsify/dns",
+  "version": "0.1.0",
+  "description": "Node.js dns module for Gjs",
+  "type": "module",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
+    },
+    "./promises": {
+      "types": "./lib/types/promises.d.ts",
+      "default": "./lib/esm/promises.js"
+    }
+  },
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+    "build:types": "tsc",
+    "build:test": "yarn build:test:gjs && yarn build:test:node",
+    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.mjs",
+    "test:node": "node test.node.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "node",
+    "dns"
+  ],
+  "devDependencies": {
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
+  },
+  "dependencies": {
+    "@girs/gio-2.0": "^2.88.0-4.0.0-beta.42",
+    "@girs/glib-2.0": "^2.88.0-4.0.0-beta.42",
+    "@gjsify/net": "^0.1.0",
+    "@gjsify/utils": "^0.1.0"
+  }
+}