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.tsindex 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.tsindex 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 limitingdiff --git a/lib/resolvers/alibaba.ts b/lib/resolvers/alibaba.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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(