feat: Deduplicate DNS records in resolveAll

Co-authored-by: jake <jake@jarv.is>

Author: cursoragent

server/services/dns.test.ts

@@ -45,6 +45,34 @@ function dohAnswer(
 }
 
 describe("resolveAll", () => {
+  it("deduplicates records when DoH provider returns duplicates", async () => {
+    const { resolveAll } = await import("./dns");
+    // Simulate a DoH provider returning duplicate A records (same IP twice)
+    const fetchMock = vi
+      .spyOn(global, "fetch")
+      .mockResolvedValueOnce(
+        dohAnswer([
+          { name: "example.com.", TTL: 60, data: "1.2.3.4" },
+          { name: "example.com.", TTL: 60, data: "1.2.3.4" }, // duplicate!
+          { name: "example.com.", TTL: 60, data: "5.6.7.8" },
+        ]),
+      )
+      .mockResolvedValueOnce(dohAnswer([])) // AAAA
+      .mockResolvedValueOnce(dohAnswer([])) // MX
+      .mockResolvedValueOnce(dohAnswer([])) // TXT
+      .mockResolvedValueOnce(dohAnswer([])); // NS
+
+    const out = await resolveAll("example.com");
+    const aRecords = out.records.filter((r) => r.type === "A");
+
+    // Should have exactly 2 A records (duplicate removed), not 3
+    expect(aRecords).toHaveLength(2);
+    expect(aRecords[0]?.value).toBe("1.2.3.4");
+    expect(aRecords[1]?.value).toBe("5.6.7.8");
+
+    fetchMock.mockRestore();
+  });
+
   it("normalizes records and returns combined results", async () => {
     const { resolveAll } = await import("./dns");
     // The code calls DoH for A, AAAA, MX, TXT, NS in parallel and across providers; we just return A for both A and AAAA etc.

server/services/dns.ts

@@ -251,10 +251,12 @@ export async function resolveAll(domain: string): Promise<DnsResolveResult> {
             isCloudflare: r.isCloudflare ?? undefined,
           })),
         );
-        const merged = sortDnsRecordsByType(
-          [...cachedFresh, ...fetchedStale],
-          types,
-        );
+        // Deduplicate before sorting to prevent duplicates in merged results
+        const deduplicated = deduplicateDnsRecords([
+          ...cachedFresh,
+          ...fetchedStale,
+        ]);
+        const merged = sortDnsRecordsByType(deduplicated, types);
         const counts = (types as DnsType[]).reduce(
           (acc, t) => {
             acc[t] = merged.filter((r) => r.type === t).length;
@@ -370,8 +372,10 @@ export async function resolveAll(domain: string): Promise<DnsResolveResult> {
       console.info(
         `[dns] ok ${registrable} counts=${JSON.stringify(counts)} resolver=${resolverUsed} durations=${JSON.stringify(durationByProvider)}`,
       );
+      // Deduplicate records before returning (same logic as replaceDns uses for DB persistence)
+      const deduplicated = deduplicateDnsRecords(flat);
       // Sort records deterministically to match cache-path ordering
-      const sorted = sortDnsRecordsByType(flat, types);
+      const sorted = sortDnsRecordsByType(deduplicated, types);
       return { records: sorted, resolver: resolverUsed } as DnsResolveResult;
     } catch (err) {
       console.warn(
@@ -466,6 +470,29 @@ function trimQuotes(s: string) {
   return s.replace(/^"|"$/g, "");
 }
 
+/**
+ * Deduplicate DNS records using the same logic as replaceDns.
+ * Records are considered duplicates if they have the same type, name, value, and priority.
+ * Case-insensitive comparison for name and value.
+ */
+function deduplicateDnsRecords(records: DnsRecord[]): DnsRecord[] {
+  const seen = new Set<string>();
+  const deduplicated: DnsRecord[] = [];
+
+  for (const r of records) {
+    // Use case-insensitive comparison, same as replaceDns
+    const priorityPart = r.priority != null ? `|${r.priority}` : "";
+    const key = `${r.type}|${r.name.trim().toLowerCase()}|${r.value.trim().toLowerCase()}${priorityPart}`;
+
+    if (!seen.has(key)) {
+      seen.add(key);
+      deduplicated.push(r);
+    }
+  }
+
+  return deduplicated;
+}
+
 function sortDnsRecordsByType(
   records: DnsRecord[],
   order: readonly DnsType[],