bulk-update-nameservers.js

Go to the documentation of this file.

#!/usr/bin/env node
/**
 * Bulk Nameserver Updater
 * 
 * This script updates nameservers for multiple domains at once.
 * Supports Moniker and eNom registrars.
 * 
 * Usage:
 *   node scripts/bulk-update-nameservers.js --registrar moniker --file domains.json --nameservers "ns1.example.com,ns2.example.com"
 *   node scripts/bulk-update-nameservers.js --registrar moniker --domain example.com --cloudflare
 *   node scripts/bulk-update-nameservers.js --registrar enom --file domains.txt --cloudflare
 * 
 * Options:
 *   --registrar <name>         Registrar API to use (moniker or enom)
 *   --domain <domain>          Single domain to update
 *   --file <path>              File with list of domains (JSON array or newline-separated)
 *   --nameservers <ns1,ns2>    Comma-separated list of nameservers
 *   --cloudflare               Use Cloudflare nameservers (auto-fetches from API)
 *   --dry-run                  Test mode - show what would be updated without making changes
 *   --delay <ms>               Delay between API calls in milliseconds (default: 1000)
 */
 
require('dotenv').config();
const fs = require('fs').promises;
const path = require('path');
const moniker = require('../services/moniker');
const enom = require('../services/enom');
const { createZone, getZone } = require('../services/cloudflare');
 
// Parse command line arguments
/**
 *
 */
function parseArgs() {
  const args = process.argv.slice(2);
  const options = {
    registrar: null,
    domain: null,
    file: null,
    nameservers: [],
    cloudflare: false,
    dryRun: false,
    delay: 1000
  };
 
  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    const next = args[i + 1];
 
    switch (arg) {
      case '--registrar':
        options.registrar = next;
        i++;
        break;
      case '--domain':
        options.domain = next;
        i++;
        break;
      case '--file':
        options.file = next;
        i++;
        break;
      case '--nameservers':
        options.nameservers = next.split(',').map(ns => ns.trim());
        i++;
        break;
      case '--cloudflare':
        options.cloudflare = true;
        break;
      case '--dry-run':
        options.dryRun = true;
        break;
      case '--delay':
        options.delay = parseInt(next, 10);
        i++;
        break;
      case '--help':
      case '-h':
        printHelp();
        process.exit(0);
        break;
    }
  }
 
  return options;
}
 
/**
 *
 */
function printHelp() {
  console.log(`
Bulk Nameserver Updater
=======================
 
Update nameservers for multiple domains across different registrars.
 
Usage:
  node scripts/bulk-update-nameservers.js [options]
 
Options:
  --registrar <name>         Required. Registrar API (moniker or enom)
  --domain <domain>          Single domain to update
  --file <path>              File with domains (JSON or text)
  --nameservers <ns1,ns2>    Comma-separated nameservers
  --cloudflare               Use Cloudflare nameservers
  --dry-run                  Test without making changes
  --delay <ms>               Delay between calls (default: 1000ms)
  --help, -h                 Show this help
 
Examples:
  # Update single domain to Cloudflare
  node scripts/bulk-update-nameservers.js --registrar moniker --domain example.com --cloudflare
 
  # Update domains from file to custom nameservers
  node scripts/bulk-update-nameservers.js --registrar enom --file domains.txt --nameservers "ns1.host.com,ns2.host.com"
 
  # Dry run to see what would change
  node scripts/bulk-update-nameservers.js --registrar moniker --file domains.json --cloudflare --dry-run
 
File Formats:
  - JSON: ["domain1.com", "domain2.com", "domain3.com"]
  - Text: One domain per line
  `);
}
 
/**
 * Load domains from file
 * @param filePath
 */
async function loadDomainsFromFile(filePath) {
  const content = await fs.readFile(filePath, 'utf8');
  const ext = path.extname(filePath).toLowerCase();
 
  if (ext === '.json') {
    const data = JSON.parse(content);
    // Handle both array and object with domains property
    return Array.isArray(data) ? data : data.domains || [];
  } else {
    // Text file - one domain per line
    return content.split('\n')
      .map(line => line.trim())
      .filter(line => line && !line.startsWith('#'));
  }
}
 
/**
 * Get Cloudflare nameservers for a domain
 * @param domain
 */
async function getCloudflareNameservers(domain) {
  try {
    console.log(`[Cloudflare] Checking if zone exists for ${domain}...`);
    
    // Try to get existing zone
    let zone = await getZone(domain);
    
    // If no zone, create one
    if (!zone || !zone.id) {
      console.log(`[Cloudflare] Creating new zone for ${domain}...`);
      zone = await createZone(domain);
    }
 
    if (!zone || !zone.name_servers || zone.name_servers.length === 0) {
      throw new Error('Failed to get Cloudflare nameservers');
    }
 
    console.log(`[Cloudflare] Zone ID: ${zone.id}`);
    console.log(`[Cloudflare] Nameservers: ${zone.name_servers.join(', ')}`);
 
    return {
      zoneId: zone.id,
      nameservers: zone.name_servers
    };
  } catch (error) {
    console.error(`[Cloudflare] Error for ${domain}:`, error.message);
    throw error;
  }
}
 
/**
 * Update nameservers for a domain
 * @param registrar
 * @param domain
 * @param nameservers
 * @param dryRun
 */
async function updateDomainNameservers(registrar, domain, nameservers, dryRun = false) {
  console.log(`\n${'='.repeat(60)}`);
  console.log(`Processing: ${domain}`);
  console.log(`${'='.repeat(60)}`);
  
  if (dryRun) {
    console.log('[DRY RUN] Would update nameservers to:', nameservers);
    return {
      domain,
      success: true,
      dryRun: true,
      nameservers
    };
  }
 
  try {
    let result;
    
    if (registrar === 'moniker') {
      console.log('[Moniker] Updating nameservers...');
      result = await moniker.updateNameservers(domain, nameservers);
    } else if (registrar === 'enom') {
      console.log('[eNom] Updating nameservers...');
      result = await enom.updateNameservers(domain, nameservers);
    } else {
      throw new Error(`Unsupported registrar: ${registrar}`);
    }
 
    console.log('✅ Success!');
    console.log('Updated nameservers:', result.nameservers);
    
    return {
      domain,
      success: true,
      nameservers: result.nameservers,
      result
    };
  } catch (error) {
    console.error('❌ Error:', error.message);
    
    return {
      domain,
      success: false,
      error: error.message
    };
  }
}
 
/**
 * Delay execution
 * @param ms
 */
function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}
 
/**
 * Main execution
 */
async function main() {
  const options = parseArgs();
 
  // Validate options
  if (!options.registrar) {
    console.error('❌ Error: --registrar is required');
    console.log('Run with --help for usage information');
    process.exit(1);
  }
 
  if (!['moniker', 'enom'].includes(options.registrar)) {
    console.error('❌ Error: --registrar must be "moniker" or "enom"');
    process.exit(1);
  }
 
  if (!options.domain && !options.file) {
    console.error('❌ Error: Either --domain or --file is required');
    console.log('Run with --help for usage information');
    process.exit(1);
  }
 
  if (!options.cloudflare && options.nameservers.length === 0) {
    console.error('❌ Error: Either --cloudflare or --nameservers is required');
    process.exit(1);
  }
 
  console.log(`
╔════════════════════════════════════════════════════════════╗
║         Bulk Nameserver Updater                            ║
╚════════════════════════════════════════════════════════════╝
 
Configuration:
  Registrar:   ${options.registrar}
  Mode:        ${options.dryRun ? 'DRY RUN (no changes)' : 'LIVE'}
  Delay:       ${options.delay}ms between requests
  `);
 
  // Get domains
  let domains = [];
  if (options.domain) {
    domains = [options.domain];
  } else if (options.file) {
    console.log(`Loading domains from: ${options.file}`);
    domains = await loadDomainsFromFile(options.file);
    console.log(`Loaded ${domains.length} domain(s)\n`);
  }
 
  if (domains.length === 0) {
    console.error('❌ No domains to process');
    process.exit(1);
  }
 
  // Results tracking
  const results = [];
  let successCount = 0;
  let failCount = 0;
 
  // Process each domain
  for (let i = 0; i < domains.length; i++) {
    const domain = domains[i];
    
    try {
      // Get nameservers
      let nameservers = options.nameservers;
      
      if (options.cloudflare) {
        console.log(`\n[${i + 1}/${domains.length}] Getting Cloudflare nameservers for ${domain}...`);
        const cfData = await getCloudflareNameservers(domain);
        nameservers = cfData.nameservers;
      }
 
      // Update nameservers
      const result = await updateDomainNameservers(
        options.registrar,
        domain,
        nameservers,
        options.dryRun
      );
 
      results.push(result);
      
      if (result.success) {
        successCount++;
      } else {
        failCount++;
      }
 
      // Delay between requests (except for last one)
      if (i < domains.length - 1) {
        console.log(`\nWaiting ${options.delay}ms before next request...`);
        await delay(options.delay);
      }
    } catch (error) {
      console.error(`\n❌ Fatal error processing ${domain}:`, error.message);
      results.push({
        domain,
        success: false,
        error: error.message
      });
      failCount++;
    }
  }
 
  // Print summary
  console.log(`\n${'='.repeat(60)}`);
  console.log('SUMMARY');
  console.log(`${'='.repeat(60)}`);
  console.log(`Total domains:    ${domains.length}`);
  console.log(`✅ Successful:    ${successCount}`);
  console.log(`❌ Failed:        ${failCount}`);
  
  if (options.dryRun) {
    console.log('\n⚠️  DRY RUN - No actual changes were made');
  }
 
  // Print failed domains
  if (failCount > 0) {
    console.log('\n\nFailed Domains:');
    results
      .filter(r => !r.success)
      .forEach(r => {
        console.log(`  • ${r.domain}: ${r.error}`);
      });
  }
 
  // Save results to file
  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
  const resultFile = `nameserver-update-results-${timestamp}.json`;
  await fs.writeFile(
    resultFile,
    JSON.stringify(results, null, 2),
    'utf8'
  );
  console.log(`\nResults saved to: ${resultFile}`);
 
  process.exit(failCount > 0 ? 1 : 0);
}
 
// Run if called directly
if (require.main === module) {
  main().catch(error => {
    console.error('Fatal error:', error);
    process.exit(1);
  });
}
 
module.exports = {
  updateDomainNameservers,
  getCloudflareNameservers,
  loadDomainsFromFile
};