@push.rocks/smartdns 5.0.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist_ts/00_commitinfo_data.d.ts +8 -0
- package/dist_ts/00_commitinfo_data.js +9 -0
- package/dist_ts/dnsly.plugins.d.ts +13 -0
- package/dist_ts/dnsly.plugins.js +15 -0
- package/dist_ts/index.d.ts +67 -0
- package/dist_ts/index.js +186 -0
- package/npmextra.json +18 -0
- package/package.json +59 -0
- package/readme.md +51 -0
- package/ts/00_commitinfo_data.ts +8 -0
- package/ts/dnsly.plugins.ts +22 -0
- package/ts/index.ts +229 -0
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* autocreated commitinfo by @pushrocks/commitinfo
|
|
3
|
+
*/
|
|
4
|
+
export const commitinfo = {
|
|
5
|
+
name: '@pushrocks/smartdns',
|
|
6
|
+
version: '5.0.4',
|
|
7
|
+
description: 'smart dns methods written in TypeScript'
|
|
8
|
+
};
|
|
9
|
+
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHlDQUF5QztDQUN2RCxDQUFBIn0=
|
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
/// <reference types="node" resolution-mode="require"/>
|
|
2
|
+
import * as smartenv from '@pushrocks/smartenv';
|
|
3
|
+
import type dnsType from 'dns';
|
|
4
|
+
declare const dns: typeof dnsType;
|
|
5
|
+
export { dns };
|
|
6
|
+
import * as smartdelay from '@pushrocks/smartdelay';
|
|
7
|
+
import * as smartpromise from '@pushrocks/smartpromise';
|
|
8
|
+
import * as smartrequest from '@pushrocks/smartrequest';
|
|
9
|
+
export { smartdelay, smartenv, smartpromise, smartrequest };
|
|
10
|
+
import * as tsclass from '@tsclass/tsclass';
|
|
11
|
+
export { tsclass };
|
|
12
|
+
declare const dns2: Promise<any>;
|
|
13
|
+
export { dns2 };
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
import * as smartenv from '@pushrocks/smartenv';
|
|
2
|
+
const smartenvInstance = new smartenv.Smartenv();
|
|
3
|
+
const dns = await smartenvInstance.getSafeNodeModule('dns');
|
|
4
|
+
export { dns };
|
|
5
|
+
// pushrocks scope
|
|
6
|
+
import * as smartdelay from '@pushrocks/smartdelay';
|
|
7
|
+
import * as smartpromise from '@pushrocks/smartpromise';
|
|
8
|
+
import * as smartrequest from '@pushrocks/smartrequest';
|
|
9
|
+
export { smartdelay, smartenv, smartpromise, smartrequest };
|
|
10
|
+
import * as tsclass from '@tsclass/tsclass';
|
|
11
|
+
export { tsclass };
|
|
12
|
+
// third party scope
|
|
13
|
+
const dns2 = smartenvInstance.getSafeNodeModule('dns2');
|
|
14
|
+
export { dns2 };
|
|
15
|
+
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5zbHkucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2Ruc2x5LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLFFBQVEsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRCxNQUFNLGdCQUFnQixHQUFHLElBQUksUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDO0FBR2pELE1BQU0sR0FBRyxHQUFtQixNQUFNLGdCQUFnQixDQUFDLGlCQUFpQixDQUFDLEtBQUssQ0FBQyxDQUFDO0FBRTVFLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQztBQUVmLGtCQUFrQjtBQUNsQixPQUFPLEtBQUssVUFBVSxNQUFNLHVCQUF1QixDQUFDO0FBQ3BELE9BQU8sS0FBSyxZQUFZLE1BQU0seUJBQXlCLENBQUM7QUFDeEQsT0FBTyxLQUFLLFlBQVksTUFBTSx5QkFBeUIsQ0FBQztBQUV4RCxPQUFPLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxZQUFZLEVBQUUsWUFBWSxFQUFFLENBQUM7QUFFNUQsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFbkIsb0JBQW9CO0FBQ3BCLE1BQU0sSUFBSSxHQUFHLGdCQUFnQixDQUFDLGlCQUFpQixDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQ3hELE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQyJ9
|
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
import * as plugins from './dnsly.plugins.js';
|
|
2
|
+
export type TDnsProvider = 'google' | 'cloudflare';
|
|
3
|
+
export declare const makeNodeProcessUseDnsProvider: (providerArg: TDnsProvider) => void;
|
|
4
|
+
export interface ISmartDnsConstructorOptions {
|
|
5
|
+
}
|
|
6
|
+
export interface IGoogleDNSHTTPSResponse {
|
|
7
|
+
Status: number;
|
|
8
|
+
TC: boolean;
|
|
9
|
+
RD: boolean;
|
|
10
|
+
RA: boolean;
|
|
11
|
+
AD: boolean;
|
|
12
|
+
CD: boolean;
|
|
13
|
+
Question: Array<{
|
|
14
|
+
name: string;
|
|
15
|
+
type: number;
|
|
16
|
+
}>;
|
|
17
|
+
Answer: Array<{
|
|
18
|
+
name: string;
|
|
19
|
+
type: number;
|
|
20
|
+
TTL: number;
|
|
21
|
+
data: string;
|
|
22
|
+
}>;
|
|
23
|
+
Additional: [];
|
|
24
|
+
Comment: string;
|
|
25
|
+
}
|
|
26
|
+
/**
|
|
27
|
+
* class dnsly offers methods for working with dns from a dns provider like Google DNS
|
|
28
|
+
*/
|
|
29
|
+
export declare class Smartdns {
|
|
30
|
+
dnsServerIp: string;
|
|
31
|
+
dnsServerPort: number;
|
|
32
|
+
dnsTypeMap: {
|
|
33
|
+
[key: string]: number;
|
|
34
|
+
};
|
|
35
|
+
/**
|
|
36
|
+
* constructor for class dnsly
|
|
37
|
+
*/
|
|
38
|
+
constructor(optionsArg: ISmartDnsConstructorOptions);
|
|
39
|
+
/**
|
|
40
|
+
* check a dns record until it has propagated to Google DNS
|
|
41
|
+
* should be considerably fast
|
|
42
|
+
* @param recordNameArg
|
|
43
|
+
* @param recordTypeArg
|
|
44
|
+
* @param expectedValue
|
|
45
|
+
*/
|
|
46
|
+
checkUntilAvailable(recordNameArg: string, recordTypeArg: plugins.tsclass.network.TDnsRecordType, expectedValue: string, cyclesArg?: number, intervalArg?: number): Promise<any>;
|
|
47
|
+
/**
|
|
48
|
+
* get A Dns Record
|
|
49
|
+
*/
|
|
50
|
+
getRecordsA(recordNameArg: string): Promise<plugins.tsclass.network.IDnsRecord[]>;
|
|
51
|
+
/**
|
|
52
|
+
* get AAAA Record
|
|
53
|
+
*/
|
|
54
|
+
getRecordsAAAA(recordNameArg: string): Promise<plugins.tsclass.network.IDnsRecord[]>;
|
|
55
|
+
/**
|
|
56
|
+
* gets a txt record
|
|
57
|
+
*/
|
|
58
|
+
getRecordsTxt(recordNameArg: string): Promise<plugins.tsclass.network.IDnsRecord[]>;
|
|
59
|
+
getRecords(recordNameArg: string, recordTypeArg: plugins.tsclass.network.TDnsRecordType, retriesCounterArg?: number): Promise<plugins.tsclass.network.IDnsRecord[]>;
|
|
60
|
+
/**
|
|
61
|
+
* gets a record using nodejs dns resolver
|
|
62
|
+
*/
|
|
63
|
+
getRecordWithNodeDNS(recordNameArg: string, recordTypeArg: plugins.tsclass.network.TDnsRecordType): Promise<plugins.tsclass.network.IDnsRecord[]>;
|
|
64
|
+
getNameServers(domainNameArg: string): Promise<string[]>;
|
|
65
|
+
convertDnsTypeNameToTypeNumber(dnsTypeNameArg: string): number;
|
|
66
|
+
convertDnsTypeNumberToTypeName(dnsTypeNumberArg: number): plugins.tsclass.network.TDnsRecordType;
|
|
67
|
+
}
|
package/dist_ts/index.js
ADDED
|
@@ -0,0 +1,186 @@
|
|
|
1
|
+
import * as plugins from './dnsly.plugins.js';
|
|
2
|
+
export const makeNodeProcessUseDnsProvider = (providerArg) => {
|
|
3
|
+
switch (providerArg) {
|
|
4
|
+
case 'cloudflare':
|
|
5
|
+
plugins.dns.setServers([
|
|
6
|
+
'1.1.1.1',
|
|
7
|
+
'1.0.0.1',
|
|
8
|
+
'[2606:4700:4700::1111]',
|
|
9
|
+
'[2606:4700:4700::1001]',
|
|
10
|
+
]);
|
|
11
|
+
break;
|
|
12
|
+
case 'google':
|
|
13
|
+
plugins.dns.setServers([
|
|
14
|
+
'8.8.8.8',
|
|
15
|
+
'8.8.4.4',
|
|
16
|
+
'[2001:4860:4860::8888]',
|
|
17
|
+
'[2606:4700:4700::1001]',
|
|
18
|
+
]);
|
|
19
|
+
}
|
|
20
|
+
};
|
|
21
|
+
/**
|
|
22
|
+
* class dnsly offers methods for working with dns from a dns provider like Google DNS
|
|
23
|
+
*/
|
|
24
|
+
export class Smartdns {
|
|
25
|
+
/**
|
|
26
|
+
* constructor for class dnsly
|
|
27
|
+
*/
|
|
28
|
+
constructor(optionsArg) {
|
|
29
|
+
this.dnsTypeMap = {
|
|
30
|
+
A: 1,
|
|
31
|
+
AAAA: 28,
|
|
32
|
+
CNAME: 5,
|
|
33
|
+
MX: 15,
|
|
34
|
+
TXT: 16,
|
|
35
|
+
};
|
|
36
|
+
}
|
|
37
|
+
/**
|
|
38
|
+
* check a dns record until it has propagated to Google DNS
|
|
39
|
+
* should be considerably fast
|
|
40
|
+
* @param recordNameArg
|
|
41
|
+
* @param recordTypeArg
|
|
42
|
+
* @param expectedValue
|
|
43
|
+
*/
|
|
44
|
+
async checkUntilAvailable(recordNameArg, recordTypeArg, expectedValue, cyclesArg = 50, intervalArg = 500) {
|
|
45
|
+
let runCycles = 0;
|
|
46
|
+
const doCheck = async () => {
|
|
47
|
+
if (runCycles < cyclesArg) {
|
|
48
|
+
runCycles++;
|
|
49
|
+
try {
|
|
50
|
+
let myRecordArray;
|
|
51
|
+
if (runCycles % 2 === 0 || !plugins.dns) {
|
|
52
|
+
myRecordArray = await this.getRecords(recordNameArg, recordTypeArg, 0);
|
|
53
|
+
}
|
|
54
|
+
else {
|
|
55
|
+
myRecordArray = await this.getRecordWithNodeDNS(recordNameArg, recordTypeArg);
|
|
56
|
+
}
|
|
57
|
+
const myRecord = myRecordArray[0].value;
|
|
58
|
+
if (myRecord === expectedValue) {
|
|
59
|
+
console.log(`smartdns: .checkUntilAvailable() verified that wanted >>>${recordTypeArg}<<< record exists for >>>${recordNameArg}<<< with value >>>${expectedValue}<<<`);
|
|
60
|
+
return true;
|
|
61
|
+
}
|
|
62
|
+
else {
|
|
63
|
+
await plugins.smartdelay.delayFor(intervalArg);
|
|
64
|
+
return await doCheck();
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
catch (err) {
|
|
68
|
+
// console.log(err);
|
|
69
|
+
await plugins.smartdelay.delayFor(intervalArg);
|
|
70
|
+
return await doCheck();
|
|
71
|
+
}
|
|
72
|
+
}
|
|
73
|
+
else {
|
|
74
|
+
console.log(`smartdns: .checkUntilAvailable() failed permanently for ${recordNameArg} with value ${recordTypeArg} - ${expectedValue}...`);
|
|
75
|
+
return false;
|
|
76
|
+
}
|
|
77
|
+
};
|
|
78
|
+
return await doCheck();
|
|
79
|
+
}
|
|
80
|
+
/**
|
|
81
|
+
* get A Dns Record
|
|
82
|
+
*/
|
|
83
|
+
async getRecordsA(recordNameArg) {
|
|
84
|
+
return await this.getRecords(recordNameArg, 'A');
|
|
85
|
+
}
|
|
86
|
+
/**
|
|
87
|
+
* get AAAA Record
|
|
88
|
+
*/
|
|
89
|
+
async getRecordsAAAA(recordNameArg) {
|
|
90
|
+
return await this.getRecords(recordNameArg, 'AAAA');
|
|
91
|
+
}
|
|
92
|
+
/**
|
|
93
|
+
* gets a txt record
|
|
94
|
+
*/
|
|
95
|
+
async getRecordsTxt(recordNameArg) {
|
|
96
|
+
return await this.getRecords(recordNameArg, 'TXT');
|
|
97
|
+
}
|
|
98
|
+
async getRecords(recordNameArg, recordTypeArg, retriesCounterArg = 20) {
|
|
99
|
+
const requestUrl = `https://cloudflare-dns.com/dns-query?name=${recordNameArg}&type=${recordTypeArg}&do=1`;
|
|
100
|
+
const returnArray = [];
|
|
101
|
+
const getResponseBody = async (counterArg = 0) => {
|
|
102
|
+
const response = await plugins.smartrequest.request(requestUrl, {
|
|
103
|
+
method: 'GET',
|
|
104
|
+
headers: {
|
|
105
|
+
accept: 'application/dns-json',
|
|
106
|
+
},
|
|
107
|
+
});
|
|
108
|
+
const responseBody = response.body;
|
|
109
|
+
if (responseBody?.Status !== 0 && counterArg < retriesCounterArg) {
|
|
110
|
+
await plugins.smartdelay.delayFor(500);
|
|
111
|
+
return getResponseBody(counterArg++);
|
|
112
|
+
}
|
|
113
|
+
else {
|
|
114
|
+
return responseBody;
|
|
115
|
+
}
|
|
116
|
+
};
|
|
117
|
+
const responseBody = await getResponseBody();
|
|
118
|
+
if (!responseBody.Answer || !typeof responseBody.Answer[Symbol.iterator]) {
|
|
119
|
+
return returnArray;
|
|
120
|
+
}
|
|
121
|
+
for (const dnsEntry of responseBody.Answer) {
|
|
122
|
+
if (dnsEntry.data.startsWith('"') && dnsEntry.data.endsWith('"')) {
|
|
123
|
+
dnsEntry.data = dnsEntry.data.replace(/^"(.*)"$/, '$1');
|
|
124
|
+
}
|
|
125
|
+
if (dnsEntry.name.endsWith('.')) {
|
|
126
|
+
dnsEntry.name = dnsEntry.name.substring(0, dnsEntry.name.length - 1);
|
|
127
|
+
}
|
|
128
|
+
returnArray.push({
|
|
129
|
+
name: dnsEntry.name,
|
|
130
|
+
type: this.convertDnsTypeNumberToTypeName(dnsEntry.type),
|
|
131
|
+
dnsSecEnabled: responseBody.AD,
|
|
132
|
+
value: dnsEntry.data,
|
|
133
|
+
});
|
|
134
|
+
}
|
|
135
|
+
// console.log(responseBody);
|
|
136
|
+
return returnArray;
|
|
137
|
+
}
|
|
138
|
+
/**
|
|
139
|
+
* gets a record using nodejs dns resolver
|
|
140
|
+
*/
|
|
141
|
+
async getRecordWithNodeDNS(recordNameArg, recordTypeArg) {
|
|
142
|
+
const done = plugins.smartpromise.defer();
|
|
143
|
+
plugins.dns.resolve(recordNameArg, recordTypeArg, (err, recordsArg) => {
|
|
144
|
+
if (err) {
|
|
145
|
+
done.reject(err);
|
|
146
|
+
return;
|
|
147
|
+
}
|
|
148
|
+
const returnArray = [];
|
|
149
|
+
for (const recordKey in recordsArg) {
|
|
150
|
+
returnArray.push({
|
|
151
|
+
name: recordNameArg,
|
|
152
|
+
value: recordsArg[recordKey][0],
|
|
153
|
+
type: recordTypeArg,
|
|
154
|
+
dnsSecEnabled: false,
|
|
155
|
+
});
|
|
156
|
+
}
|
|
157
|
+
done.resolve(returnArray);
|
|
158
|
+
});
|
|
159
|
+
return done.promise;
|
|
160
|
+
}
|
|
161
|
+
async getNameServers(domainNameArg) {
|
|
162
|
+
const done = plugins.smartpromise.defer();
|
|
163
|
+
plugins.dns.resolveNs(domainNameArg, (err, result) => {
|
|
164
|
+
if (!err) {
|
|
165
|
+
done.resolve(result);
|
|
166
|
+
}
|
|
167
|
+
else {
|
|
168
|
+
console.log(err);
|
|
169
|
+
done.reject(err);
|
|
170
|
+
}
|
|
171
|
+
});
|
|
172
|
+
return await done.promise;
|
|
173
|
+
}
|
|
174
|
+
convertDnsTypeNameToTypeNumber(dnsTypeNameArg) {
|
|
175
|
+
return this.dnsTypeMap[dnsTypeNameArg];
|
|
176
|
+
}
|
|
177
|
+
convertDnsTypeNumberToTypeName(dnsTypeNumberArg) {
|
|
178
|
+
for (const key in this.dnsTypeMap) {
|
|
179
|
+
if (this.dnsTypeMap[key] === dnsTypeNumberArg) {
|
|
180
|
+
return key;
|
|
181
|
+
}
|
|
182
|
+
}
|
|
183
|
+
return null;
|
|
184
|
+
}
|
|
185
|
+
}
|
|
186
|
+
//# sourceMappingURL=data:application/json;base64,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
|
package/npmextra.json
ADDED
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
{
|
|
2
|
+
"gitzone": {
|
|
3
|
+
"projectType": "npm",
|
|
4
|
+
"module": {
|
|
5
|
+
"githost": "gitlab.com",
|
|
6
|
+
"gitscope": "pushrocks",
|
|
7
|
+
"gitrepo": "smartdns",
|
|
8
|
+
"description": "smart dns methods written in TypeScript",
|
|
9
|
+
"npmPackagename": "@pushrocks/smartdns",
|
|
10
|
+
"license": "MIT"
|
|
11
|
+
}
|
|
12
|
+
},
|
|
13
|
+
"npmci": {
|
|
14
|
+
"npmGlobalTools": [],
|
|
15
|
+
"npmAccessLevel": "public",
|
|
16
|
+
"npmRegistryUrl": "registry.npmjs.org"
|
|
17
|
+
}
|
|
18
|
+
}
|
package/package.json
ADDED
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
{
|
|
2
|
+
"name": "@push.rocks/smartdns",
|
|
3
|
+
"version": "5.0.4",
|
|
4
|
+
"private": false,
|
|
5
|
+
"description": "smart dns methods written in TypeScript",
|
|
6
|
+
"main": "dist_ts/index.js",
|
|
7
|
+
"typings": "dist_ts/index.d.ts",
|
|
8
|
+
"scripts": {
|
|
9
|
+
"test": "(tstest test/)",
|
|
10
|
+
"build": "(tsbuild --web --allowimplicitany)",
|
|
11
|
+
"buildDocs": "tsdoc"
|
|
12
|
+
},
|
|
13
|
+
"repository": {
|
|
14
|
+
"type": "git",
|
|
15
|
+
"url": "git+ssh://git@gitlab.com/pushrocks/dnsly.git"
|
|
16
|
+
},
|
|
17
|
+
"keywords": [
|
|
18
|
+
"dns",
|
|
19
|
+
"google dns",
|
|
20
|
+
"dns record"
|
|
21
|
+
],
|
|
22
|
+
"author": "Lossless GmbH",
|
|
23
|
+
"license": "MIT",
|
|
24
|
+
"bugs": {
|
|
25
|
+
"url": "https://gitlab.com/pushrocks/dnsly/issues"
|
|
26
|
+
},
|
|
27
|
+
"homepage": "https://gitlab.com/pushrocks/dnsly#README",
|
|
28
|
+
"dependencies": {
|
|
29
|
+
"@pushrocks/smartdelay": "^2.0.13",
|
|
30
|
+
"@pushrocks/smartenv": "^5.0.2",
|
|
31
|
+
"@pushrocks/smartpromise": "^3.1.7",
|
|
32
|
+
"@pushrocks/smartrequest": "^2.0.11",
|
|
33
|
+
"@tsclass/tsclass": "^4.0.17",
|
|
34
|
+
"dns2": "^2.0.5"
|
|
35
|
+
},
|
|
36
|
+
"devDependencies": {
|
|
37
|
+
"@gitzone/tsbuild": "^2.1.63",
|
|
38
|
+
"@gitzone/tsrun": "^1.2.39",
|
|
39
|
+
"@gitzone/tstest": "^1.0.72",
|
|
40
|
+
"@pushrocks/tapbundle": "^5.0.4",
|
|
41
|
+
"@types/node": "^18.15.11"
|
|
42
|
+
},
|
|
43
|
+
"files": [
|
|
44
|
+
"ts/**/*",
|
|
45
|
+
"ts_web/**/*",
|
|
46
|
+
"dist/**/*",
|
|
47
|
+
"dist_*/**/*",
|
|
48
|
+
"dist_ts/**/*",
|
|
49
|
+
"dist_ts_web/**/*",
|
|
50
|
+
"assets/**/*",
|
|
51
|
+
"cli.js",
|
|
52
|
+
"npmextra.json",
|
|
53
|
+
"readme.md"
|
|
54
|
+
],
|
|
55
|
+
"browserslist": [
|
|
56
|
+
"last 1 chrome versions"
|
|
57
|
+
],
|
|
58
|
+
"type": "module"
|
|
59
|
+
}
|
package/readme.md
ADDED
|
@@ -0,0 +1,51 @@
|
|
|
1
|
+
# @pushrocks/smartdns
|
|
2
|
+
smart dns methods written in TypeScript
|
|
3
|
+
|
|
4
|
+
## Availabililty and Links
|
|
5
|
+
* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartdns)
|
|
6
|
+
* [gitlab.com (source)](https://gitlab.com/pushrocks/smartdns)
|
|
7
|
+
* [github.com (source mirror)](https://github.com/pushrocks/smartdns)
|
|
8
|
+
* [docs (typedoc)](https://pushrocks.gitlab.io/smartdns/)
|
|
9
|
+
|
|
10
|
+
## Status for master
|
|
11
|
+
|
|
12
|
+
Status Category | Status Badge
|
|
13
|
+
-- | --
|
|
14
|
+
GitLab Pipelines | [](https://lossless.cloud)
|
|
15
|
+
GitLab Pipline Test Coverage | [](https://lossless.cloud)
|
|
16
|
+
npm | [](https://lossless.cloud)
|
|
17
|
+
Snyk | [](https://lossless.cloud)
|
|
18
|
+
TypeScript Support | [](https://lossless.cloud)
|
|
19
|
+
node Support | [](https://nodejs.org/dist/latest-v10.x/docs/api/)
|
|
20
|
+
Code Style | [](https://lossless.cloud)
|
|
21
|
+
PackagePhobia (total standalone install weight) | [](https://lossless.cloud)
|
|
22
|
+
PackagePhobia (package size on registry) | [](https://lossless.cloud)
|
|
23
|
+
BundlePhobia (total size when bundled) | [](https://lossless.cloud)
|
|
24
|
+
|
|
25
|
+
## Usage
|
|
26
|
+
|
|
27
|
+
Use TypeScript for best in class instellisense.
|
|
28
|
+
|
|
29
|
+
```typescript
|
|
30
|
+
const mySmartDns = new smartdns.SmartDns(); // uses Google DNS Https API
|
|
31
|
+
const demoRecord = await mySmartDns.getRecord('example.com', 'AAAA'); // returns promise
|
|
32
|
+
/*
|
|
33
|
+
demoRecord looks like this:
|
|
34
|
+
{
|
|
35
|
+
name: 'example.com',
|
|
36
|
+
type: 'A',
|
|
37
|
+
dnsSecEnabled: true,
|
|
38
|
+
value: '104.24.103.243'
|
|
39
|
+
}
|
|
40
|
+
*/
|
|
41
|
+
```
|
|
42
|
+
|
|
43
|
+
## Contribution
|
|
44
|
+
|
|
45
|
+
We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
|
|
46
|
+
|
|
47
|
+
For further information read the linked docs at the top of this readme.
|
|
48
|
+
|
|
49
|
+
## Legal
|
|
50
|
+
> MIT licensed | **©** [Task Venture Capital GmbH](https://task.vc)
|
|
51
|
+
| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
import * as smartenv from '@pushrocks/smartenv';
|
|
2
|
+
const smartenvInstance = new smartenv.Smartenv();
|
|
3
|
+
// node native scope
|
|
4
|
+
import type dnsType from 'dns';
|
|
5
|
+
const dns: typeof dnsType = await smartenvInstance.getSafeNodeModule('dns');
|
|
6
|
+
|
|
7
|
+
export { dns };
|
|
8
|
+
|
|
9
|
+
// pushrocks scope
|
|
10
|
+
import * as smartdelay from '@pushrocks/smartdelay';
|
|
11
|
+
import * as smartpromise from '@pushrocks/smartpromise';
|
|
12
|
+
import * as smartrequest from '@pushrocks/smartrequest';
|
|
13
|
+
|
|
14
|
+
export { smartdelay, smartenv, smartpromise, smartrequest };
|
|
15
|
+
|
|
16
|
+
import * as tsclass from '@tsclass/tsclass';
|
|
17
|
+
|
|
18
|
+
export { tsclass };
|
|
19
|
+
|
|
20
|
+
// third party scope
|
|
21
|
+
const dns2 = smartenvInstance.getSafeNodeModule('dns2');
|
|
22
|
+
export { dns2 };
|
package/ts/index.ts
ADDED
|
@@ -0,0 +1,229 @@
|
|
|
1
|
+
import * as plugins from './dnsly.plugins.js';
|
|
2
|
+
|
|
3
|
+
export type TDnsProvider = 'google' | 'cloudflare';
|
|
4
|
+
|
|
5
|
+
export const makeNodeProcessUseDnsProvider = (providerArg: TDnsProvider) => {
|
|
6
|
+
switch (providerArg) {
|
|
7
|
+
case 'cloudflare':
|
|
8
|
+
plugins.dns.setServers([
|
|
9
|
+
'1.1.1.1',
|
|
10
|
+
'1.0.0.1',
|
|
11
|
+
'[2606:4700:4700::1111]',
|
|
12
|
+
'[2606:4700:4700::1001]',
|
|
13
|
+
]);
|
|
14
|
+
break;
|
|
15
|
+
case 'google':
|
|
16
|
+
plugins.dns.setServers([
|
|
17
|
+
'8.8.8.8',
|
|
18
|
+
'8.8.4.4',
|
|
19
|
+
'[2001:4860:4860::8888]',
|
|
20
|
+
'[2606:4700:4700::1001]',
|
|
21
|
+
]);
|
|
22
|
+
}
|
|
23
|
+
};
|
|
24
|
+
|
|
25
|
+
export interface ISmartDnsConstructorOptions {}
|
|
26
|
+
|
|
27
|
+
export interface IGoogleDNSHTTPSResponse {
|
|
28
|
+
Status: number;
|
|
29
|
+
TC: boolean;
|
|
30
|
+
RD: boolean;
|
|
31
|
+
RA: boolean;
|
|
32
|
+
AD: boolean;
|
|
33
|
+
CD: boolean;
|
|
34
|
+
Question: Array<{ name: string; type: number }>;
|
|
35
|
+
Answer: Array<{ name: string; type: number; TTL: number; data: string }>;
|
|
36
|
+
Additional: [];
|
|
37
|
+
Comment: string;
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
/**
|
|
41
|
+
* class dnsly offers methods for working with dns from a dns provider like Google DNS
|
|
42
|
+
*/
|
|
43
|
+
export class Smartdns {
|
|
44
|
+
public dnsServerIp: string;
|
|
45
|
+
public dnsServerPort: number;
|
|
46
|
+
|
|
47
|
+
public dnsTypeMap: { [key: string]: number } = {
|
|
48
|
+
A: 1,
|
|
49
|
+
AAAA: 28,
|
|
50
|
+
CNAME: 5,
|
|
51
|
+
MX: 15,
|
|
52
|
+
TXT: 16,
|
|
53
|
+
};
|
|
54
|
+
|
|
55
|
+
/**
|
|
56
|
+
* constructor for class dnsly
|
|
57
|
+
*/
|
|
58
|
+
constructor(optionsArg: ISmartDnsConstructorOptions) {}
|
|
59
|
+
|
|
60
|
+
/**
|
|
61
|
+
* check a dns record until it has propagated to Google DNS
|
|
62
|
+
* should be considerably fast
|
|
63
|
+
* @param recordNameArg
|
|
64
|
+
* @param recordTypeArg
|
|
65
|
+
* @param expectedValue
|
|
66
|
+
*/
|
|
67
|
+
public async checkUntilAvailable(
|
|
68
|
+
recordNameArg: string,
|
|
69
|
+
recordTypeArg: plugins.tsclass.network.TDnsRecordType,
|
|
70
|
+
expectedValue: string,
|
|
71
|
+
cyclesArg: number = 50,
|
|
72
|
+
intervalArg: number = 500
|
|
73
|
+
) {
|
|
74
|
+
let runCycles = 0;
|
|
75
|
+
const doCheck = async () => {
|
|
76
|
+
if (runCycles < cyclesArg) {
|
|
77
|
+
runCycles++;
|
|
78
|
+
try {
|
|
79
|
+
let myRecordArray: plugins.tsclass.network.IDnsRecord[];
|
|
80
|
+
if (runCycles % 2 === 0 || !plugins.dns) {
|
|
81
|
+
myRecordArray = await this.getRecords(recordNameArg, recordTypeArg, 0);
|
|
82
|
+
} else {
|
|
83
|
+
myRecordArray = await this.getRecordWithNodeDNS(recordNameArg, recordTypeArg);
|
|
84
|
+
}
|
|
85
|
+
const myRecord = myRecordArray[0].value;
|
|
86
|
+
if (myRecord === expectedValue) {
|
|
87
|
+
console.log(
|
|
88
|
+
`smartdns: .checkUntilAvailable() verified that wanted >>>${recordTypeArg}<<< record exists for >>>${recordNameArg}<<< with value >>>${expectedValue}<<<`
|
|
89
|
+
);
|
|
90
|
+
return true;
|
|
91
|
+
} else {
|
|
92
|
+
await plugins.smartdelay.delayFor(intervalArg);
|
|
93
|
+
return await doCheck();
|
|
94
|
+
}
|
|
95
|
+
} catch (err) {
|
|
96
|
+
// console.log(err);
|
|
97
|
+
await plugins.smartdelay.delayFor(intervalArg);
|
|
98
|
+
return await doCheck();
|
|
99
|
+
}
|
|
100
|
+
} else {
|
|
101
|
+
console.log(
|
|
102
|
+
`smartdns: .checkUntilAvailable() failed permanently for ${recordNameArg} with value ${recordTypeArg} - ${expectedValue}...`
|
|
103
|
+
);
|
|
104
|
+
return false;
|
|
105
|
+
}
|
|
106
|
+
};
|
|
107
|
+
return await doCheck();
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
/**
|
|
111
|
+
* get A Dns Record
|
|
112
|
+
*/
|
|
113
|
+
public async getRecordsA(recordNameArg: string): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
|
114
|
+
return await this.getRecords(recordNameArg, 'A');
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
/**
|
|
118
|
+
* get AAAA Record
|
|
119
|
+
*/
|
|
120
|
+
public async getRecordsAAAA(recordNameArg: string) {
|
|
121
|
+
return await this.getRecords(recordNameArg, 'AAAA');
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
/**
|
|
125
|
+
* gets a txt record
|
|
126
|
+
*/
|
|
127
|
+
public async getRecordsTxt(recordNameArg: string): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
|
128
|
+
return await this.getRecords(recordNameArg, 'TXT');
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
public async getRecords(
|
|
132
|
+
recordNameArg: string,
|
|
133
|
+
recordTypeArg: plugins.tsclass.network.TDnsRecordType,
|
|
134
|
+
retriesCounterArg = 20
|
|
135
|
+
): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
|
136
|
+
const requestUrl = `https://cloudflare-dns.com/dns-query?name=${recordNameArg}&type=${recordTypeArg}&do=1`;
|
|
137
|
+
const returnArray: plugins.tsclass.network.IDnsRecord[] = [];
|
|
138
|
+
const getResponseBody = async (counterArg = 0): Promise<IGoogleDNSHTTPSResponse> => {
|
|
139
|
+
const response = await plugins.smartrequest.request(requestUrl, {
|
|
140
|
+
method: 'GET',
|
|
141
|
+
headers: {
|
|
142
|
+
accept: 'application/dns-json',
|
|
143
|
+
},
|
|
144
|
+
});
|
|
145
|
+
const responseBody: IGoogleDNSHTTPSResponse = response.body;
|
|
146
|
+
if (responseBody?.Status !== 0 && counterArg < retriesCounterArg) {
|
|
147
|
+
await plugins.smartdelay.delayFor(500);
|
|
148
|
+
return getResponseBody(counterArg++);
|
|
149
|
+
} else {
|
|
150
|
+
return responseBody;
|
|
151
|
+
}
|
|
152
|
+
};
|
|
153
|
+
const responseBody = await getResponseBody();
|
|
154
|
+
if (!responseBody.Answer || !typeof responseBody.Answer[Symbol.iterator]) {
|
|
155
|
+
return returnArray;
|
|
156
|
+
}
|
|
157
|
+
for (const dnsEntry of responseBody.Answer) {
|
|
158
|
+
if (dnsEntry.data.startsWith('"') && dnsEntry.data.endsWith('"')) {
|
|
159
|
+
dnsEntry.data = dnsEntry.data.replace(/^"(.*)"$/, '$1');
|
|
160
|
+
}
|
|
161
|
+
if (dnsEntry.name.endsWith('.')) {
|
|
162
|
+
dnsEntry.name = dnsEntry.name.substring(0, dnsEntry.name.length - 1);
|
|
163
|
+
}
|
|
164
|
+
returnArray.push({
|
|
165
|
+
name: dnsEntry.name,
|
|
166
|
+
type: this.convertDnsTypeNumberToTypeName(dnsEntry.type),
|
|
167
|
+
dnsSecEnabled: responseBody.AD,
|
|
168
|
+
value: dnsEntry.data,
|
|
169
|
+
});
|
|
170
|
+
}
|
|
171
|
+
// console.log(responseBody);
|
|
172
|
+
return returnArray;
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
/**
|
|
176
|
+
* gets a record using nodejs dns resolver
|
|
177
|
+
*/
|
|
178
|
+
public async getRecordWithNodeDNS(
|
|
179
|
+
recordNameArg: string,
|
|
180
|
+
recordTypeArg: plugins.tsclass.network.TDnsRecordType
|
|
181
|
+
): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
|
182
|
+
const done = plugins.smartpromise.defer<plugins.tsclass.network.IDnsRecord[]>();
|
|
183
|
+
plugins.dns.resolve(recordNameArg, recordTypeArg, (err, recordsArg) => {
|
|
184
|
+
if (err) {
|
|
185
|
+
done.reject(err);
|
|
186
|
+
return;
|
|
187
|
+
}
|
|
188
|
+
const returnArray: plugins.tsclass.network.IDnsRecord[] = [];
|
|
189
|
+
for (const recordKey in recordsArg) {
|
|
190
|
+
returnArray.push({
|
|
191
|
+
name: recordNameArg,
|
|
192
|
+
value: recordsArg[recordKey][0],
|
|
193
|
+
type: recordTypeArg,
|
|
194
|
+
dnsSecEnabled: false,
|
|
195
|
+
});
|
|
196
|
+
}
|
|
197
|
+
done.resolve(returnArray);
|
|
198
|
+
});
|
|
199
|
+
return done.promise;
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
public async getNameServers(domainNameArg: string): Promise<string[]> {
|
|
203
|
+
const done = plugins.smartpromise.defer<string[]>();
|
|
204
|
+
plugins.dns.resolveNs(domainNameArg, (err, result) => {
|
|
205
|
+
if (!err) {
|
|
206
|
+
done.resolve(result);
|
|
207
|
+
} else {
|
|
208
|
+
console.log(err);
|
|
209
|
+
done.reject(err);
|
|
210
|
+
}
|
|
211
|
+
});
|
|
212
|
+
return await done.promise;
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
public convertDnsTypeNameToTypeNumber(dnsTypeNameArg: string): number {
|
|
216
|
+
return this.dnsTypeMap[dnsTypeNameArg];
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
public convertDnsTypeNumberToTypeName(
|
|
220
|
+
dnsTypeNumberArg: number
|
|
221
|
+
): plugins.tsclass.network.TDnsRecordType {
|
|
222
|
+
for (const key in this.dnsTypeMap) {
|
|
223
|
+
if (this.dnsTypeMap[key] === dnsTypeNumberArg) {
|
|
224
|
+
return key as plugins.tsclass.network.TDnsRecordType;
|
|
225
|
+
}
|
|
226
|
+
}
|
|
227
|
+
return null;
|
|
228
|
+
}
|
|
229
|
+
}
|