@dnscmp/core 0.0.1

package/README.md

@@ -0,0 +1,30 @@
+# @dnscmp/core
+
+Library for benchmarking and comparing DNS resolution times across DNS providers.
+
+## Usage
+
+```ts
+import { dnscmp } from "@dnscmp/core";
+
+const results = await dnscmp({
+  providers: [
+    { name: "Cloudflare", ips: ["1.1.1.1", "1.0.0.1"] },
+    { name: "Google", ips: ["8.8.8.8", "8.8.4.4"] },
+  ],
+});
+
+console.log(results);
+// [
+//   { name: "Cloudflare", resolver: "1.1.1.1", avg: 3.42 },
+//   { name: "Google", resolver: "8.8.8.8", avg: 7.81 },
+// ]
+```
+
+Results are sorted fastest-first. Providers with multiple IPs are all tested; only the fastest IP per provider is returned. Providers that fail to respond (timeout or 3 consecutive failures) return `avg: null` and are sorted last.
+
+## Build
+
+```bash
+bun run build
+```

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import type { DnsProvider, DnsResult } from "@dnscmp/types";
+export type { DnsProvider, DnsResult };
+export interface DnscmpOptions {
+	providers: DnsProvider[];
+	domains?: string[];
+	tries?: number;
+}
+export declare function dnscmp(options: DnscmpOptions): Promise<DnsResult[]>;

package/dist/index.js

@@ -0,0 +1,71 @@
+// src/index.ts
+import { Resolver } from "dns/promises";
+var DEFAULT_DOMAINS = ["example.com", "example.org", "example.net"];
+var DEFAULT_TRIES = 10;
+var QUERY_TIMEOUT_MS = 1000;
+var MAX_CONSECUTIVE_FAILURES = 3;
+function withTimeout(promise, ms) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => setTimeout(() => reject(new Error("ETIMEOUT")), ms))
+  ]);
+}
+async function measureAvg(resolverIp, domains, tries) {
+  const resolver = new Resolver;
+  resolver.setServers([resolverIp]);
+  let total = 0;
+  let count = 0;
+  let consecutiveFailures = 0;
+  for (let i = 0;i < tries; i++) {
+    for (const domain of domains) {
+      try {
+        const start = performance.now();
+        await withTimeout(resolver.resolve4(domain), QUERY_TIMEOUT_MS);
+        total += performance.now() - start;
+        count++;
+        consecutiveFailures = 0;
+      } catch {
+        consecutiveFailures++;
+        if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+          return null;
+        }
+      }
+    }
+  }
+  return count > 0 ? total / count : null;
+}
+async function measureProvider(provider, domains, tries) {
+  const resolverResults = await Promise.all(provider.resolvers.map(async (resolverIp) => ({
+    resolverIp,
+    avg: await measureAvg(resolverIp, domains, tries)
+  })));
+  resolverResults.sort((a, b) => {
+    if (a.avg === null && b.avg === null)
+      return 0;
+    if (a.avg === null)
+      return 1;
+    if (b.avg === null)
+      return -1;
+    return a.avg - b.avg;
+  });
+  const best = resolverResults[0];
+  return { name: provider.name, resolver: best.resolverIp, avg: best.avg };
+}
+async function dnscmp(options) {
+  const domains = options.domains ?? DEFAULT_DOMAINS;
+  const tries = options.tries ?? DEFAULT_TRIES;
+  const results = await Promise.all(options.providers.map((provider) => measureProvider(provider, domains, tries)));
+  results.sort((a, b) => {
+    if (a.avg === null && b.avg === null)
+      return 0;
+    if (a.avg === null)
+      return 1;
+    if (b.avg === null)
+      return -1;
+    return a.avg - b.avg;
+  });
+  return results;
+}
+export {
+  dnscmp
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@dnscmp/core",
+  "description": "Library for benchmarking and comparing DNS resolution times across DNS providers.",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "homepage": "https://github.com/oBusk/dnscmp#readme",
+  "bugs": {
+    "url": "https://github.com/oBusk/dnscmp/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oBusk/dnscmp",
+    "directory": "packages/core"
+  },
+  "license": "MIT",
+  "author": "Oscar Busk (https://github.com/oBusk)",
+  "scripts": {
+    "build": "bun run build.ts"
+  },
+  "dependencies": {
+    "@dnscmp/types": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "bun-plugin-isolated-decl": "^0.2",
+    "oxc-transform": "~0.123",
+    "typescript": "^5"
+  }
+}

package/src/index.ts

@@ -0,0 +1,99 @@
+import type { DnsProvider, DnsResult } from "@dnscmp/types";
+import { Resolver } from "dns/promises";
+
+export type { DnsProvider, DnsResult };
+
+const DEFAULT_DOMAINS = ["example.com", "example.org", "example.net"];
+const DEFAULT_TRIES = 10;
+const QUERY_TIMEOUT_MS = 1000;
+const MAX_CONSECUTIVE_FAILURES = 3;
+
+export interface DnscmpOptions {
+  providers: DnsProvider[];
+  domains?: string[];
+  tries?: number;
+}
+
+function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<T>((_, reject) =>
+      setTimeout(() => reject(new Error("ETIMEOUT")), ms),
+    ),
+  ]);
+}
+
+async function measureAvg(
+  resolverIp: string,
+  domains: string[],
+  tries: number,
+): Promise<number | null> {
+  const resolver = new Resolver();
+  resolver.setServers([resolverIp]);
+
+  let total = 0;
+  let count = 0;
+  let consecutiveFailures = 0;
+
+  for (let i = 0; i < tries; i++) {
+    for (const domain of domains) {
+      try {
+        const start = performance.now();
+        await withTimeout(resolver.resolve4(domain), QUERY_TIMEOUT_MS);
+        total += performance.now() - start;
+        count++;
+        consecutiveFailures = 0;
+      } catch {
+        consecutiveFailures++;
+        if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+          return null;
+        }
+      }
+    }
+  }
+
+  return count > 0 ? total / count : null;
+}
+
+async function measureProvider(
+  provider: DnsProvider,
+  domains: string[],
+  tries: number,
+): Promise<DnsResult> {
+  const resolverResults = await Promise.all(
+    provider.resolvers.map(async (resolverIp) => ({
+      resolverIp,
+      avg: await measureAvg(resolverIp, domains, tries),
+    })),
+  );
+
+  resolverResults.sort((a, b) => {
+    if (a.avg === null && b.avg === null) return 0;
+    if (a.avg === null) return 1;
+    if (b.avg === null) return -1;
+    return a.avg - b.avg;
+  });
+
+  const best = resolverResults[0]!;
+  return { name: provider.name, resolver: best.resolverIp, avg: best.avg };
+}
+
+export async function dnscmp(options: DnscmpOptions): Promise<DnsResult[]> {
+  const domains = options.domains ?? DEFAULT_DOMAINS;
+  const tries = options.tries ?? DEFAULT_TRIES;
+
+  const results = await Promise.all(
+    options.providers.map((provider) =>
+      measureProvider(provider, domains, tries),
+    ),
+  );
+
+  results.sort((a, b) => {
+    if (a.avg === null && b.avg === null) return 0;
+    if (a.avg === null) return 1;
+    if (b.avg === null) return -1;
+    return a.avg - b.avg;
+  });
+
+  return results;
+}