coolify-deployment-cli/lib/dns-helper-advanced.js

CLI tool for Coolify deployments

#!/usr/bin/env node

const dns = require('dns').promises;
const DNSHelperCore = require('./dns-helper-core');

class DNSHelper extends DNSHelperCore {
  async checkMXRecords(domain) {
    try {
      const result = await this.withTimeout(
        this.retryOperation(() => dns.resolveMx(domain))
      );

      return {
        type: 'MX',
        domain: domain,
        records: result.map(mx => ({
          exchange: mx.exchange,
          priority: mx.priority
        })),
        success: true,
        error: null
      };
    } catch (error) {
      return {
        type: 'MX',
        domain: domain,
        records: [],
        success: false,
        error: error.code === 'ENODATA' ? 'No MX records found' : error.message
      };
    }
  }

  async checkSOA(domain) {
    try {
      const result = await this.withTimeout(
        this.retryOperation(() => dns.resolveSoa(domain))
      );

      return {
        type: 'SOA',
        domain: domain,
        records: [result],
        success: true,
        error: null
      };
    } catch (error) {
      return {
        type: 'SOA',
        domain: domain,
        records: [],
        success: false,
        error: error.code === 'ENODATA' ? 'No SOA record found' : error.message
      };
    }
  }

  async checkCAA(domain) {
    try {
      const result = await this.withTimeout(
        this.retryOperation(() => dns.resolveCaa(domain))
      );

      return {
        type: 'CAA',
        domain: domain,
        records: result,
        success: true,
        error: null
      };
    } catch (error) {
      return {
        type: 'CAA',
        domain: domain,
        records: [],
        success: false,
        error: error.code === 'ENODATA' ? 'No CAA records found' : error.message
      };
    }
  }

  async reverseDNS(ip) {
    try {
      const result = await this.withTimeout(
        this.retryOperation(() => dns.reverse(ip))
      );

      return {
        type: 'PTR',
        domain: ip,
        records: result,
        success: true,
        error: null
      };
    } catch (error) {
      return {
        type: 'PTR',
        domain: ip,
        records: [],
        success: false,
        error: error.message
      };
    }
  }

  async comprehensiveDNSCheck(domain) {
    const checks = [
      this.checkARecords(domain),
      this.checkAAAARecords(domain),
      this.checkMXRecords(domain),
      this.checkTXTRecords(domain),
      this.checkNSRecords(domain),
      this.checkSOA(domain),
      this.checkCAA(domain)
    ];

    const results = await Promise.allSettled(checks);
    const dnsResults = {};

    const recordTypes = ['A', 'AAAA', 'MX', 'TXT', 'NS', 'SOA', 'CAA'];

    results.forEach((result, index) => {
      const recordType = recordTypes[index];
      if (result.status === 'fulfilled') {
        dnsResults[recordType] = result.value;
      } else {
        dnsResults[recordType] = {
          type: recordType,
          domain: domain,
          records: [],
          success: false,
          error: result.reason?.message || 'Unknown error'
        };
      }
    });

    return dnsResults;
  }
}

module.exports = DNSHelper;