very simple node:dns implementation

completely untested

3 files changed, 445 insertions, 0 deletions

diff --git a/src/bun.js/module_loader.zig b/src/bun.js/module_loader.zig
index cf433414f..6432fb7ca 100644
--- a/src/bun.js/module_loader.zig
+++ b/src/bun.js/module_loader.zig
@@ -1655,6 +1655,24 @@ pub const ModuleLoader = struct {
                         .hash = 0,
                     };
                 },
+                .@"node:dns" => {
+                    return ResolvedSource{
+                        .allocator = null,
+                        .source_code = ZigString.init(jsModuleFromFile(jsc_vm.load_builtins_from_path, "node-dns.exports.js")),
+                        .specifier = ZigString.init("node:dns"),
+                        .source_url = ZigString.init("node:dns"),
+                        .hash = 0,
+                    };
+                },
+                .@"node:dns/promises" => {
+                    return ResolvedSource{
+                        .allocator = null,
+                        .source_code = ZigString.init(jsModuleFromFile(jsc_vm.load_builtins_from_path, "node-dns_promises.exports.js")),
+                        .specifier = ZigString.init("node:dns/promises"),
+                        .source_url = ZigString.init("node:dns/promises"),
+                        .hash = 0,
+                    };
+                },
                 .@"node:path/win32" => {
                     return ResolvedSource{
                         .allocator = null,
@@ -1983,6 +2001,8 @@ pub const HardcodedModule = enum {
     @"node:buffer",
     @"node:child_process",
     @"node:crypto",
+    @"node:dns",
+    @"node:dns/promises",
     @"node:events",
     @"node:fs",
     @"node:fs/promises",
@@ -2033,6 +2053,7 @@ pub const HardcodedModule = enum {
             .{ "node:http", HardcodedModule.@"node:http" },
             .{ "node:https", HardcodedModule.@"node:https" },
             .{ "node:module", HardcodedModule.@"node:module" },
+            .{ "node:dns", HardcodedModule.@"node:dns" },
             .{ "node:net", HardcodedModule.@"node:net" },
             .{ "node:os", HardcodedModule.@"node:os" },
             .{ "node:path", HardcodedModule.@"node:path" },
@@ -2069,6 +2090,8 @@ pub const HardcodedModule = enum {
             .{ "depd", "depd" },
             .{ "detect-libc", "detect-libc" },
             .{ "detect-libc/lib/detect-libc.js", "detect-libc" },
+            .{ "dns", "node:dns" },
+            .{ "dns/promises", "node:dns/promises" },
             .{ "events", "node:events" },
             .{ "ffi", "bun:ffi" },
             .{ "fs", "node:fs" },
@@ -2081,6 +2104,8 @@ pub const HardcodedModule = enum {
             .{ "node:buffer", "node:buffer" },
             .{ "node:child_process", "node:child_process" },
             .{ "node:crypto", "node:crypto" },
+            .{ "node:dns", "node:dns" },
+            .{ "node:dns/promises", "node:dns/promises" },
             .{ "node:events", "node:events" },
             .{ "node:fs", "node:fs" },
             .{ "node:fs/promises", "node:fs/promises" },
diff --git a/src/bun.js/node-dns.exports.js b/src/bun.js/node-dns.exports.js
new file mode 100644
index 000000000..3ffcf2432
--- /dev/null
+++ b/src/bun.js/node-dns.exports.js
@@ -0,0 +1,376 @@
+// only resolve4, resolve, lookup, and resolve6 are implemented.
+
+const { dns } = globalThis.Bun;
+
+function lookup(domain, options, callback) {
+  if (typeof options == "function") {
+    callback = options;
+  }
+
+  if (typeof callback != "function") {
+    throw new TypeError("callback must be a function");
+  }
+
+  if (typeof options == "number") {
+    options = { family: options };
+  }
+
+  dns.lookup(domain, options).then(
+    ([{ address, family }]) => {
+      callback(null, address, family);
+    },
+    (error) => {
+      callback(error);
+    },
+  );
+}
+
+function lookupService(address, port, callback) {
+  if (typeof callback != "function") {
+    throw new TypeError("callback must be a function");
+  }
+
+  callback(null, address, port);
+}
+
+var InternalResolver = class Resolver {
+  constructor(options) {}
+
+  cancel() {}
+
+  getServers() {
+    return [];
+  }
+
+  resolve(hostname, rrtype, callback) {
+    if (typeof rrtype == "function") {
+      callback = rrtype;
+    }
+
+    if (typeof callback != "function") {
+      throw new TypeError("callback must be a function");
+    }
+
+    dns.lookup(hostname).then(
+      (addresses) => {
+        callback(
+          null,
+          hostname,
+          addresses.map(({ address }) => address),
+        );
+      },
+      (error) => {
+        callback(error);
+      },
+    );
+  }
+
+  resolve4(hostname, options, callback) {
+    if (typeof options == "function") {
+      callback = options;
+    }
+
+    if (typeof callback != "function") {
+      throw new TypeError("callback must be a function");
+    }
+
+    dns.lookup(hostname, { family: 4 }).then(
+      (addresses) => {
+        callback(
+          null,
+          addresses.map(({ address }) => address),
+        );
+      },
+      (error) => {
+        callback(error);
+      },
+    );
+  }
+
+  resolve6(hostname, options, callback) {
+    if (typeof options == "function") {
+      callback = options;
+    }
+
+    if (typeof callback != "function") {
+      throw new TypeError("callback must be a function");
+    }
+
+    dns.lookup(hostname, { family: 6 }).then(
+      (addresses) => {
+        callback(
+          null,
+          addresses.map(({ address }) => address),
+        );
+      },
+      (error) => {
+        callback(error);
+      },
+    );
+  }
+
+  resolveAny(hostname, callback) {
+    callback(null, []);
+  }
+
+  resolveCname(hostname, callback) {
+    callback(null, []);
+  }
+
+  resolveMx(hostname, callback) {
+    callback(null, []);
+  }
+
+  resolveNaptr(hostname, callback) {
+    callback(null, []);
+  }
+
+  resolveNs(hostname, callback) {
+    callback(null, []);
+  }
+
+  resolvePtr(hostname, callback) {
+    callback(null, []);
+  }
+
+  resolveSoa(hostname, callback) {
+    callback(null, []);
+  }
+
+  resolveSrv(hostname, callback) {
+    callback(null, []);
+  }
+
+  resolveCaa(hostname, callback) {
+    callback(null, []);
+  }
+
+  resolveTxt(hostname, callback) {
+    callback(null, []);
+  }
+
+  reverse(ip, callback) {
+    callback(null, []);
+  }
+
+  setServers(servers) {}
+};
+
+function Resolver(options) {
+  return new InternalResolver(options);
+}
+Object.setPrototypeOf(Resolver.prototype, InternalResolver.prototype);
+Object.setPrototypeOf(Resolver, InternalResolver);
+
+export var {
+  resolve,
+  resolve4,
+  resolve6,
+  resolveAny,
+  resolveCname,
+  resolveCaa,
+  resolveMx,
+  resolveNaptr,
+  resolveNs,
+  resolvePtr,
+  resolveSoa,
+  resolveSrv,
+  resolveTxt,
+} = InternalResolver.prototype;
+
+function setDefaultResultOrder() {}
+function setServers() {}
+export const { resolve, reverse } = InternalResolver.prototype;
+
+// promisified versions
+export const promises = {
+  lookup(domain, options) {
+    return dns.lookup(domain, options);
+  },
+
+  lookupService(address, port) {
+    return Promise.resolve([]);
+  },
+
+  resolve(hostname, rrtype) {
+    return dns.lookup(hostname);
+  },
+
+  resolve4(hostname, options) {
+    return dns.lookup(hostname, { family: 4 });
+  },
+
+  resolve6(hostname, options) {
+    return dns.lookup(hostname, { family: 6 });
+  },
+
+  Resolver: class Resolver {
+    constructor(options) {}
+
+    cancel() {}
+
+    getServers() {
+      return [];
+    }
+
+    resolve(hostname, rrtype) {
+      return dns.lookup(hostname);
+    }
+
+    resolve4(hostname, options) {
+      return dns.lookup(hostname, { family: 4 });
+    }
+
+    resolve6(hostname, options) {
+      return dns.lookup(hostname, { family: 6 });
+    }
+
+    resolveAny(hostname) {
+      return Promise.resolve([]);
+    }
+
+    resolveCname(hostname) {
+      return Promise.resolve([]);
+    }
+
+    resolveMx(hostname) {
+      return Promise.resolve([]);
+    }
+
+    resolveNaptr(hostname) {
+      return Promise.resolve([]);
+    }
+
+    resolveNs(hostname) {
+      return Promise.resolve([]);
+    }
+
+    resolvePtr(hostname) {
+      return Promise.resolve([]);
+    }
+
+    resolveSoa(hostname) {
+      return Promise.resolve([]);
+    }
+
+    resolveSrv(hostname) {
+      return Promise.resolve([]);
+    }
+
+    resolveCaa(hostname) {
+      return Promise.resolve([]);
+    }
+
+    resolveTxt(hostname) {
+      return Promise.resolve([]);
+    }
+
+    reverse(ip) {
+      return Promise.resolve([]);
+    }
+
+    setServers(servers) {}
+  },
+};
+for (const key of [
+  "resolveAny",
+  "resolveCname",
+  "resolveCaa",
+  "resolveMx",
+  "resolveNaptr",
+  "resolveNs",
+  "resolvePtr",
+  "resolveSoa",
+  "resolveSrv",
+  "resolveTxt",
+  "reverse",
+]) {
+  promises[key] = () => Promise.resolve(undefined);
+}
+
+const exports = {
+  // these are wrong
+  ADDRCONFIG: 0,
+  ALL: 1,
+  V4MAPPED: 2,
+
+  // ERROR CODES
+  NODATA: "DNS_ENODATA",
+  FORMERR: "DNS_EFORMERR",
+  SERVFAIL: "DNS_ESERVFAIL",
+  NOTFOUND: "DNS_ENOTFOUND",
+  NOTIMP: "DNS_ENOTIMP",
+  REFUSED: "DNS_EREFUSED",
+  BADQUERY: "DNS_EBADQUERY",
+  BADNAME: "DNS_EBADNAME",
+  BADFAMILY: "DNS_EBADFAMILY",
+  BADRESP: "DNS_EBADRESP",
+  CONNREFUSED: "DNS_ECONNREFUSED",
+  TIMEOUT: "DNS_ETIMEOUT",
+  EOF: "DNS_EEOF",
+  FILE: "DNS_EFILE",
+  NOMEM: "DNS_ENOMEM",
+  DESTRUCTION: "DNS_EDESTRUCTION",
+  BADSTR: "DNS_EBADSTR",
+  BADFLAGS: "DNS_EBADFLAGS",
+  NONAME: "DNS_ENONAME",
+  BADHINTS: "DNS_EBADHINTS",
+  NOTINITIALIZED: "DNS_ENOTINITIALIZED",
+  LOADIPHLPAPI: "DNS_ELOADIPHLPAPI",
+  ADDRGETNETWORKPARAMS: "DNS_EADDRGETNETWORKPARAMS",
+  CANCELLED: "DNS_ECANCELLED",
+
+  lookup,
+  lookupService,
+  Resolver,
+  setServers,
+  setDefaultResultOrder,
+  resolve,
+  reverse,
+  resolve,
+  resolve4,
+  resolve6,
+  resolveAny,
+  resolveCname,
+  resolveCaa,
+  resolveMx,
+  resolveNaptr,
+  resolveNs,
+  resolvePtr,
+  resolveSoa,
+  resolveSrv,
+  resolveTxt,
+  promises,
+  [Symbol.for("CommonJS")]: 0,
+};
+export default exports;
+export const {
+  ADDRCONFIG,
+  ALL,
+  V4MAPPED,
+  NODATA,
+  FORMERR,
+  SERVFAIL,
+  NOTFOUND,
+  NOTIMP,
+  REFUSED,
+  BADQUERY,
+  BADNAME,
+  BADFAMILY,
+  BADRESP,
+  CONNREFUSED,
+  TIMEOUT,
+  EOF,
+  FILE,
+  NOMEM,
+  DESTRUCTION,
+  BADSTR,
+  BADFLAGS,
+  NONAME,
+  BADHINTS,
+  NOTINITIALIZED,
+  LOADIPHLPAPI,
+  ADDRGETNETWORKPARAMS,
+  CANCELLED,
+} = exports;
+export { lookup, lookupService, Resolver, setServers, setDefaultResultOrder };
diff --git a/src/bun.js/node-dns_promises.exports.js b/src/bun.js/node-dns_promises.exports.js
new file mode 100644
index 000000000..1fc894fe1
--- /dev/null
+++ b/src/bun.js/node-dns_promises.exports.js
@@ -0,0 +1,44 @@
+const { promises } = import.meta.require("node:dns");
+
+export const {
+  lookup,
+  lookupService,
+  resolve,
+  resolve4,
+  resolveAny,
+  resolveCname,
+  resolveCaa,
+  resolveMx,
+  resolveNaptr,
+  resolveNs,
+  resolvePtr,
+  resolveSoa,
+  resolveSrv,
+  resolveTxt,
+  reverse,
+  Resolver,
+  setServers,
+  setDefaultResultOrder,
+} = promises;
+
+export default {
+  lookup,
+  lookupService,
+  resolve,
+  resolve4,
+  resolveAny,
+  resolveCname,
+  resolveCaa,
+  resolveMx,
+  resolveNaptr,
+  resolveNs,
+  resolvePtr,
+  resolveSoa,
+  resolveSrv,
+  resolveTxt,
+  reverse,
+  Resolver,
+  setServers,
+  setDefaultResultOrder,
+  [Symbol.for("CommonJS")]: 0,
+};