1
// Copyright (c) 2017-2022 Cloudflare, Inc.
2
// Licensed under the Apache 2.0 license found in the LICENSE file or at:
3
//     https://opensource.org/licenses/Apache-2.0
4
// Copyright Joyent and Node contributors. All rights reserved. MIT license.
5
 
6
import type dns from 'node:dns/promises';
7
import type {
8
  LookupAddress,
9
  LookupAllOptions,
10
  LookupOneOptions,
11
  LookupOptions,
12
} from 'node:dns';
13
import * as errorCodes from 'node-internal:internal_dns_constants';
14
import {
15
  reverse,
16
  resolveTxt,
17
  resolveCaa,
18
  resolveMx,
19
  resolveCname,
20
  resolveNs,
21
  resolvePtr,
22
  resolveSrv,
23
  resolveSoa,
24
  resolveNaptr,
25
  resolve4,
26
  resolve6,
27
  getServers,
28
  setServers,
29
  getDefaultResultOrder,
30
  setDefaultResultOrder,
31
  lookup as internalLookup,
32
  lookupService,
33
  resolve,
34
  resolveAny,
35
} from 'node-internal:internal_dns';
36
import type {
37
  CAA,
38
  MX,
39
  NAPTR,
40
  SOA,
41
  SRV,
42
  TTLResponse,
43
} from 'node-internal:internal_dns_client';
44
 
45
export * from 'node-internal:internal_dns_constants';
46
export {
47
  reverse,
48
  resolveTxt,
49
  resolveCaa,
50
  resolveMx,
51
  resolveCname,
52
  resolveNs,
53
  resolvePtr,
54
  resolveSrv,
55
  resolveSoa,
56
  resolveNaptr,
57
  resolve4,
58
  resolve6,
59
  getServers,
60
  setServers,
61
  getDefaultResultOrder,
62
  setDefaultResultOrder,
63
  lookupService,
64
  resolve,
65
  resolveAny,
66
} from 'node-internal:internal_dns';
67
 
68
export class Resolver implements dns.Resolver {
69
  cancel(): void {
70
    // TODO(soon): Implement this.
71
    throw new Error('Not implemented');
72
  }
73
 
74
  setLocalAddress(): void {
75
    // Does not apply to workerd implementation
76
    throw new Error('Not implemented');
77
  }
78
 
79
  getServers(): string[] {
80
    return getServers();
81
  }
82
 
83
  // @ts-expect-error TS2769 No matching overload.
84
  resolve(name: string, rrtype: string): ReturnType<typeof resolve> {
85
    return resolve(name, rrtype);
86
  }
87
 
88
  // @ts-expect-error TS2769 No matching overload.
89
  resolve4(
90
    input: string,
91
    options?: { ttl?: boolean }
92
  ): Promise<(string | TTLResponse)[]> {
93
    return resolve4(input, options);
94
  }
95
 
96
  // @ts-expect-error TS2769 No matching overload.
97
  resolve6(
98
    input: string,
99
    options?: { ttl?: boolean }
100
  ): Promise<(string | TTLResponse)[]> {
101
    return resolve6(input, options);
102
  }
103
 
104
  // @ts-expect-error TS2769 No matching overload.
105
  resolveAny(): Promise<void> {
106
    return resolveAny();
107
  }
108
 
109
  resolveCaa(name: string): Promise<CAA[]> {
110
    return resolveCaa(name);
111
  }
112
 
113
  resolveCname(name: string): Promise<string[]> {
114
    return resolveCname(name);
115
  }
116
 
117
  resolveMx(name: string): Promise<MX[]> {
118
    return resolveMx(name);
119
  }
120
 
121
  resolveNaptr(name: string): Promise<NAPTR[]> {
122
    return resolveNaptr(name);
123
  }
124
 
125
  resolveNs(name: string): Promise<string[]> {
126
    return resolveNs(name);
127
  }
128
 
129
  resolvePtr(name: string): Promise<string[]> {
130
    return resolvePtr(name);
131
  }
132
 
133
  resolveSoa(name: string): Promise<SOA> {
134
    return resolveSoa(name);
135
  }
136
 
137
  resolveSrv(name: string): Promise<SRV[]> {
138
    return resolveSrv(name);
139
  }
140
 
141
  resolveTxt(name: string): Promise<string[][]> {
142
    return resolveTxt(name);
143
  }
144
 
145
  reverse(name: string): Promise<string[]> {
146
    return reverse(name);
147
  }
148
 
149
  setServers(): void {
150
    setServers();
151
  }
152
}
153
 
154
export function lookup(
155
  hostname: string,
156
  options?: LookupOptions | LookupOneOptions | LookupAllOptions
157
): Promise<LookupAddress | LookupAddress[]> {
158
  const { promise, resolve, reject } = Promise.withResolvers<
159
    LookupAddress | LookupAddress[]
160
  >();
161
  internalLookup(hostname, options, (error, address, family) => {
162
    if (error) {
163
      reject(error);
164
    } else if (Array.isArray(address)) {
165
      resolve(address);
166
    } else {
167
      resolve({
168
        address,
169
        family,
170
      } as LookupAddress);
171
    }
172
  });
173
  return promise;
174
}
175
 
176
export default {
177
  reverse,
178
  resolveTxt,
179
  resolveCaa,
180
  resolveMx,
181
  resolveCname,
182
  resolveNs,
183
  resolvePtr,
184
  resolveSrv,
185
  resolveSoa,
186
  resolveNaptr,
187
  resolve4,
188
  resolve6,
189
  getServers,
190
  setServers,
191
  getDefaultResultOrder,
192
  setDefaultResultOrder,
193
  lookup,
194
  lookupService,
195
  resolve,
196
  resolveAny,
197
  Resolver,
198
  ...errorCodes,
199
};