domainSync.js

Go to the documentation of this file.

/**
 * Domain Sync Service
 * Syncs domain data from all registrars (Cloudflare, Moniker, eNom) every 5 minutes
 * Stores results in Redis for caching and updates PostgreSQL database
 */
 
const pool = require('./db');
const cloudflare = require('./cloudflare');
const moniker = require('./moniker');
const enom = require('./enom');
const { createClient } = require('redis');
 
const SYNC_INTERVAL = 5 * 60 * 1000; // 5 minutes
const REDIS_KEY_PREFIX = 'domains:sync:';
const REDIS_CACHE_TTL = 600; // 10 minutes cache
 
let redisClient = null;
let syncInterval = null;
let lastSyncTime = 0;
 
/**
 * Initialize Redis client
 */
async function initRedis() {
  if (redisClient) return redisClient;
 
  try {
    redisClient = createClient({
      url: process.env.REDIS_URL || `redis://${process.env.REDIS_HOST || 'localhost'}:${process.env.REDIS_PORT || 6379}`,
      username: process.env.REDIS_USERNAME,
      password: process.env.REDIS_PASSWORD
    });
 
    redisClient.on('error', (err) => {
      console.error('[Domain Sync] Redis error:', err);
    });
 
    await redisClient.connect();
    console.log('[Domain Sync] Redis connected');
    
    return redisClient;
  } catch (error) {
    console.error('[Domain Sync] Failed to connect to Redis:', error.message);
    return null;
  }
}
 
/**
 * Sync domains from Cloudflare
 */
async function syncCloudflare() {
  console.log('[Domain Sync] Syncing from Cloudflare...');
  
  try {
    const zones = await cloudflare.listZones();
    
    if (!zones || zones.length === 0) {
      console.log('[Domain Sync] No Cloudflare zones found');
      return [];
    }
 
    console.log(`[Domain Sync] Found ${zones.length} Cloudflare zones`);
    
    const domains = zones.map(zone => ({
      domain_name: zone.name,
      registrar: 'cloudflare',
      registrar_domain_id: zone.id,
      status: zone.status === 'active' ? 'active' : 'pending',
      nameservers: zone.name_servers || [],
      created_at: zone.created_on,
      modified_at: zone.modified_on,
      raw_data: zone
    }));
 
    // Cache in Redis
    if (redisClient) {
      await redisClient.setEx(
        `${REDIS_KEY_PREFIX}cloudflare`,
        REDIS_CACHE_TTL,
        JSON.stringify(domains)
      );
    }
 
    return domains;
  } catch (error) {
    console.error('[Domain Sync] Cloudflare sync error:', error.message);
    return [];
  }
}
 
/**
 * Sync domains from Moniker
 */
async function syncMoniker() {
  console.log('[Domain Sync] Syncing from Moniker...');
  
  // Check if Moniker credentials are configured
  const isTestMode = !process.env.MONIKER_USER_KEY || 
                     process.env.MONIKER_USER_KEY === 'monikerapi' ||
                     process.env.MONIKER_BASE_URL?.includes('testapi');
  
  if (isTestMode) {
    console.log('[Domain Sync] Moniker in test mode - skipping sync');
    return [];
  }
 
  try {
    // Moniker doesn't have a "list all domains" endpoint in standard API
    // We'll need to query our database for domains registered via Moniker
    // and update their details
    const result = await pool.query(
      `SELECT domain_id, domain_name, registrar_domain_id 
       FROM domains 
       WHERE registrar = 'moniker' AND status != 'cancelled'`
    );
 
    if (result.rows.length === 0) {
      console.log('[Domain Sync] No Moniker domains to sync');
      return [];
    }
 
    console.log(`[Domain Sync] Syncing ${result.rows.length} Moniker domains`);
    
    const domains = [];
    
    for (const row of result.rows) {
      try {
        const domainInfo = await moniker.getDomainInfo(row.domain_name);
        
        domains.push({
          domain_id: row.domain_id,
          domain_name: row.domain_name,
          registrar: 'moniker',
          registrar_domain_id: domainInfo.domain_id || row.registrar_domain_id,
          status: domainInfo.status?.toLowerCase() || 'active',
          expiration_date: domainInfo.expiration_date,
          nameservers: domainInfo.nameservers || [],
          raw_data: domainInfo
        });
        
        // Small delay to avoid rate limiting
        await new Promise(resolve => setTimeout(resolve, 500));
      } catch (error) {
        console.error(`[Domain Sync] Error syncing Moniker domain ${row.domain_name}:`, error.message);
      }
    }
 
    // Cache in Redis
    if (redisClient) {
      await redisClient.setEx(
        `${REDIS_KEY_PREFIX}moniker`,
        REDIS_CACHE_TTL,
        JSON.stringify(domains)
      );
    }
 
    return domains;
  } catch (error) {
    console.error('[Domain Sync] Moniker sync error:', error.message);
    return [];
  }
}
 
/**
 * Sync domains from eNom
 */
async function syncEnom() {
  console.log('[Domain Sync] Syncing from eNom...');
  
  // Check if eNom credentials are configured
  if (!process.env.ENOM_UID || !process.env.ENOM_PASSWORD) {
    console.log('[Domain Sync] eNom credentials not configured - skipping sync');
    return [];
  }
 
  try {
    // eNom doesn't have a "list all domains" endpoint in standard API
    // We'll query our database for eNom domains and update their details
    const result = await pool.query(
      `SELECT domain_id, domain_name, registrar_domain_id 
       FROM domains 
       WHERE registrar = 'enom' AND status != 'cancelled'`
    );
 
    if (result.rows.length === 0) {
      console.log('[Domain Sync] No eNom domains to sync');
      return [];
    }
 
    console.log(`[Domain Sync] Syncing ${result.rows.length} eNom domains`);
    
    const domains = [];
    
    for (const row of result.rows) {
      try {
        const domainInfo = await enom.getDomainInfo(row.domain_name);
        
        domains.push({
          domain_id: row.domain_id,
          domain_name: row.domain_name,
          registrar: 'enom',
          registrar_domain_id: domainInfo.domain_id || row.registrar_domain_id,
          status: domainInfo.status?.toLowerCase() || 'active',
          expiration_date: domainInfo.expiration,
          nameservers: domainInfo.nameservers || [],
          raw_data: domainInfo
        });
        
        // Small delay to avoid rate limiting
        await new Promise(resolve => setTimeout(resolve, 500));
      } catch (error) {
        console.error(`[Domain Sync] Error syncing eNom domain ${row.domain_name}:`, error.message);
      }
    }
 
    // Cache in Redis
    if (redisClient) {
      await redisClient.setEx(
        `${REDIS_KEY_PREFIX}enom`,
        REDIS_CACHE_TTL,
        JSON.stringify(domains)
      );
    }
 
    return domains;
  } catch (error) {
    console.error('[Domain Sync] eNom sync error:', error.message);
    return [];
  }
}
 
/**
 * Update database with synced domain data
 * @param domains
 */
async function updateDatabase(domains) {
  if (!domains || domains.length === 0) {
    console.log('[Domain Sync] No domains to update in database');
    return;
  }
 
  let updated = 0;
  let inserted = 0;
 
  for (const domain of domains) {
    try {
      // Check if domain exists
      const existing = await pool.query(
        'SELECT domain_id FROM domains WHERE domain_name = $1',
        [domain.domain_name]
      );
 
      if (existing.rows.length > 0) {
        // Update existing domain
        if (domain.domain_id) {
          await pool.query(
            `UPDATE domains 
             SET registrar_domain_id = COALESCE($1, registrar_domain_id),
                 status = COALESCE($2, status),
                 expiration_date = COALESCE($3, expiration_date),
                 nameservers = COALESCE($4, nameservers),
                 updated_at = NOW()
             WHERE domain_id = $5`,
            [
              domain.registrar_domain_id,
              domain.status,
              domain.expiration_date,
              JSON.stringify(domain.nameservers),
              domain.domain_id
            ]
          );
          updated++;
        }
      } else {
        // Insert new domain (Cloudflare zones not in database yet)
        if (domain.registrar === 'cloudflare') {
          // Get default tenant_id (you may want to make this smarter)
          const tenantResult = await pool.query('SELECT tenant_id FROM tenants LIMIT 1');
          
          if (tenantResult.rows.length > 0) {
            await pool.query(
              `INSERT INTO domains (
                 tenant_id, domain_name, registrar, registrar_domain_id, 
                 status, nameservers, expiration_date, created_at, updated_at
               )
               VALUES ($1, $2, $3, $4, $5, $6, $7, NOW(), NOW())
               ON CONFLICT (domain_name) DO NOTHING`,
              [
                tenantResult.rows[0].tenant_id,
                domain.domain_name,
                domain.registrar,
                domain.registrar_domain_id,
                domain.status,
                JSON.stringify(domain.nameservers),
                domain.expiration_date || new Date(Date.now() + 365 * 24 * 60 * 60 * 1000) // Default 1 year
              ]
            );
            inserted++;
          }
        }
      }
    } catch (error) {
      console.error(`[Domain Sync] Error updating domain ${domain.domain_name}:`, error.message);
    }
  }
 
  console.log(`[Domain Sync] Database updated: ${updated} updated, ${inserted} inserted`);
}
 
/**
 * Perform full sync from all registrars
 */
async function performSync() {
  const startTime = Date.now();
  console.log(`[Domain Sync] Starting full sync at ${new Date().toISOString()}`);
 
  try {
    // Sync from all registrars in parallel
    const [cloudflareDomains, monikerDomains, enomDomains] = await Promise.all([
      syncCloudflare(),
      syncMoniker(),
      syncEnom()
    ]);
 
    const allDomains = [...cloudflareDomains, ...monikerDomains, ...enomDomains];
    
    console.log(`[Domain Sync] Synced ${allDomains.length} total domains (Cloudflare: ${cloudflareDomains.length}, Moniker: ${monikerDomains.length}, eNom: ${enomDomains.length})`);
 
    // Update database
    await updateDatabase(allDomains);
 
    // Store summary in Redis
    if (redisClient) {
      const summary = {
        last_sync: new Date().toISOString(),
        duration_ms: Date.now() - startTime,
        total_domains: allDomains.length,
        by_registrar: {
          cloudflare: cloudflareDomains.length,
          moniker: monikerDomains.length,
          enom: enomDomains.length
        }
      };
 
      await redisClient.setEx(
        `${REDIS_KEY_PREFIX}summary`,
        REDIS_CACHE_TTL,
        JSON.stringify(summary)
      );
    }
 
    lastSyncTime = Date.now();
    console.log(`[Domain Sync] Sync completed in ${Date.now() - startTime}ms`);
 
    return {
      success: true,
      total: allDomains.length,
      duration: Date.now() - startTime
    };
  } catch (error) {
    console.error('[Domain Sync] Sync failed:', error);
    return {
      success: false,
      error: error.message
    };
  }
}
 
/**
 * Start periodic sync
 */
async function startPeriodicSync() {
  console.log('[Domain Sync] Starting periodic sync service...');
  
  // Initialize Redis
  await initRedis();
 
  // Do initial sync
  await performSync();
 
  // Set up periodic sync
  syncInterval = setInterval(async () => {
    await performSync();
  }, SYNC_INTERVAL);
 
  console.log(`[Domain Sync] Periodic sync started (interval: ${SYNC_INTERVAL / 1000}s)`);
}
 
/**
 * Stop periodic sync
 */
function stopPeriodicSync() {
  if (syncInterval) {
    clearInterval(syncInterval);
    syncInterval = null;
    console.log('[Domain Sync] Periodic sync stopped');
  }
}
 
/**
 * Get cached domains from Redis
 * @param registrar
 */
async function getCachedDomains(registrar = null) {
  if (!redisClient) {
    await initRedis();
  }
 
  if (!redisClient) {
    return null;
  }
 
  try {
    if (registrar) {
      const cached = await redisClient.get(`${REDIS_KEY_PREFIX}${registrar}`);
      return cached ? JSON.parse(cached) : null;
    } else {
      // Get all
      const [cloudflare, moniker, enom] = await Promise.all([
        redisClient.get(`${REDIS_KEY_PREFIX}cloudflare`),
        redisClient.get(`${REDIS_KEY_PREFIX}moniker`),
        redisClient.get(`${REDIS_KEY_PREFIX}enom`)
      ]);
 
      return {
        cloudflare: cloudflare ? JSON.parse(cloudflare) : [],
        moniker: moniker ? JSON.parse(moniker) : [],
        enom: enom ? JSON.parse(enom) : []
      };
    }
  } catch (error) {
    console.error('[Domain Sync] Error getting cached domains:', error.message);
    return null;
  }
}
 
/**
 * Get sync summary
 */
async function getSyncSummary() {
  if (!redisClient) {
    await initRedis();
  }
 
  if (!redisClient) {
    return null;
  }
 
  try {
    const summary = await redisClient.get(`${REDIS_KEY_PREFIX}summary`);
    return summary ? JSON.parse(summary) : null;
  } catch (error) {
    console.error('[Domain Sync] Error getting sync summary:', error.message);
    return null;
  }
}
 
/**
 * Force immediate sync
 */
async function forceSyncNow() {
  console.log('[Domain Sync] Force sync requested');
  return await performSync();
}
 
module.exports = {
  startPeriodicSync,
  stopPeriodicSync,
  performSync,
  forceSyncNow,
  getCachedDomains,
  getSyncSummary,
  initRedis
};