Skip to content

Full Toolkit for Next-Level Domain Analysis

Centralize DoH transport and disable upstream DNS caching 🛡️🧠 (#115)

Felix Wotschofsky2e3dbb3f5ec1
diff --git a/lib/ips.test.ts b/lib/ips.test.ts
index b8e06e2..fd4d3dd 100644
--- a/lib/ips.test.ts
+++ b/lib/ips.test.ts
@@ -1,5 +1,5 @@
import isIP from 'validator/lib/isIP';
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import {
getIpDetails,
@@ -140,38 +140,95 @@ describe('getIpDetails', () => {
});
describe('lookupReverse', () => {
- it('should return an array of domain names from reverse DNS lookups', async () => {
- const fakeResponse = {
- json: vi.fn().mockResolvedValue({
- Answer: [{ data: 'dns.google.' }, { data: 'another.dns.google.' }],
- }),
- ok: true,
- };
- global.fetch = vi.fn().mockResolvedValue(fakeResponse);
+ const fetchMock = vi.fn();
- const results = await lookupReverse('8.8.8.8');
- expect(results).toEqual(['dns.google', 'another.dns.google']);
+ beforeEach(() => {
+ fetchMock.mockReset();
+ vi.stubGlobal('fetch', fetchMock);
});
- it('should return an empty array if no answers are found in the DNS lookup', async () => {
- const fakeResponse = {
- json: vi.fn().mockResolvedValue({}),
- ok: true,
- };
- global.fetch = vi.fn().mockResolvedValue(fakeResponse);
+ afterEach(() => vi.unstubAllGlobals());
+
+ it('returns only PTR hostnames through the uncached Cloudflare resolver', async () => {
+ fetchMock.mockResolvedValue(
+ Response.json({
+ Status: 0,
+ Answer: [
+ {
+ name: '8.8.8.8.in-addr.arpa',
+ type: 5,
+ TTL: 30,
+ data: 'alias.example.',
+ },
+ { name: 'alias.example', type: 12, TTL: 300, data: 'dns.google.' },
+ {
+ name: 'alias.example',
+ type: 12,
+ TTL: 300,
+ data: 'another.dns.google',
+ },
+ ],
+ }),
+ );
- const results = await lookupReverse('8.8.4.4');
- expect(results).toEqual([]);
+ expect(await lookupReverse('8.8.8.8')).toEqual([
+ 'dns.google',
+ 'another.dns.google',
+ ]);
+ expect(fetchMock).toHaveBeenCalledWith(
+ new URL(
+ 'https://cloudflare-dns.com/dns-query?name=8.8.8.8.in-addr.arpa&type=PTR',
+ ),
+ expect.objectContaining({ cache: 'no-store' }),
+ );
});
- it('should throw a user-facing error when the API call for DNS lookup fails', async () => {
- global.fetch = vi.fn().mockResolvedValue({
- ok: false,
- status: 503,
- statusText: 'Service Unavailable',
+ it.each([{ Status: 0 }, { Status: 3 }, { Status: 2 }])(
+ 'returns no hostnames for a DNS response without answers: %j',
+ async (body) => {
+ fetchMock.mockResolvedValue(Response.json(body));
+ expect(await lookupReverse('8.8.4.4')).toEqual([]);
+ },
+ );
+
+ it('preserves resolver errors for failed HTTP responses', async () => {
+ fetchMock.mockResolvedValue(
+ new Response(null, {
+ status: 503,
+ statusText: 'Service Unavailable',
+ }),
+ );
+ await expect(lookupReverse('8.8.4.4')).rejects.toMatchObject({
+ payload: { title: 'DNS resolver is unavailable', retryable: true },
});
+ });
- await expect(lookupReverse('8.8.4.4')).rejects.toThrow(/Cloudflare DNS/);
+ it('wraps network failures in a user-facing error', async () => {
+ const error = new Error('Connection failed');
+ fetchMock.mockRejectedValue(error);
+ await expect(lookupReverse('8.8.4.4')).rejects.toMatchObject({
+ payload: { title: "Couldn't reach Cloudflare DNS", retryable: true },
+ cause: error,
+ });
+ });
+
+ it('rejects malformed DNS data instead of returning an invalid hostname', async () => {
+ fetchMock.mockResolvedValue(
+ Response.json({
+ Status: 0,
+ Answer: [
+ { name: '8.8.4.4.in-addr.arpa', type: 12, TTL: 300, data: null },
+ ],
+ }),
+ );
+ await expect(lookupReverse('8.8.4.4')).rejects.toThrow();
+ });
+
+ it('rejects invalid IP addresses before starting a DNS lookup', async () => {
+ await expect(lookupReverse('not-an-ip')).rejects.toThrow(
+ 'Invalid IP address',
+ );
+ expect(fetchMock).not.toHaveBeenCalled();
});
});
diff --git a/lib/ips.ts b/lib/ips.ts
index cbb3b39..f2efaf9 100644
--- a/lib/ips.ts
+++ b/lib/ips.ts
@@ -1,6 +1,7 @@
import DataLoader from 'dataloader';
import isIP from 'validator/lib/isIP';
+import { CloudflareDoHResolver } from './resolvers/cloudflare';
import { UserFacingError } from './user-facing-error';
type IpDetails = {
@@ -110,17 +111,14 @@ export const lookupReverse = async (ip: string): Promise<string[]> => {
});
}
- const reverseDnsName = ipToDnsName(ip);
-
- let response: Response;
try {
- response = await fetch(
- `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(reverseDnsName)}&type=PTR`,
- {
- headers: { Accept: 'application/dns-json' },
- },
+ const { records } = await new CloudflareDoHResolver().resolveRecordType(
+ ipToDnsName(ip),
+ 'PTR',
);
+ return records.map((record) => record.data.replace(/\.$/, ''));
} catch (error) {
+ if (error instanceof UserFacingError) throw error;
throw new UserFacingError(
{
title: "Couldn't reach Cloudflare DNS",
@@ -131,27 +129,6 @@ export const lookupReverse = async (ip: string): Promise<string[]> => {
{ cause: error },
);
}
-
- if (!response.ok)
- throw new UserFacingError(
- {
- title: 'Cloudflare DNS is unavailable',
- description:
- 'Cloudflare DNS returned an error and may be temporarily down. Please try again shortly.',
- retryable: true,
- },
- {
- cause: new Error(
- `Cloudflare DNS responded with HTTP ${response.status} ${response.statusText}`,
- ),
- },
- );
-
- const data = await response.json();
-
- return data.Answer
- ? data.Answer.map((record: { data: string }) => record.data.slice(0, -1))
- : [];
};
// Standardize last segment of IP address to reduce the number of requests and avoid rate limiting
diff --git a/lib/resolvers/alibaba.ts b/lib/resolvers/alibaba.ts
index ffbf550..d5b6625 100644
--- a/lib/resolvers/alibaba.ts
+++ b/lib/resolvers/alibaba.ts
@@ -1,12 +1,7 @@
-import { BaseDoHResolver } from './base-doh';
+import { BaseDoHResolver, type DoHResolverOptions } from './base-doh';
export class AlibabaDoHResolver extends BaseDoHResolver {
- constructor() {
- super((domain, type) =>
- fetch(`https://dns.alidns.com/resolve?name=${domain}&type=${type}`, {
- method: 'GET',
- headers: { Accept: 'application/json' },
- }),
- );
+ constructor(options: DoHResolverOptions = {}) {
+ super('https://dns.alidns.com/resolve', 'application/json', options);
}
}
diff --git a/lib/resolvers/base-doh.test.ts b/lib/resolvers/base-doh.test.ts
index 3998fe2..4bf1353 100644
--- a/lib/resolvers/base-doh.test.ts
+++ b/lib/resolvers/base-doh.test.ts
@@ -1,42 +1,44 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { BaseDoHResolver, type DoHResponse } from './base-doh';
+import { BaseDoHResolver, type DoHAnswer, type DoHResponse } from './base-doh';
describe('BaseDoHResolver', () => {
- const mockSendRequest = vi.fn();
+ const fetchMock = vi.fn();
- class TestDoHResolver extends BaseDoHResolver {}
+ class TestDoHResolver extends BaseDoHResolver {
+ constructor() {
+ super('https://dns.google/resolve', 'application/json');
+ }
+ }
const mockDoHResponse = (
- answers: Partial<NonNullable<DoHResponse['Answer']>[number]>[] = [],
+ answers: Partial<DoHAnswer>[] = [],
): DoHResponse => ({
Status: 0,
TC: false,
- RD: true,
- RA: true,
- AD: false,
- CD: false,
- Question: [{ name: 'example.com', type: 1 }],
Answer: answers.map((ans) => ({
- name: ans.name || 'example.com',
- type: ans.type || 1,
- TTL: ans.TTL || 300,
- data: ans.data || 'data',
+ name: ans.name ?? 'example.com',
+ type: ans.type ?? 1,
+ TTL: ans.TTL ?? 300,
+ data: ans.data ?? 'data',
})),
});
beforeEach(() => {
- mockSendRequest.mockReset();
+ fetchMock.mockReset();
+ vi.stubGlobal('fetch', fetchMock);
});
+ afterEach(() => vi.unstubAllGlobals());
+
it('should correctly resolve records from DoH response', async () => {
- mockSendRequest.mockResolvedValue({
+ fetchMock.mockResolvedValue({
ok: true,
json: () => Promise.resolve(mockDoHResponse([{ type: 1 }])),
url: 'https://dns.google/resolve',
});
- const resolver = new TestDoHResolver(mockSendRequest);
+ const resolver = new TestDoHResolver();
const records = await resolver.resolveRecordType('example.com', 'A');
expect(records).toEqual({
@@ -50,17 +52,20 @@ describe('BaseDoHResolver', () => {
],
trace: ['HTTPS GET https://dns.google/resolve -> answer: data'],
});
- expect(mockSendRequest).toHaveBeenCalledWith('example.com', 'A');
+ expect(fetchMock).toHaveBeenCalledWith(
+ new URL('https://dns.google/resolve?name=example.com&type=A'),
+ expect.objectContaining({ cache: 'no-store' }),
+ );
});
it('should handle empty answers by returning an empty array', async () => {
- mockSendRequest.mockResolvedValue({
+ fetchMock.mockResolvedValue({
ok: true,
json: () => Promise.resolve(mockDoHResponse([])),
url: 'https://dns.google/resolve',
});
- const resolver = new TestDoHResolver(mockSendRequest);
+ const resolver = new TestDoHResolver();
const records = await resolver.resolveRecordType('example.com', 'A');
expect(records).toEqual({
@@ -70,17 +75,167 @@ describe('BaseDoHResolver', () => {
});
it('should throw a user-facing error for bad HTTP responses', async () => {
- mockSendRequest.mockResolvedValue({
+ fetchMock.mockResolvedValue({
ok: false,
status: 500,
statusText: 'Internal Server Error',
url: 'https://dns.google/resolve',
});
- const resolver = new TestDoHResolver(mockSendRequest);
+ const resolver = new TestDoHResolver();
await expect(
resolver.resolveRecordType('example.com', 'A'),
).rejects.toThrow(/DNS resolver/);
});
+
+ it('keeps aliases and TTLs in raw answers while filtering records by type', async () => {
+ const answers = [
+ { name: 'example.com', type: 5, TTL: 30, data: 'alias.example.' },
+ { name: 'alias.example', type: 16, TTL: 300, data: '"some TXT"' },
+ { name: 'alias.example', type: 65000, TTL: 300, data: 'unknown type' },
+ ];
+ fetchMock.mockResolvedValue({
+ ok: true,
+ json: async () => ({ Status: 0, Answer: answers }),
+ url: 'https://cloudflare-dns.com/dns-query',
+ });
+ const resolver = new TestDoHResolver();
+ expect(
+ (await resolver.resolveAnswers('example.com', 'TXT')).answers,
+ ).toEqual(answers);
+ expect(
+ (await resolver.resolveRecordType('example.com', 'TXT')).records,
+ ).toEqual([
+ { name: 'alias.example', type: 'TXT', TTL: 300, data: '"some TXT"' },
+ ]);
+ });
+
+ it.each([{ Status: 0 }, { Status: 3 }])(
+ 'treats %j as an empty answer',
+ async (body) => {
+ fetchMock.mockResolvedValue({
+ ok: true,
+ json: async () => body,
+ url: 'https://cloudflare-dns.com/dns-query',
+ });
+ const resolver = new TestDoHResolver();
+ expect(await resolver.resolveRecordType('example.com', 'TXT')).toEqual({
+ records: [],
+ trace: ['HTTPS GET https://cloudflare-dns.com/dns-query -> no answer'],
+ });
+ },
+ );
+
+ it('preserves aliases when NXDOMAIN describes the end of a CNAME chain', async () => {
+ fetchMock.mockResolvedValue({
+ ok: true,
+ json: async () => ({
+ ...mockDoHResponse(),
+ Status: 3,
+ Answer: [
+ { name: 'example.com', type: 5, TTL: 300, data: 'missing.example.' },
+ ],
+ }),
+ url: 'https://cloudflare-dns.com/dns-query',
+ });
+ const resolver = new TestDoHResolver();
+ const result = await resolver.resolveAnswers('example.com', 'CNAME');
+ expect(result.rcode).toBe(3);
+ expect(result.answers).toEqual([
+ { name: 'example.com', type: 5, TTL: 300, data: 'missing.example.' },
+ ]);
+ expect(
+ (await resolver.resolveRecordType('example.com', 'CNAME')).records,
+ ).toEqual([
+ {
+ name: 'example.com',
+ type: 'CNAME',
+ TTL: 300,
+ data: 'missing.example.',
+ },
+ ]);
+ });
+
+ it.each([
+ { Status: 1 },
+ { Status: 2 },
+ { Status: 5 },
+ { Status: 0, TC: true },
+ {},
+ { Status: '0' },
+ {
+ Status: 0,
+ Answer: [{ name: 'example.com', type: 16, TTL: -1, data: 'bad' }],
+ },
+ {
+ Status: 0,
+ Answer: [{ name: 'example.com', type: 'TXT', TTL: 300, data: 'bad' }],
+ },
+ {
+ Status: 0,
+ Answer: [{ name: 'example.com', type: 16, TTL: 300, data: null }],
+ },
+ ])('rejects DNS errors and malformed responses: %j', async (body) => {
+ fetchMock.mockResolvedValue({
+ ok: true,
+ json: async () => body,
+ url: 'https://cloudflare-dns.com/dns-query',
+ });
+ const resolver = new TestDoHResolver();
+ await expect(
+ resolver.resolveAnswers('example.com', 'TXT'),
+ ).rejects.toThrow();
+ });
+
+ it('keeps the other record types when the resolver cannot answer one', async () => {
+ fetchMock.mockImplementation(async (url: URL) => ({
+ ok: true,
+ json: async () =>
+ url.searchParams.get('type') === 'RRSIG'
+ ? { Status: 2 }
+ : mockDoHResponse([{ type: 1 }]),
+ url: url.href,
+ }));
+ const resolver = new TestDoHResolver();
+ const results = await resolver.resolveRecordTypes('example.com', [
+ 'A',
+ 'RRSIG',
+ ]);
+ expect(results.A.records).toHaveLength(1);
+ expect(results.RRSIG).toEqual({
+ records: [],
+ trace: [
+ 'HTTPS GET https://dns.google/resolve?name=example.com&type=RRSIG -> DNS status 2',
+ ],
+ });
+ });
+
+ it.each([
+ [400, false],
+ [429, true],
+ [503, true],
+ ])('marks HTTP %i as retryable=%s', async (status, retryable) => {
+ fetchMock.mockResolvedValue({
+ ok: false,
+ status,
+ statusText: 'Failure',
+ url: 'https://cloudflare-dns.com/dns-query',
+ });
+ const resolver = new TestDoHResolver();
+ await expect(
+ resolver.resolveRecordType('example.com', 'TXT'),
+ ).rejects.toMatchObject({
+ payload: { retryable },
+ cause: { message: expect.stringContaining(`HTTP ${status}`) },
+ });
+ });
+
+ it('propagates transport failures', async () => {
+ fetchMock.mockRejectedValue(new DOMException('Cancelled', 'AbortError'));
+ const resolver = new TestDoHResolver();
+ await expect(resolver.resolveAnswers('example.com', 'TXT')).rejects.toThrow(
+ 'Cancelled',
+ );
+ });
});
diff --git a/lib/resolvers/base-doh.ts b/lib/resolvers/base-doh.ts
index c1b6de1..1f29860 100644
--- a/lib/resolvers/base-doh.ts
+++ b/lib/resolvers/base-doh.ts
@@ -1,47 +1,63 @@
+import { z } from 'zod';
+
import { RECORD_TYPES_BY_DECIMAL } from '../data';
import { UserFacingError } from '../user-facing-error';
import { DnsResolver, type RecordType, type ResolverResponse } from './base';
-export type DoHResponse = {
- Status: number;
- TC: boolean;
- RD: boolean;
- RA: boolean;
- AD: boolean;
- CD: boolean;
- Question: {
- name: string;
- type: number;
- }[];
- Answer?: {
- name: string;
- type: number;
- TTL: number;
- data: string;
- }[];
- Authority?: {
- name: string;
- type: number;
- TTL: number;
- data: string;
- }[];
+const answerSchema = z.object({
+ name: z.string(),
+ type: z.number().int().nonnegative(),
+ TTL: z.number().int().nonnegative(),
+ data: z.string(),
+});
+
+const responseSchema = z.object({
+ Status: z.number().int(),
+ TC: z.boolean().optional(),
+ Answer: z.array(answerSchema).optional(),
+});
+
+export type DoHAnswer = z.infer<typeof answerSchema>;
+export type DoHResponse = z.infer<typeof responseSchema>;
+
+export type DoHResolverResponse = {
+ answers: DoHAnswer[];
+ rcode: number;
+ trace: string[];
};
+export type DoHResolverOptions = {
+ signal?: AbortSignal;
+};
+
+const recordTypes: Readonly<Record<number, RecordType | undefined>> =
+ RECORD_TYPES_BY_DECIMAL;
+
export abstract class BaseDoHResolver extends DnsResolver {
constructor(
- private sendRequest: (
- domain: string,
- type: RecordType,
- ) => Promise<Response>,
+ private readonly endpoint: string,
+ private readonly accept: string,
+ private readonly options: DoHResolverOptions = {},
) {
super();
}
- public async resolveRecordType(
+ // `failure` is set when the resolver answered but could not complete the
+ // lookup; HTTP and malformed responses throw.
+ private async query(
domain: string,
type: RecordType,
- ): Promise<ResolverResponse> {
- const response = await this.sendRequest(domain, type);
+ ): Promise<DoHResolverResponse & { failure?: string }> {
+ const url = new URL(this.endpoint);
+ url.searchParams.set('name', domain);
+ url.searchParams.set('type', type);
+
+ const response = await fetch(url, {
+ method: 'GET',
+ headers: { Accept: this.accept },
+ cache: 'no-store',
+ signal: this.options.signal,
+ });
if (!response.ok) {
const retryable = response.status === 429 || response.status >= 500;
throw new UserFacingError(
@@ -58,34 +74,67 @@ export abstract class BaseDoHResolver extends DnsResolver {
},
);
}
- const results = (await response.json()) as DoHResponse;
-
- if (!results.Answer) {
- return {
- records: [],
- trace: [`HTTPS GET ${response.url} -> no answer`],
- };
- }
-
- const filteredAnswers = results.Answer.filter(
- (answer) =>
- answer.type in RECORD_TYPES_BY_DECIMAL &&
- // @ts-expect-error
- RECORD_TYPES_BY_DECIMAL[answer.type] === type,
- );
-
- const cleanedAnswers = filteredAnswers.map((answer) => ({
- name: answer.name,
- type,
- TTL: answer.TTL,
- data: answer.data,
- }));
+ const results = responseSchema.parse(await response.json());
+ const failure = results.TC
+ ? 'Truncated DNS response'
+ : [0, 3].includes(results.Status)
+ ? undefined
+ : `DNS status ${results.Status}`;
+ const answers = failure ? undefined : results.Answer;
return {
- records: cleanedAnswers,
+ answers: answers ?? [],
+ rcode: results.Status,
trace: [
- `HTTPS GET ${response.url} -> answer: ${cleanedAnswers.map((a) => a.data).join(', ')}`,
+ `HTTPS GET ${response.url} -> ${
+ failure ??
+ (answers
+ ? `answer: ${answers.map((answer) => answer.data).join(', ')}`
+ : 'no answer')
+ }`,
],
+ failure,
};
}
+
+ // Preserve the whole answer section, including aliases and unknown types.
+ // Throws on a DNS-level failure, so an empty result always means no data.
+ public async resolveAnswers(
+ domain: string,
+ type: RecordType,
+ ): Promise<DoHResolverResponse> {
+ const { failure, ...response } = await this.query(domain, type);
+ if (failure) {
+ throw new UserFacingError(
+ {
+ title: 'DNS resolver could not complete the lookup',
+ description:
+ 'The DNS resolver returned an error or incomplete response. Please try again shortly.',
+ retryable: true,
+ },
+ { cause: new Error(failure) },
+ );
+ }
+ return response;
+ }
+
+ // A DNS-level failure yields no records and is noted in the trace, so one
+ // unanswerable type (e.g. SERVFAIL for RRSIG) cannot fail a whole batch.
+ public async resolveRecordType(
+ domain: string,
+ type: RecordType,
+ ): Promise<ResolverResponse> {
+ const { answers, trace } = await this.query(domain, type);
+
+ const records = answers
+ .filter((answer) => recordTypes[answer.type] === type)
+ .map((answer) => ({
+ name: answer.name,
+ type,
+ TTL: answer.TTL,
+ data: answer.data,
+ }));
+
+ return { records, trace };
+ }
}
diff --git a/lib/resolvers/cloudflare.ts b/lib/resolvers/cloudflare.ts
index 290ccb3..e3b72f8 100644
--- a/lib/resolvers/cloudflare.ts
+++ b/lib/resolvers/cloudflare.ts
@@ -1,15 +1,11 @@
-import { BaseDoHResolver } from './base-doh';
+import { BaseDoHResolver, type DoHResolverOptions } from './base-doh';
export class CloudflareDoHResolver extends BaseDoHResolver {
- constructor() {
- super((domain, type) =>
- fetch(
- `https://cloudflare-dns.com/dns-query?name=${domain}&type=${type}`,
- {
- method: 'GET',
- headers: { Accept: 'application/dns-json' },
- },
- ),
+ constructor(options: DoHResolverOptions = {}) {
+ super(
+ 'https://cloudflare-dns.com/dns-query',
+ 'application/dns-json',
+ options,
);
}
}
diff --git a/lib/resolvers/doh.test.ts b/lib/resolvers/doh.test.ts
new file mode 100644
index 0000000..120cd9b
--- /dev/null
+++ b/lib/resolvers/doh.test.ts
@@ -0,0 +1,71 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { AlibabaDoHResolver } from './alibaba';
+import { CloudflareDoHResolver } from './cloudflare';
+import { GoogleDoHResolver } from './google';
+
+describe.each([
+ {
+ name: 'Cloudflare',
+ Resolver: CloudflareDoHResolver,
+ endpoint: 'https://cloudflare-dns.com/dns-query',
+ accept: 'application/dns-json',
+ },
+ {
+ name: 'Google',
+ Resolver: GoogleDoHResolver,
+ endpoint: 'https://dns.google/resolve',
+ accept: 'application/json',
+ },
+ {
+ name: 'Alibaba',
+ Resolver: AlibabaDoHResolver,
+ endpoint: 'https://dns.alidns.com/resolve',
+ accept: 'application/json',
+ },
+])('$name DoH resolver', ({ Resolver, endpoint, accept }) => {
+ const fetchMock = vi.fn();
+
+ beforeEach(() => {
+ fetchMock.mockReset();
+ fetchMock.mockResolvedValue(new Response(JSON.stringify({ Status: 0 })));
+ vi.stubGlobal('fetch', fetchMock);
+ });
+
+ afterEach(() => vi.unstubAllGlobals());
+
+ it('uses the provider endpoint and disables caching by default', async () => {
+ await new Resolver().resolveRecordType('example.com', 'A');
+ expect(fetchMock).toHaveBeenCalledWith(
+ new URL(`${endpoint}?name=example.com&type=A`),
+ {
+ method: 'GET',
+ headers: { Accept: accept },
+ cache: 'no-store',
+ signal: undefined,
+ },
+ );
+ });
+
+ it('passes the caller’s cancellation signal to the shared transport', async () => {
+ const controller = new AbortController();
+ const resolver = new Resolver({ signal: controller.signal });
+ await resolver.resolveAnswers('_service.example.com', 'TXT');
+ expect(fetchMock.mock.calls[0][1]).toMatchObject({
+ cache: 'no-store',
+ signal: controller.signal,
+ });
+ });
+
+ it('encodes DNS names as a single query parameter', async () => {
+ await new Resolver().resolveAnswers(
+ 'example.com&name=other.example',
+ 'TXT',
+ );
+ const url = new URL(fetchMock.mock.calls[0][0]);
+ expect(url.searchParams.getAll('name')).toEqual([
+ 'example.com&name=other.example',
+ ]);
+ expect(url.searchParams.get('type')).toBe('TXT');
+ });
+});
diff --git a/lib/resolvers/google.ts b/lib/resolvers/google.ts
index cb800b1..3692123 100644
--- a/lib/resolvers/google.ts
+++ b/lib/resolvers/google.ts
@@ -1,12 +1,7 @@
-import { BaseDoHResolver } from './base-doh';
+import { BaseDoHResolver, type DoHResolverOptions } from './base-doh';
export class GoogleDoHResolver extends BaseDoHResolver {
- constructor() {
- super((domain, type) =>
- fetch(`https://dns.google/resolve?name=${domain}&type=${type}`, {
- method: 'GET',
- headers: { Accept: 'application/json' },
- }),
- );
+ constructor(options: DoHResolverOptions = {}) {
+ super('https://dns.google/resolve', 'application/json', options);
}
}
diff --git a/lib/resolvers/internal.test.ts b/lib/resolvers/internal.test.ts
index 777c38f..d2ef8ce 100644
--- a/lib/resolvers/internal.test.ts
+++ b/lib/resolvers/internal.test.ts
@@ -1,42 +1,42 @@
-import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ResolverMultiResponse, ResolverResponse } from './base';
import { InternalDoHResolver } from './internal';
-global.fetch = vi.fn();
+const fetchMock = vi.fn();
+vi.mock('@/env', () => ({
+ env: {
+ SITE_URL: 'https://example.com',
+ INTERNAL_API_SECRET: 'secret',
+ },
+}));
describe('InternalDoHResolver', () => {
- beforeAll(() => {
- vi.mock('@/env', () => ({
- env: {
- SITE_URL: 'https://example.com',
- INTERNAL_API_SECRET: 'secret',
- },
- }));
+ beforeEach(() => {
+ fetchMock.mockReset();
+ vi.stubGlobal('fetch', fetchMock);
});
- afterAll(() => {
- vi.resetAllMocks();
- });
+ afterEach(() => vi.unstubAllGlobals());
it('should successfully resolve DNS records', async () => {
const resolver = new InternalDoHResolver('cdg', 'google');
- const mockRawRecord = [{ data: '192.168.1.1' }];
- const mockResponse = {
- ok: true,
- json: () => Promise.resolve({ A: mockRawRecord }),
- status: 200,
- statusText: 'OK',
+ const summary: ResolverResponse = {
+ records: [
+ { name: 'example.com', type: 'A', TTL: 300, data: '192.168.1.1' },
+ ],
+ trace: ['DNS lookup'],
};
+ fetchMock.mockResolvedValue(Response.json({ A: summary }));
- vi.mocked(fetch).mockResolvedValue(mockResponse as Response);
-
- const records = await resolver.resolveRecordType('example.com', 'A');
- expect(records).toEqual(mockRawRecord);
+ const result = await resolver.resolveRecordType('example.com', 'A');
+ expect(result).toEqual(summary);
expect(fetch).toHaveBeenCalledWith(
new URL(
'https://example.com/api/internal/resolve/cdg?resolver=google&type=A&domain=example.com',
),
{
+ cache: 'no-store',
headers: {
Authorization: 'secret',
},
@@ -46,13 +46,12 @@ describe('InternalDoHResolver', () => {
it('should throw an error on failed DNS resolution', async () => {
const resolver = new InternalDoHResolver('lhr', 'alibaba');
- const mockResponse = {
- ok: false,
- status: 500,
- statusText: 'Internal Server Error',
- };
-
- vi.mocked(fetch).mockResolvedValue(mockResponse as Response);
+ fetchMock.mockResolvedValue(
+ new Response(null, {
+ status: 500,
+ statusText: 'Internal Server Error',
+ }),
+ );
await expect(
resolver.resolveRecordType('example.com', 'A'),
@@ -61,18 +60,19 @@ describe('InternalDoHResolver', () => {
it('should handle multiple DNS record types', async () => {
const resolver = new InternalDoHResolver('hkg', 'cloudflare');
- const mockRecords = {
- A: [{ data: '192.168.1.1' }],
- AAAA: [{ data: '::1' }],
- };
- const mockResponse = {
- ok: true,
- json: () => Promise.resolve(mockRecords),
- status: 200,
- statusText: 'OK',
+ const mockRecords: ResolverMultiResponse = {
+ A: {
+ records: [
+ { name: 'example.com', type: 'A', TTL: 300, data: '192.168.1.1' },
+ ],
+ trace: ['IPv4 lookup'],
+ },
+ AAAA: {
+ records: [{ name: 'example.com', type: 'AAAA', TTL: 300, data: '::1' }],
+ trace: ['IPv6 lookup'],
+ },
};
-
- vi.mocked(fetch).mockResolvedValue(mockResponse as Response);
+ fetchMock.mockResolvedValue(Response.json(mockRecords));
const records = await resolver.resolveRecordTypes('example.com', [
'A',
@@ -84,6 +84,7 @@ describe('InternalDoHResolver', () => {
'https://example.com/api/internal/resolve/hkg?resolver=cloudflare&type=A&type=AAAA&domain=example.com',
),
{
+ cache: 'no-store',
headers: {
Authorization: 'secret',
},
diff --git a/lib/resolvers/internal.ts b/lib/resolvers/internal.ts
index 1e640fe..8d6591e 100644
--- a/lib/resolvers/internal.ts
+++ b/lib/resolvers/internal.ts
@@ -26,7 +26,7 @@ export class InternalDoHResolver extends DnsResolver {
return baseUrl;
}
- private get requestInit() {
+ private get requestInit(): RequestInit {
const headers: Record<string, string> = {};
if (env.INTERNAL_API_SECRET) {
@@ -38,11 +38,7 @@ export class InternalDoHResolver extends DnsResolver {
env.VERCEL_AUTOMATION_BYPASS_SECRET;
}
- if (Object.keys(headers).length === 0) {
- return {};
- }
-
- return { headers };
+ return { cache: 'no-store', headers };
}
public async resolveRecordType(