@push.rocks/smartdns 6.2.1 → 7.0.2

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/smartdns',
+    version: '7.0.2',
+    description: 'A robust TypeScript library providing advanced DNS management and resolution capabilities including support for DNSSEC, custom DNS servers, and integration with various DNS providers.'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxzQkFBc0I7SUFDNUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHlMQUF5TDtDQUN2TSxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1,3 @@
+import * as dnsClientMod from '../dist_ts_client/index.js';
+import * as dnsServerMod from '../dist_ts_server/index.js';
+export { dnsClientMod, dnsServerMod };

package/dist_ts/index.js

@@ -0,0 +1,4 @@
+import * as dnsClientMod from '../dist_ts_client/index.js';
+import * as dnsServerMod from '../dist_ts_server/index.js';
+export { dnsClientMod, dnsServerMod };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssWUFBWSxNQUFNLDRCQUE0QixDQUFDO0FBQzNELE9BQU8sS0FBSyxZQUFZLE1BQU0sNEJBQTRCLENBQUM7QUFFM0QsT0FBTyxFQUFFLFlBQVksRUFBRSxZQUFZLEVBQUUsQ0FBQyJ9

package/dist_ts_client/classes.dnsclient.d.ts

@@ -1,4 +1,4 @@
-import * as plugins from './dnsly.plugins.js';
+import * as plugins from './plugins.js';
 export type TDnsProvider = 'google' | 'cloudflare';
 export declare const makeNodeProcessUseDnsProvider: (providerArg: TDnsProvider) => void;
 export interface ISmartDnsConstructorOptions {

package/dist_ts_client/classes.dnsclient.js

@@ -1,4 +1,4 @@
-import * as plugins from './dnsly.plugins.js';
+import * as plugins from './plugins.js';
 export const makeNodeProcessUseDnsProvider = (providerArg) => {
     switch (providerArg) {
         case 'cloudflare':
@@ -108,7 +108,7 @@ export class Smartdns {
             const responseBody = response.body;
             if (responseBody?.Status !== 0 && counterArg < retriesCounterArg) {
                 await plugins.smartdelay.delayFor(500);
-                return getResponseBody(counterArg++);
+                return getResponseBody(counterArg + 1);
             }
             else {
                 return responseBody;
@@ -183,4 +183,4 @@ export class Smartdns {
         return null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_client/plugins.d.ts

@@ -0,0 +1,10 @@
+import * as smartenv from '@push.rocks/smartenv';
+import type dnsType from 'dns';
+declare const dns: typeof dnsType;
+export { dns };
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrequest from '@push.rocks/smartrequest';
+export { smartdelay, smartenv, smartpromise, smartrequest };
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass };

package/dist_ts_client/plugins.js

@@ -0,0 +1,12 @@
+import * as smartenv from '@push.rocks/smartenv';
+const smartenvInstance = new smartenv.Smartenv();
+const dns = await smartenvInstance.getSafeNodeModule('dns');
+export { dns };
+// pushrocks scope
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrequest from '@push.rocks/smartrequest';
+export { smartdelay, smartenv, smartpromise, smartrequest };
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2NsaWVudC9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztBQUdqRCxNQUFNLEdBQUcsR0FBbUIsTUFBTSxnQkFBZ0IsQ0FBQyxpQkFBaUIsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUU1RSxPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUM7QUFFZixrQkFBa0I7QUFDbEIsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFFekQsT0FBTyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxDQUFDO0FBRTVELE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDIn0=

package/dist_ts_server/classes.dnssec.js

@@ -60,10 +60,26 @@ export class DnsSec {
         }
     }
     signData(data) {
-        // Sign the data using the private key
-        const keyPair = this.ec.keyFromPrivate(this.keyPair.privateKey, 'hex');
-        const signature = keyPair.sign(plugins.crypto.createHash('sha256').update(data).digest());
-        return Buffer.from(signature.toDER());
+        switch (this.zone.algorithm) {
+            case 'ECDSA':
+                if (!this.ec)
+                    throw new Error('EC instance is not initialized.');
+                const ecKeyPair = this.ec.keyFromPrivate(this.keyPair.privateKey, 'hex');
+                const ecSignature = ecKeyPair.sign(plugins.crypto.createHash('sha256').update(data).digest());
+                return Buffer.from(ecSignature.toDER());
+            case 'ED25519':
+                if (!this.eddsa)
+                    throw new Error('EdDSA instance is not initialized.');
+                const edKeyPair = this.eddsa.keyFromSecret(Buffer.from(this.keyPair.privateKey, 'hex'));
+                // ED25519 doesn't need a separate hash function as it includes the hashing internally
+                const edSignature = edKeyPair.sign(data);
+                // Convert the signature to the correct format for Buffer.from
+                return Buffer.from(edSignature.toBytes());
+            case 'RSA':
+                throw new Error('RSA signing is not yet implemented.');
+            default:
+                throw new Error(`Unsupported algorithm: ${this.zone.algorithm}`);
+        }
     }
     generateDNSKEY() {
         const flags = 256; // 256 indicates a Zone Signing Key (ZSK)
@@ -136,4 +152,4 @@ export class DnsSec {
         return { keyPair: this.keyPair, dsRecord, dnskeyRecord };
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5kbnNzZWMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19zZXJ2ZXIvY2xhc3Nlcy5kbnNzZWMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsMkNBQTJDO0FBQzNDLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBY3hDLE1BQU0sT0FBTyxNQUFNO0lBTWpCLFlBQVksSUFBZ0I7UUFDMUIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFFakIsMkVBQTJFO1FBQzNFLFFBQVEsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztZQUM1QixLQUFLLE9BQU87Z0JBQ1YsSUFBSSxDQUFDLEVBQUUsR0FBRyxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsNEJBQTRCO2dCQUN2RSxNQUFNO1lBQ1IsS0FBSyxTQUFTO2dCQUNaLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQztnQkFDbkQsTUFBTTtZQUNSLEtBQUssS0FBSztnQkFDUixtQ0FBbUM7Z0JBQ25DLE1BQU0sSUFBSSxLQUFLLENBQUMsdUNBQXVDLENBQUMsQ0FBQztZQUMzRDtnQkFDRSxNQUFNLElBQUksS0FBSyxDQUFDLDBCQUEwQixJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUM7UUFDckUsQ0FBQztRQUVELHdCQUF3QjtRQUN4QixJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQztJQUN4QyxDQUFDO0lBRU8sZUFBZTtRQUNyQixJQUFJLFVBQWtCLENBQUM7UUFDdkIsSUFBSSxTQUFpQixDQUFDO1FBRXRCLFFBQVEsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztZQUM1QixLQUFLLE9BQU87Z0JBQ1YsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFO29CQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsaUNBQWlDLENBQUMsQ0FBQztnQkFDakUsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFDdkMsVUFBVSxHQUFHLFNBQVMsQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBQ3pDLFNBQVMsR0FBRyxTQUFTLENBQUMsU0FBUyxDQUFDLEtBQUssRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLHNCQUFzQjtnQkFDckUsTUFBTTtZQUNSLEtBQUssU0FBUztnQkFDWixJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUs7b0JBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxvQ0FBb0MsQ0FBQyxDQUFDO2dCQUN2RSxNQUFNLE1BQU0sR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxFQUFFLENBQUMsQ0FBQztnQkFDOUMsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLENBQUM7Z0JBQ25ELFVBQVUsR0FBRyxTQUFTLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO2dCQUN4QyxTQUFTLEdBQUcsU0FBUyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztnQkFDdkMsTUFBTTtZQUNSLEtBQUssS0FBSztnQkFDUiwrQ0FBK0M7Z0JBQy9DLE1BQU0sSUFBSSxLQUFLLENBQUMsNENBQTRDLENBQUMsQ0FBQztZQUNoRTtnQkFDRSxNQUFNLElBQUksS0FBSyxDQUFDLDBCQUEwQixJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUM7UUFDckUsQ0FBQztRQUVELE9BQU8sRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLENBQUM7SUFDbkMsQ0FBQztJQUVNLGtCQUFrQjtRQUN2QixRQUFRLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7WUFDNUIsS0FBSyxPQUFPO2dCQUNWLE9BQU8sRUFBRSxDQUFDLENBQUMsa0JBQWtCO1lBQy9CLEtBQUssU0FBUztnQkFDWixPQUFPLEVBQUUsQ0FBQztZQUNaLEtBQUssS0FBSztnQkFDUixPQUFPLENBQUMsQ0FBQyxDQUFDLFlBQVk7WUFDeEI7Z0JBQ0UsTUFBTSxJQUFJLEtBQUssQ0FBQywwQkFBMEIsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQyxDQUFDO1FBQ3JFLENBQUM7SUFDSCxDQUFDO0lBRU0sUUFBUSxDQUFDLElBQVk7UUFDMUIsc0NBQXNDO1FBQ3RDLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxFQUFHLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsVUFBVSxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQ3hFLE1BQU0sU0FBUyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7UUFDMUYsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQ3hDLENBQUM7SUFFTyxjQUFjO1FBQ3BCLE1BQU0sS0FBSyxHQUFHLEdBQUcsQ0FBQyxDQUFDLHlDQUF5QztRQUM1RCxNQUFNLFFBQVEsR0FBRyxDQUFDLENBQUMsQ0FBQyw2QkFBNkI7UUFDakQsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLGtCQUFrQixFQUFFLENBQUM7UUFFNUMsSUFBSSxhQUFxQixDQUFDO1FBRTFCLFFBQVEsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztZQUM1QixLQUFLLE9BQU87Z0JBQ1YsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFO29CQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsaUNBQWlDLENBQUMsQ0FBQztnQkFDakUsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTLEVBQUUsS0FBSyxDQUFDLENBQUMsU0FBUyxFQUFFLENBQUM7Z0JBQ3JGLE1BQU0sQ0FBQyxHQUFHLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxXQUFXLENBQUMsTUFBTSxFQUFFLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQztnQkFDM0QsTUFBTSxDQUFDLEdBQUcsV0FBVyxDQUFDLElBQUksRUFBRSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDO2dCQUMzRCxhQUFhLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUN0QyxNQUFNO1lBQ1IsS0FBSyxTQUFTO2dCQUNaLGFBQWEsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxFQUFFLEtBQUssQ0FBQyxDQUFDO2dCQUMzRCxNQUFNO1lBQ1IsS0FBSyxLQUFLO2dCQUNSLDBDQUEwQztnQkFDMUMsTUFBTSxJQUFJLEtBQUssQ0FBQyxtREFBbUQsQ0FBQyxDQUFDO1lBQ3ZFO2dCQUNFLE1BQU0sSUFBSSxLQUFLLENBQUMsMEJBQTBCLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUMsQ0FBQztRQUNyRSxDQUFDO1FBRUQsNkJBQTZCO1FBQzdCLE1BQU0sV0FBVyxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUM7WUFDaEMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLEtBQUssSUFBSSxDQUFDLEVBQUUsS0FBSyxHQUFHLElBQUksQ0FBQyxDQUFDLEVBQUUsa0JBQWtCO1lBQzNELE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxFQUFFLG9CQUFvQjtZQUM3QyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxxQkFBcUI7WUFDL0MsYUFBYSxFQUFFLGFBQWE7U0FDN0IsQ0FBQyxDQUFDO1FBRUgsT0FBTyxXQUFXLENBQUM7SUFDckIsQ0FBQztJQUVPLGFBQWEsQ0FBQyxXQUFtQjtRQUN2QyxrREFBa0Q7UUFDbEQsSUFBSSxHQUFHLEdBQUcsQ0FBQyxDQUFDO1FBQ1osS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLFdBQVcsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQztZQUM1QyxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3RELENBQUM7UUFDRCxHQUFHLElBQUksQ0FBQyxHQUFHLElBQUksRUFBRSxDQUFDLEdBQUcsTUFBTSxDQUFDO1FBQzVCLE9BQU8sR0FBRyxHQUFHLE1BQU0sQ0FBQztJQUN0QixDQUFDO0lBRU8sZUFBZTtRQUNyQixNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsY0FBYyxFQUFFLENBQUM7UUFDMUMsTUFBTSxLQUFLLEdBQUcsR0FBRyxDQUFDO1FBQ2xCLE1BQU0sUUFBUSxHQUFHLENBQUMsQ0FBQztRQUNuQixNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztRQUM1QyxNQUFNLGFBQWEsR0FBRyxXQUFXLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsd0NBQXdDO1FBQ3BGLE1BQU0sZUFBZSxHQUFHLGFBQWEsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUM7UUFFekQsT0FBTyxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxlQUFlLEtBQUssSUFBSSxRQUFRLElBQUksU0FBUyxJQUFJLGVBQWUsRUFBRSxDQUFDO0lBQzdGLENBQUM7SUFFTSxXQUFXO1FBQ2hCLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxjQUFjLEVBQUUsQ0FBQztRQUMxQyxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQy9DLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1FBQzVDLE1BQU0sVUFBVSxHQUFHLENBQUMsQ0FBQyxDQUFDLFVBQVU7UUFDaEMsTUFBTSxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU07YUFDMUIsVUFBVSxDQUFDLFFBQVEsQ0FBQzthQUNwQixNQUFNLENBQUMsV0FBVyxDQUFDO2FBQ25CLE1BQU0sQ0FBQyxLQUFLLENBQUM7YUFDYixXQUFXLEVBQUUsQ0FBQztRQUVqQixPQUFPLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLFdBQVcsTUFBTSxJQUFJLFNBQVMsSUFBSSxVQUFVLElBQUksTUFBTSxFQUFFLENBQUM7SUFDbkYsQ0FBQztJQUVNLFVBQVU7UUFDZixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDdEIsQ0FBQztJQUVNLGVBQWU7UUFDcEIsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ3BDLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQztRQUM1QyxPQUFPLEVBQUUsT0FBTyxFQUFFLElBQUksQ0FBQyxPQUFPLEVBQUUsUUFBUSxFQUFFLFlBQVksRUFBRSxDQUFDO0lBQzNELENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_server/classes.dnsserver.d.ts

@@ -1,18 +1,28 @@
 import * as dnsPacket from 'dns-packet';
-interface IDnsServerOptions {
+export interface IDnsServerOptions {
     httpsKey: string;
     httpsCert: string;
     httpsPort: number;
     udpPort: number;
     dnssecZone: string;
 }
-interface DnsAnswer {
+export interface DnsAnswer {
     name: string;
     type: string;
     class: string | number;
     ttl: number;
     data: any;
 }
+export interface IDnsHandler {
+    domainPattern: string;
+    recordTypes: string[];
+    handler: (question: dnsPacket.Question) => DnsAnswer | null;
+}
+interface LetsEncryptOptions {
+    email?: string;
+    staging?: boolean;
+    certDir?: string;
+}
 export declare class DnsServer {
     private options;
     private udpServer;
@@ -23,7 +33,35 @@ export declare class DnsServer {
     private keyTag;
     constructor(options: IDnsServerOptions);
     registerHandler(domainPattern: string, recordTypes: string[], handler: (question: dnsPacket.Question) => DnsAnswer | null): void;
-    private processDnsRequest;
+    unregisterHandler(domainPattern: string, recordTypes: string[]): boolean;
+    /**
+     * Retrieve SSL certificate for specified domains using Let's Encrypt
+     * @param domainNames Array of domain names to include in the certificate
+     * @param options Configuration options for Let's Encrypt
+     * @returns Object containing certificate, private key, and success status
+     */
+    retrieveSslCertificate(domainNames: string[], options?: LetsEncryptOptions): Promise<{
+        cert: string;
+        key: string;
+        success: boolean;
+    }>;
+    /**
+     * Create DNS record value for the ACME challenge
+     */
+    private getDnsRecordValueForChallenge;
+    /**
+     * Restart the HTTPS server with the new certificate
+     */
+    private restartHttpsServer;
+    /**
+     * Filter domains to include only those the server is authoritative for
+     */
+    filterAuthorizedDomains(domainNames: string[]): string[];
+    /**
+     * Check if the server is authoritative for a domain
+     */
+    private isAuthorizedForDomain;
+    processDnsRequest(request: dnsPacket.Packet): dnsPacket.Packet;
     private isDnssecRequested;
     private generateRRSIG;
     private serializeRRset;

package/dist_ts_server/classes.dnsserver.js

@@ -21,6 +21,259 @@ export class DnsServer {
     registerHandler(domainPattern, recordTypes, handler) {
         this.handlers.push({ domainPattern, recordTypes, handler });
     }
+    // Unregister a specific handler
+    unregisterHandler(domainPattern, recordTypes) {
+        const initialLength = this.handlers.length;
+        this.handlers = this.handlers.filter(handler => !(handler.domainPattern === domainPattern &&
+            recordTypes.every(type => handler.recordTypes.includes(type))));
+        return this.handlers.length < initialLength;
+    }
+    /**
+     * Retrieve SSL certificate for specified domains using Let's Encrypt
+     * @param domainNames Array of domain names to include in the certificate
+     * @param options Configuration options for Let's Encrypt
+     * @returns Object containing certificate, private key, and success status
+     */
+    async retrieveSslCertificate(domainNames, options = {}) {
+        // Default options
+        const opts = {
+            email: options.email || 'admin@example.com',
+            staging: options.staging !== undefined ? options.staging : false,
+            certDir: options.certDir || './certs'
+        };
+        // Create certificate directory if it doesn't exist
+        if (!plugins.fs.existsSync(opts.certDir)) {
+            plugins.fs.mkdirSync(opts.certDir, { recursive: true });
+        }
+        // Filter domains this server is authoritative for
+        const authorizedDomains = this.filterAuthorizedDomains(domainNames);
+        if (authorizedDomains.length === 0) {
+            console.error('None of the provided domains are authorized for this DNS server');
+            return { cert: '', key: '', success: false };
+        }
+        console.log(`Retrieving SSL certificate for domains: ${authorizedDomains.join(', ')}`);
+        try {
+            // Allow for override in tests
+            // @ts-ignore - acmeClientOverride is added for testing purposes
+            const acmeClient = this.acmeClientOverride || await import('acme-client');
+            // Generate or load account key
+            const accountKeyPath = plugins.path.join(opts.certDir, 'account.key');
+            let accountKey;
+            if (plugins.fs.existsSync(accountKeyPath)) {
+                accountKey = plugins.fs.readFileSync(accountKeyPath);
+            }
+            else {
+                // Generate new account key
+                const { privateKey } = plugins.crypto.generateKeyPairSync('rsa', {
+                    modulusLength: 2048,
+                    publicKeyEncoding: { type: 'spki', format: 'pem' },
+                    privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+                });
+                accountKey = Buffer.from(privateKey);
+                plugins.fs.writeFileSync(accountKeyPath, accountKey);
+            }
+            // Initialize ACME client
+            const client = new acmeClient.Client({
+                directoryUrl: opts.staging
+                    ? acmeClient.directory.letsencrypt.staging
+                    : acmeClient.directory.letsencrypt.production,
+                accountKey: accountKey
+            });
+            // Create or update account
+            await client.createAccount({
+                termsOfServiceAgreed: true,
+                contact: [`mailto:${opts.email}`]
+            });
+            // Create order for certificate
+            const order = await client.createOrder({
+                identifiers: authorizedDomains.map(domain => ({
+                    type: 'dns',
+                    value: domain
+                }))
+            });
+            // Get authorizations
+            const authorizations = await client.getAuthorizations(order);
+            // Track handlers to clean up later
+            const challengeHandlers = [];
+            // Process each authorization
+            for (const auth of authorizations) {
+                const domain = auth.identifier.value;
+                // Get DNS challenge
+                const challenge = auth.challenges.find(c => c.type === 'dns-01');
+                if (!challenge) {
+                    throw new Error(`No DNS-01 challenge found for ${domain}`);
+                }
+                // Get key authorization and DNS record value
+                const keyAuthorization = await client.getChallengeKeyAuthorization(challenge);
+                const recordValue = this.getDnsRecordValueForChallenge(keyAuthorization);
+                // Create challenge domain (where TXT record should be placed)
+                const challengeDomain = `_acme-challenge.${domain}`;
+                console.log(`Setting up TXT record for ${challengeDomain}: ${recordValue}`);
+                // Register handler for the TXT record
+                this.registerHandler(challengeDomain, ['TXT'], (question) => {
+                    if (question.name === challengeDomain && question.type === 'TXT') {
+                        return {
+                            name: question.name,
+                            type: 'TXT',
+                            class: 'IN',
+                            ttl: 300,
+                            data: [recordValue]
+                        };
+                    }
+                    return null;
+                });
+                // Track the handler for cleanup
+                challengeHandlers.push({ domain, pattern: challengeDomain });
+                // Wait briefly for DNS propagation
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                // Complete the challenge
+                await client.completeChallenge(challenge);
+                // Wait for verification
+                await client.waitForValidStatus(challenge);
+                console.log(`Challenge for ${domain} validated successfully!`);
+            }
+            // Generate certificate key
+            const domainKeyPath = plugins.path.join(opts.certDir, `${authorizedDomains[0]}.key`);
+            const { privateKey } = plugins.crypto.generateKeyPairSync('rsa', {
+                modulusLength: 2048,
+                publicKeyEncoding: { type: 'spki', format: 'pem' },
+                privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+            });
+            plugins.fs.writeFileSync(domainKeyPath, privateKey);
+            // Use the forge.createCsr method and handle typing with a more direct approach
+            const csrResult = await acmeClient.forge.createCsr({
+                commonName: authorizedDomains[0],
+                altNames: authorizedDomains
+            });
+            // Finalize the order with the CSR
+            await client.finalizeOrder(order, csrResult.csr);
+            // Get certificate
+            const certificate = await client.getCertificate(order);
+            // Save certificate
+            const certPath = plugins.path.join(opts.certDir, `${authorizedDomains[0]}.cert`);
+            plugins.fs.writeFileSync(certPath, certificate);
+            // Update HTTPS server with new certificate
+            this.options.httpsCert = certificate;
+            this.options.httpsKey = privateKey;
+            // Restart HTTPS server with new certificate
+            await this.restartHttpsServer();
+            // Clean up challenge handlers
+            for (const handler of challengeHandlers) {
+                this.unregisterHandler(handler.pattern, ['TXT']);
+                console.log(`Cleaned up challenge handler for ${handler.domain}`);
+            }
+            return {
+                cert: certificate,
+                key: privateKey,
+                success: true
+            };
+        }
+        catch (error) {
+            console.error('Error retrieving SSL certificate:', error);
+            return { cert: '', key: '', success: false };
+        }
+    }
+    /**
+     * Create DNS record value for the ACME challenge
+     */
+    getDnsRecordValueForChallenge(keyAuthorization) {
+        // Create SHA-256 digest of the key authorization
+        const digest = plugins.crypto
+            .createHash('sha256')
+            .update(keyAuthorization)
+            .digest('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=/g, '');
+        return digest;
+    }
+    /**
+     * Restart the HTTPS server with the new certificate
+     */
+    async restartHttpsServer() {
+        return new Promise((resolve, reject) => {
+            // First check if the server exists
+            if (!this.httpsServer) {
+                console.log('No HTTPS server to restart');
+                resolve();
+                return;
+            }
+            this.httpsServer.close(() => {
+                try {
+                    // Validate certificate and key before trying to create the server
+                    if (!this.options.httpsCert || !this.options.httpsKey) {
+                        throw new Error('Missing certificate or key for HTTPS server');
+                    }
+                    // For testing, check if we have a mock certificate
+                    if (this.options.httpsCert.includes('MOCK_CERTIFICATE')) {
+                        console.log('Using mock certificate in test mode');
+                        // In test mode with mock cert, we can use the original cert
+                        // @ts-ignore - accessing acmeClientOverride for testing
+                        if (this.acmeClientOverride) {
+                            this.httpsServer = plugins.https.createServer({
+                                key: this.options.httpsKey,
+                                cert: this.options.httpsCert,
+                            }, this.handleHttpsRequest.bind(this));
+                            this.httpsServer.listen(this.options.httpsPort, () => {
+                                console.log(`HTTPS DNS server restarted on port ${this.options.httpsPort} with test certificate`);
+                                resolve();
+                            });
+                            return;
+                        }
+                    }
+                    // Create the new server with the updated certificate
+                    this.httpsServer = plugins.https.createServer({
+                        key: this.options.httpsKey,
+                        cert: this.options.httpsCert,
+                    }, this.handleHttpsRequest.bind(this));
+                    this.httpsServer.listen(this.options.httpsPort, () => {
+                        console.log(`HTTPS DNS server restarted on port ${this.options.httpsPort} with new certificate`);
+                        resolve();
+                    });
+                }
+                catch (err) {
+                    console.error('Error creating HTTPS server with new certificate:', err);
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * Filter domains to include only those the server is authoritative for
+     */
+    filterAuthorizedDomains(domainNames) {
+        const authorizedDomains = [];
+        for (const domain of domainNames) {
+            // Handle wildcards (*.example.com)
+            if (domain.startsWith('*.')) {
+                const baseDomain = domain.substring(2);
+                if (this.isAuthorizedForDomain(baseDomain)) {
+                    authorizedDomains.push(domain);
+                }
+            }
+            // Regular domains
+            else if (this.isAuthorizedForDomain(domain)) {
+                authorizedDomains.push(domain);
+            }
+        }
+        return authorizedDomains;
+    }
+    /**
+     * Check if the server is authoritative for a domain
+     */
+    isAuthorizedForDomain(domain) {
+        // Check if any handler matches this domain
+        for (const handler of this.handlers) {
+            if (plugins.minimatch.minimatch(domain, handler.domainPattern)) {
+                return true;
+            }
+        }
+        // Also check if the domain is the DNSSEC zone itself
+        if (domain === this.options.dnssecZone || domain.endsWith(`.${this.options.dnssecZone}`)) {
+            return true;
+        }
+        return false;
+    }
     processDnsRequest(request) {
         const response = {
             type: 'response',
@@ -179,6 +432,19 @@ export class DnsServer {
                     const num = parseInt(segment, 16);
                     return [num >> 8, num & 0xff];
                 }));
+            case 'TXT':
+                // Handle TXT records for ACME challenges
+                if (Array.isArray(data)) {
+                    // Combine all strings and encode as lengths and values
+                    const buffers = data.map(str => {
+                        const strBuf = Buffer.from(str);
+                        const lenBuf = Buffer.alloc(1);
+                        lenBuf.writeUInt8(strBuf.length, 0);
+                        return Buffer.concat([lenBuf, strBuf]);
+                    });
+                    return Buffer.concat(buffers);
+                }
+                return Buffer.alloc(0);
             case 'DNSKEY':
                 const dnskeyData = data;
                 return Buffer.concat([
@@ -283,18 +549,32 @@ export class DnsServer {
     async stop() {
         const doneUdp = plugins.smartpromise.defer();
         const doneHttps = plugins.smartpromise.defer();
-        this.udpServer.close(() => {
-            console.log('UDP DNS server stopped');
-            this.udpServer.unref();
-            this.udpServer = null;
+        if (this.udpServer) {
+            this.udpServer.close(() => {
+                console.log('UDP DNS server stopped');
+                if (this.udpServer) {
+                    this.udpServer.unref();
+                    this.udpServer = null;
+                }
+                doneUdp.resolve();
+            });
+        }
+        else {
             doneUdp.resolve();
-        });
-        this.httpsServer.close(() => {
-            console.log('HTTPS DNS server stopped');
-            this.httpsServer.unref();
-            this.httpsServer = null;
+        }
+        if (this.httpsServer) {
+            this.httpsServer.close(() => {
+                console.log('HTTPS DNS server stopped');
+                if (this.httpsServer) {
+                    this.httpsServer.unref();
+                    this.httpsServer = null;
+                }
+                doneHttps.resolve();
+            });
+        }
+        else {
             doneHttps.resolve();
-        });
+        }
         await Promise.all([doneUdp.promise, doneHttps.promise]);
     }
     // Helper methods
@@ -339,4 +619,4 @@ export class DnsServer {
         return Buffer.concat([...buffers, Buffer.from([0])]); // Add root label
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dnsserver.js","sourceRoot":"","sources":["../ts_server/classes.dnsserver.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dnsserver.js","sourceRoot":"","sources":["../ts_server/classes.dnsserver.ts"],"names":[],"mappings":"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"}

package/dist_ts_server/plugins.d.ts

@@ -1,9 +1,10 @@
 import crypto from 'crypto';
+import dgram from 'dgram';
 import fs from 'fs';
 import http from 'http';
 import https from 'https';
-import dgram from 'dgram';
-export { crypto, fs, http, https, dgram, };
+import * as path from 'path';
+export { crypto, fs, http, https, dgram, path, };
 import * as smartpromise from '@push.rocks/smartpromise';
 export { smartpromise, };
 import elliptic from 'elliptic';

package/dist_ts_server/plugins.js

@@ -1,10 +1,11 @@
 // node native
 import crypto from 'crypto';
+import dgram from 'dgram';
 import fs from 'fs';
 import http from 'http';
 import https from 'https';
-import dgram from 'dgram';
-export { crypto, fs, http, https, dgram, };
+import * as path from 'path';
+export { crypto, fs, http, https, dgram, path, };
 // @push.rocks scope
 import * as smartpromise from '@push.rocks/smartpromise';
 export { smartpromise, };
@@ -13,4 +14,4 @@ import elliptic from 'elliptic';
 import * as dnsPacket from 'dns-packet';
 import * as minimatch from 'minimatch';
 export { dnsPacket, elliptic, minimatch, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3NlcnZlci9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWM7QUFDZCxPQUFPLE1BQU0sTUFBTSxRQUFRLENBQUM7QUFDNUIsT0FBTyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3BCLE9BQU8sSUFBSSxNQUFNLE1BQU0sQ0FBQztBQUN4QixPQUFPLEtBQUssTUFBTSxPQUFPLENBQUM7QUFDMUIsT0FBTyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBRTFCLE9BQU8sRUFDTCxNQUFNLEVBQ04sRUFBRSxFQUNGLElBQUksRUFDSixLQUFLLEVBQ0wsS0FBSyxHQUNOLENBQUE7QUFFRCxvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUV6RCxPQUFPLEVBQ0wsWUFBWSxHQUNiLENBQUE7QUFFRCxjQUFjO0FBQ2QsT0FBTyxRQUFRLE1BQU0sVUFBVSxDQUFDO0FBQ2hDLE9BQU8sS0FBSyxTQUFTLE1BQU0sWUFBWSxDQUFDO0FBQ3hDLE9BQU8sS0FBSyxTQUFTLE1BQU0sV0FBVyxDQUFDO0FBRXZDLE9BQU8sRUFDTCxTQUFTLEVBQ1QsUUFBUSxFQUNSLFNBQVMsR0FDVixDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3NlcnZlci9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWM7QUFDZCxPQUFPLE1BQU0sTUFBTSxRQUFRLENBQUM7QUFDNUIsT0FBTyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBQzFCLE9BQU8sRUFBRSxNQUFNLElBQUksQ0FBQztBQUNwQixPQUFPLElBQUksTUFBTSxNQUFNLENBQUM7QUFDeEIsT0FBTyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBQzFCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFDTCxNQUFNLEVBQ04sRUFBRSxFQUNGLElBQUksRUFDSixLQUFLLEVBQ0wsS0FBSyxFQUNMLElBQUksR0FDTCxDQUFBO0FBRUQsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFFekQsT0FBTyxFQUNMLFlBQVksR0FDYixDQUFBO0FBRUQsY0FBYztBQUNkLE9BQU8sUUFBUSxNQUFNLFVBQVUsQ0FBQztBQUNoQyxPQUFPLEtBQUssU0FBUyxNQUFNLFlBQVksQ0FBQztBQUN4QyxPQUFPLEtBQUssU0FBUyxNQUFNLFdBQVcsQ0FBQztBQUV2QyxPQUFPLEVBQ0wsU0FBUyxFQUNULFFBQVEsRUFDUixTQUFTLEdBQ1YsQ0FBQSJ9

package/npmextra.json

@@ -5,7 +5,7 @@
       "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "smartdns",
-      "description": "A TypeScript library for smart DNS methods, supporting various DNS records and providers.",
+      "description": "A robust TypeScript library providing advanced DNS management and resolution capabilities including support for DNSSEC, custom DNS servers, and integration with various DNS providers.",
       "npmPackagename": "@push.rocks/smartdns",
       "license": "MIT",
       "keywords": [
@@ -19,7 +19,13 @@
         "Google DNS",
         "Cloudflare",
         "UDP DNS",
-        "HTTPS DNS"
+        "HTTPS DNS",
+        "ACME",
+        "Let's Encrypt",
+        "SSL Certificates",
+        "Feature Flagging",
+        "Domain Propagation",
+        "DNS Server"
       ]
     }
   },

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@push.rocks/smartdns",
-  "version": "6.2.1",
+  "version": "7.0.2",
   "private": false,
-  "description": "A TypeScript library for smart DNS methods, supporting various DNS records and providers.",
+  "description": "A robust TypeScript library providing advanced DNS management and resolution capabilities including support for DNSSEC, custom DNS servers, and integration with various DNS providers.",
   "exports": {
-    ".": "./dist_ts_server/index.js",
+    ".": "./dist_ts/index.js",
     "./server": "./dist_ts_server/index.js",
     "./client": "./dist_ts_client/index.js"
   },
@@ -23,7 +23,13 @@
     "Google DNS",
     "Cloudflare",
     "UDP DNS",
-    "HTTPS DNS"
+    "HTTPS DNS",
+    "ACME",
+    "Let's Encrypt",
+    "SSL Certificates",
+    "Feature Flagging",
+    "Domain Propagation",
+    "DNS Server"
   ],
   "author": "Lossless GmbH",
   "license": "MIT",
@@ -34,21 +40,21 @@
   "dependencies": {
     "@push.rocks/smartdelay": "^3.0.1",
     "@push.rocks/smartenv": "^5.0.5",
-    "@push.rocks/smartpromise": "^4.0.4",
-    "@push.rocks/smartrequest": "^2.0.15",
-    "@tsclass/tsclass": "^4.1.2",
+    "@push.rocks/smartpromise": "^4.2.3",
+    "@push.rocks/smartrequest": "^2.1.0",
+    "@tsclass/tsclass": "^9.2.0",
     "@types/dns-packet": "^5.6.5",
     "@types/elliptic": "^6.4.18",
+    "acme-client": "^5.4.0",
     "dns-packet": "^5.6.1",
-    "elliptic": "^6.5.7",
+    "elliptic": "^6.6.1",
     "minimatch": "^10.0.1"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.84",
-    "@git.zone/tsrun": "^1.2.49",
-    "@git.zone/tstest": "^1.0.77",
-    "@push.rocks/tapbundle": "^5.2.0",
-    "@types/node": "^22.5.5"
+    "@git.zone/tsbuild": "^2.6.4",
+    "@git.zone/tsrun": "^1.3.3",
+    "@git.zone/tstest": "^2.3.1",
+    "@types/node": "^22.15.21"
   },
   "files": [
     "ts/**/*",

package/readme.md

@@ -1,4 +1,5 @@
 # @push.rocks/smartdns
+
 A TypeScript library for smart DNS methods, supporting various DNS records and providers.
 
 ## Install
@@ -31,11 +32,11 @@ import { Smartdns } from '@push.rocks/smartdns';
 
 ### Basic DNS Record Lookup
 
-Often, the need arises to fetch various DNS records for a domain. `@push.rocks/smartdns` simplifies this by providing intuitive methods.
+Often, the need arises to fetch various DNS records for a domain. `@push.rocks/smartdns` simplifies this by providing intuitive methods. A DNS record is essentially a map from a domain name to information about that domain, such as its IP address, mail exchange server, etc.
 
 #### Fetching A Records
 
-To fetch an "A" record for a domain:
+To fetch an "A" record for a domain, which resolves the domain to an IPv4 address, use the following approach:
 
 ```typescript
 import { Smartdns } from '@push.rocks/smartdns';
@@ -45,31 +46,37 @@ const aRecords = await dnsManager.getRecordsA('example.com');
 console.log(aRecords);
 ```
 
+This will return an array of records that include the IPv4 addresses mapped to the domain `example.com`.
+
 #### Fetching AAAA Records
 
-Similarly, for "AAAA" records:
+For resolving a domain to an IPv6 address, you can fetch "AAAA" records in a similar manner:
 
 ```typescript
 const aaaaRecords = await dnsManager.getRecordsAAAA('example.com');
 console.log(aaaaRecords);
 ```
 
+These queries are quite common where IPv6 addresses have been prevalent due to the scarcity of IPv4 addresses.
+
 #### Fetching TXT Records
 
-For "TXT" records:
+TXT records store arbitrary text data associated with a domain. They are often used to hold information such as SPF records for email validation or Google site verification token.
 
 ```typescript
 const txtRecords = await dnsManager.getRecordsTxt('example.com');
 console.log(txtRecords);
 ```
 
+TXT records have increasingly become significant with the growth of security features and integrations that require domain verification.
+
 ### Advanced DNS Management
 
-Beyond simple queries, `@push.rocks/smartdns` offers functionalities suitable for more complex DNS management scenarios.
+The `@push.rocks/smartdns` doesn't just stop at querying— it offers more advanced DNS management utilities, which are crucial for real-world applications involving DNS operations.
 
 #### Checking DNS Propagation
 
-When changing DNS records, ensuring that the new records have propagated fully is crucial. `@push.rocks/smartdns` facilitates this with a method to check a DNS record until it is available globally.
+When changing DNS records, ensuring that the new records have propagated fully is crucial. `@push.rocks/smartdns` facilitates this with a method to check if a DNS record is available globally. This can be critical for ensuring that users worldwide are able to access your updated records in a consistent manner.
 
 ```typescript
 const recordType = 'TXT'; // Record type: A, AAAA, CNAME, TXT etc.
@@ -83,13 +90,15 @@ if (isAvailable) {
 }
 ```
 
+This method repeatedly queries DNS servers until the expected DNS record appears, making sure that the changes made are visible globally.
+
 ### Leveraging DNS for Application Logic
 
-DNS records can serve beyond mere domain-to-IP resolution; they can be instrumental in application logic, such as feature flagging or environment-specific configurations.
+DNS records can function beyond their typical usage of domain-to-IP resolution. They can be extremely useful in application logic such as feature flagging or environment-specific configurations.
 
 #### Example: Feature Flagging via TXT Records
 
-Consider leveraging TXT records for enabling/disabling features dynamically without deploying new code.
+One such advanced use case is using TXT records for enabling or disabling features dynamically without needing to redeploy or change the actual application code:
 
 ```typescript
 const txtRecords = await dnsManager.getRecordsTxt('features.example.com');
@@ -101,16 +110,19 @@ const featureFlags = txtRecords.reduce((acc, record) => {
 
 if (featureFlags['NewFeature']) {
   // Logic to enable the new feature
+  console.log('New Feature enabled');
 }
 ```
 
+This approach enables applications to be more flexible and responsive to business needs as feature toggles can be managed through DNS.
+
 ### DNS Server Implementation
 
-To implement a DNS server, `@push.rocks/smartdns` includes classes and methods to set up a UDP and HTTPS DNS server supporting DNSSEC.
+`@push.rocks/smartdns` includes powerful features that allow you to implement your very own DNS server, complete with UDP and HTTPS protocols support and DNSSEC compliance.
 
 #### Basic DNS Server Example
 
-Here's a basic example of a UDP/HTTPS DNS server:
+Implementing a DNS server involves setting it up to respond to various DNS queries. Here's how you can set up a basic DNS server using UDP and HTTPS protocols:
 
 ```typescript
 import { DnsServer } from '@push.rocks/smartdns';
@@ -134,13 +146,15 @@ dnsServer.registerHandler('*.example.com', ['A'], (question) => ({
 dnsServer.start().then(() => console.log('DNS Server started'));
 ```
 
+This sets up a basic DNS server responding to A records for the domain `example.com` and mirrors the common structure used in production applications.
+
 ### DNSSEC Support
 
-`@push.rocks/smartdns` provides support for DNSSEC, including the generation, signing, and validation of DNS records.
+DNS Security Extensions (DNSSEC) adds an additional layer of security to DNS, protecting against various types of attacks. With `@push.rocks/smartdns`, setting up a DNS server with DNSSEC is straightforward.
 
 #### DNSSEC Configuration
 
-To configure DNSSEC for your DNS server:
+To configure DNSSEC for your DNS server, you’ll need to establish DNSSEC parameters including zone signatures and enabling key management. This setup ensures that DNS records are signed and can be verified for authenticity.
 
 ```typescript
 import { DnsServer } from '@push.rocks/smartdns';
@@ -164,20 +178,23 @@ dnsServer.registerHandler('*.example.com', ['A'], (question) => ({
 dnsServer.start().then(() => console.log('DNS Server with DNSSEC started'));
 ```
 
-This setup ensures that DNS records are signed and can be verified for authenticity.
-
 ### Handling DNS Queries Over Different Protocols
 
-The library supports handling DNS queries over UDP and HTTPS.
+The library supports handling DNS queries over UDP and HTTPS. This functionality allows for the flexible use and management of DNS inquiries and resolves, accommodating various protocol needs.
 
 #### Handling UDP Queries
 
-UDP is the traditional means of DNS query transport. 
+UDP is the traditional DNS protocol used for quick, non-persistent queries. Here’s how you can set up a DNS server to respond to UDP queries:
 
 ```typescript
 import { DnsServer } from '@push.rocks/smartdns';
 import dgram from 'dgram';
 
+const dnsServer = new DnsServer({
+  udpPort: 53,
+  httpsPort: 443,
+});
+
 dnsServer.registerHandler('*.example.com', ['A'], (question) => ({
   name: question.name,
   type: 'A',
@@ -199,9 +216,11 @@ client.on('message', (msg, rinfo) => {
 client.send(Buffer.from('example DNS query'), dnsServer.getOptions().udpPort, 'localhost');
 ```
 
+This segment of code creates a UDP server that listens for incoming DNS requests and responds accordingly.
+
 #### Handling HTTPS Queries
 
-DNS over HTTPS (DoH) is increasingly adopted for privacy and security.
+DNS over HTTPS (DoH) offers a heightened level of privacy and security, where DNS queries are transmitted over HTTPS to prevent eavesdropping and man-in-the-middle attacks.
 
 ```typescript
 import { DnsServer } from '@push.rocks/smartdns';
@@ -248,13 +267,17 @@ client.write(Buffer.from('example DNS query'));
 client.end();
 ```
 
+This ensures that DNS requests can be securely transmitted over the web, maintaining privacy for the clients querying the DNS server.
+
 ### Testing
 
-To ensure that the DNS server behaves as expected, it is important to write tests for various scenarios.
+Like any crucial application component, DNS servers require thorough testing to ensure reliability and correctness in different scenarios. Here we use TAP (Test Anything Protocol) to test various functionalities.
 
 #### DNS Server Tests
 
-Here is an example of how to test the DNS server with TAP:
+`@push.rocks/smartdns` integrates seamlessly with TAP, allowing for comprehensive testing of server functionalities.
+
+Here's an example of how you might set up tests for your DNS server:
 
 ```typescript
 import { expect, tap } from '@push.rocks/tapbundle';
@@ -312,7 +335,6 @@ tap.test('should add a DNS handler', async () => {
 });
 
 tap.test('should query the server over HTTP', async () => {
-  // Assuming fetch or any HTTP client is available
   const query = dnsPacket.encode({
     type: 'query',
     id: 2,
@@ -356,13 +378,11 @@ tap.test('should stop the server', async () => {
 await tap.start();
 ```
 
-### Conclusion
-
-`@push.rocks/smartdns` offers a versatile set of tools for DNS querying and management, tailored for applications at any scale. The examples provided illustrate the library's potential use cases, highlighting its applicability in various scenarios from basic lookups to facilitating complex application features through DNS.
+The above tests ensure that the DNS server setup, query handling, and proper stopping of the server are all functioning as intended.
 
-For the full spectrum of functionalities, including detailed method documentation and additional use cases, consult the module's [TypeDoc documentation](https://pushrocks.gitlab.io/smartdns/). This will serve as a comprehensive guide to leveraging `@push.rocks/smartdns` effectively in your projects.
+In a realistic production environment, additional tests would include edge cases such as malformed requests, large queries, concurrent access handling, and integration tests with various DNS resolvers. These tests ensure robustness and reliability of DNS services provided by the server.
 
-Remember, DNS changes might take time to propagate worldwide, and the utility methods provided by `@push.rocks/smartdns` for checking record availability will be invaluable in managing these changes seamlessly.
+This comprehensive guide demonstrates how to implement, manage, and test a DNS server using `@push.rocks/smartdns`, making it an ideal tool for developers tasked with handling DNS management and setup in TypeScript projects. The library supports the full scope of DNS operations needed for modern applications, from basic record query to full-scale DNS server operations with advanced security extensions.
 
 ## License and Legal Information
 

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartdns',
+  version: '7.0.2',
+  description: 'A robust TypeScript library providing advanced DNS management and resolution capabilities including support for DNSSEC, custom DNS servers, and integration with various DNS providers.'
+}

package/ts/index.ts

@@ -0,0 +1,4 @@
+import * as dnsClientMod from '../dist_ts_client/index.js';
+import * as dnsServerMod from '../dist_ts_server/index.js';
+
+export { dnsClientMod, dnsServerMod };

package/ts/tspublish.json

@@ -0,0 +1,3 @@
+{
+  "order": 3
+}