@tradetrust-tt/dnsprove 2.20.0 → 2.21.0

package/dist/index.js

@@ -58,7 +58,7 @@ function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symb
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 const _getLogger = (0, _logger.getLogger)("index"),
   trace = _getLogger.trace;
-const defaultDnsResolvers = exports.defaultDnsResolvers = [_dnsResolvers.googleDnsResolver, _dnsResolvers.cloudflareDnsResolver, _dnsResolvers.aliDnsResolver];
+const defaultDnsResolvers = exports.defaultDnsResolvers = [_dnsResolvers.googleDnsResolver, _dnsResolvers.cloudflareDnsResolver, _dnsResolvers.proxyDnsResolver, _dnsResolvers.aliDnsResolver];
 
 /**
  * Returns true for strings that are openattestation records

package/dist/ts/util/dns-resolvers/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./google-dns-resolver";
 export * from "./cloudflare-dns-resolver";
 export * from "./ali-dns-resolver";
+export * from "./proxy-dns-resolver";

package/dist/ts/util/dns-resolvers/proxy-dns-resolver.d.ts

@@ -0,0 +1,3 @@
+import type { CustomDnsResolver } from "../..";
+/** Server-side DoH proxy that forwards to Google/Cloudflare upstream — reachable from regions where direct access to those endpoints is blocked. */
+export declare const proxyDnsResolver: CustomDnsResolver;

package/dist/util/dns-resolvers/index.js

@@ -35,4 +35,15 @@ Object.keys(_aliDnsResolver).forEach(function (key) {
       return _aliDnsResolver[key];
     }
   });
+});
+var _proxyDnsResolver = require("./proxy-dns-resolver");
+Object.keys(_proxyDnsResolver).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _proxyDnsResolver[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _proxyDnsResolver[key];
+    }
+  });
 });

package/dist/util/dns-resolvers/proxy-dns-resolver.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.proxyDnsResolver = void 0;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+/** Server-side DoH proxy that forwards to Google/Cloudflare upstream — reachable from regions where direct access to those endpoints is blocked. */
+const proxyDnsResolver = exports.proxyDnsResolver = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* (domain) {
+    const url = new URL("https://dns.opencerts.io/resolve");
+    if (!domain) {
+      throw new Error("Domain is required");
+    }
+    url.searchParams.set("name", domain);
+    url.searchParams.set("type", "TXT");
+    const res = yield fetch(url);
+    if (!res.ok) {
+      throw new Error(`Proxy DNS request failed: HTTP ${res.status}`);
+    }
+    let data;
+    try {
+      data = yield res.json();
+    } catch (_unused) {
+      throw new Error("Failed to parse DNS response JSON");
+    }
+    return data;
+  });
+  return function proxyDnsResolver(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradetrust-tt/dnsprove",
-  "version": "2.20.0",
+  "version": "2.21.0",
   "description": "Helper utility for retrieving OpenAttestations document store address records from DNS",
   "license": "Apache-2.0",
   "repository": {

package/src/index.ts

@@ -2,7 +2,7 @@ import { OpenAttestationDNSTextRecord, OpenAttestationDNSTextRecordT } from "./r
 import { OpenAttestationDnsDidRecord, OpenAttestationDnsDidRecordT } from "./records/dnsDid";
 import { getLogger } from "./util/logger";
 import { CodedError, DnsproveStatusCode } from "./common/error";
-import { aliDnsResolver, cloudflareDnsResolver, googleDnsResolver } from "./util/dns-resolvers";
+import { aliDnsResolver, cloudflareDnsResolver, googleDnsResolver, proxyDnsResolver } from "./util/dns-resolvers";
 
 const { trace } = getLogger("index");
 
@@ -24,7 +24,12 @@ interface GenericObject {
 
 export type CustomDnsResolver = (domain: string) => Promise<IDNSQueryResponse>;
 
-export const defaultDnsResolvers: CustomDnsResolver[] = [googleDnsResolver, cloudflareDnsResolver, aliDnsResolver];
+export const defaultDnsResolvers: CustomDnsResolver[] = [
+  googleDnsResolver,
+  cloudflareDnsResolver,
+  proxyDnsResolver,
+  aliDnsResolver,
+];
 
 /**
  * Returns true for strings that are openattestation records

package/src/util/dns-resolvers/dns-resolvers.test.ts

@@ -3,6 +3,7 @@ import { http, HttpResponse } from "msw";
 import { aliDnsResolver } from "./ali-dns-resolver";
 import { cloudflareDnsResolver } from "./cloudflare-dns-resolver";
 import { googleDnsResolver } from "./google-dns-resolver";
+import { proxyDnsResolver } from "./proxy-dns-resolver";
 
 const emptyDnsJson = {
   Status: 0,
@@ -118,3 +119,37 @@ describe("aliDnsResolver", () => {
     await expect(aliDnsResolver("")).rejects.toThrow("Domain is required");
   });
 });
+
+describe("proxyDnsResolver", () => {
+  let server: SetupServerApi | undefined;
+
+  afterEach(() => {
+    server?.close();
+  });
+
+  test("requests proxy DNS JSON with name, TXT type, and encoded query", async () => {
+    server = setupServer(
+      http.get("https://dns.opencerts.io/resolve", ({ request }) => {
+        const url = new URL(request.url);
+        expect(url.searchParams.get("name")).toBe("oc example.test");
+        expect(url.searchParams.get("type")).toBe("TXT");
+        return HttpResponse.json(emptyDnsJson);
+      })
+    );
+    server.listen();
+
+    const out = await proxyDnsResolver("oc example.test");
+    expect(out).toMatchObject({ Status: 0, Answer: [] });
+  });
+
+  test("throws when proxy DNS returns non-2xx", async () => {
+    server = setupServer(http.get("https://dns.opencerts.io/resolve", () => new HttpResponse(null, { status: 502 })));
+    server.listen();
+
+    await expect(proxyDnsResolver("oc.example.test")).rejects.toThrow(/HTTP 502/);
+  });
+
+  test("throws when domain is empty", async () => {
+    await expect(proxyDnsResolver("")).rejects.toThrow("Domain is required");
+  });
+});

package/src/util/dns-resolvers/index.ts

@@ -1,3 +1,4 @@
 export * from "./google-dns-resolver";
 export * from "./cloudflare-dns-resolver";
 export * from "./ali-dns-resolver";
+export * from "./proxy-dns-resolver";

package/src/util/dns-resolvers/proxy-dns-resolver.ts

@@ -0,0 +1,28 @@
+import type { CustomDnsResolver, IDNSQueryResponse } from "../..";
+
+/** Server-side DoH proxy that forwards to Google/Cloudflare upstream — reachable from regions where direct access to those endpoints is blocked. */
+export const proxyDnsResolver: CustomDnsResolver = async (domain) => {
+  const url = new URL("https://dns.opencerts.io/resolve");
+
+  if (!domain) {
+    throw new Error("Domain is required");
+  }
+
+  url.searchParams.set("name", domain);
+  url.searchParams.set("type", "TXT");
+
+  const res = await fetch(url);
+
+  if (!res.ok) {
+    throw new Error(`Proxy DNS request failed: HTTP ${res.status}`);
+  }
+
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    throw new Error("Failed to parse DNS response JSON");
+  }
+
+  return data as IDNSQueryResponse;
+};