enom.js

Go to the documentation of this file.

// services/enom.js
// eNom Domain Registrar API Service
// Documentation: https://www.enom.com/api/
 
const axios = require('axios');
 
/**
 * Configure eNom API credentials and base URL
 */
function getConfig() {
  const isProduction = process.env.NODE_ENV === 'production';
  
  // eNom uses UID (reseller ID) and Password
  const uid = process.env.ENOM_UID || process.env.ENOM_USERNAME;
  const password = process.env.ENOM_PASSWORD;
  const baseURL = process.env.ENOM_BASE_URL || 'https://reseller.enom.com/interface.asp';
 
  if (!uid || !password) {
    console.warn('[eNom] API credentials not configured - some operations may fail');
  } else if (isProduction) {
    console.log('[eNom] Using PRODUCTION API');
  } else {
    console.log('[eNom] Using configured API credentials');
  }
 
  return {
    baseURL,
    uid,
    password
  };
}
 
/**
 * Make a request to the eNom API
 * @param {string} command - API command (e.g., 'Check', 'GetDomainInfo')
 * @param {object} params - Additional parameters
 * @returns {Promise<object>} - API response
 */
async function makeRequest(command, params = {}) {
  const config = getConfig();
  
  if (!config.uid || !config.password) {
    throw new Error('[eNom] API credentials not configured. Set ENOM_UID and ENOM_PASSWORD in environment variables.');
  }
 
  try {
    console.log(`[eNom] Making ${command} request with params:`, { ...params, UID: config.uid, PW: '***' });
    
    const response = await axios.get(config.baseURL, {
      params: {
        UID: config.uid,
        PW: config.password,
        Command: command,
        ResponseType: 'json',
        ...params
      },
      timeout: 30000
    });
 
    console.log('[eNom] Raw response:', typeof response.data, response.data);
 
    // Check if response is a string (error response)
    if (typeof response.data === 'string') {
      console.error('[eNom] API returned string instead of JSON:', response.data);
      throw new Error(`eNom API returned unexpected format: ${response.data.substring(0, 200)}`);
    }
 
    // eNom wraps responses in 'interface-response' object
    let data = response.data;
    if (data['interface-response']) {
      data = data['interface-response'];
    }
 
    // eNom returns JSON with ErrCount and errors array
    if (data.ErrCount && parseInt(data.ErrCount) > 0) {
      const errorMsg = data.errors?.join(', ') || data.Err1 || 'Unknown eNom API error';
      console.error('[eNom] API returned error:', errorMsg, 'Full data:', data);
      throw new Error(`eNom API Error: ${errorMsg}`);
    }
 
    return data;
  } catch (error) {
    if (error.response) {
      console.error(`[eNom] API Error on ${command}:`, error.response.status, error.response.data);
    } else {
      console.error(`[eNom] API Error on ${command}:`, error.message);
    }
    throw error;
  }
}
 
/**
 * Check domain availability
 * @param {string} domain - Domain name to check
 * @returns {Promise<object>} - Availability info
 */
async function checkDomain(domain) {
  try {
    // Split domain into SLD and TLD
    const parts = domain.split('.');
    const tld = parts.pop();
    const sld = parts.join('.');
 
    const result = await makeRequest('Check', {
      SLD: sld,
      TLD: tld
    });
 
    // RRPCode meanings:
    // 210 = Available
    // 211 = Not available (registered)
    // 212 = Invalid domain
    // 213 = Premium domain (available but premium price)
    const rrpCode = result.RRPCode;
    const available = rrpCode === '210' || rrpCode === '213';
    const isPremium = rrpCode === '213';
 
    return {
      domain: result.DomainName || domain,
      available: available,
      isPremium: isPremium,
      status: result.RRPText || 'unknown',
      rrpCode: result.RRPCode,
      raw: result
    };
  } catch (error) {
    console.error('[eNom] Error checking domain:', error.message);
    throw error;
  }
}
 
/**
 * Get domain information
 * @param {string} domain - Domain name
 * @returns {Promise<object>} - Domain details
 */
async function getDomainInfo(domain) {
  try {
    // Split domain into SLD and TLD
    const parts = domain.split('.');
    const tld = parts.pop();
    const sld = parts.join('.');
 
    const result = await makeRequest('GetDomainInfo', {
      SLD: sld,
      TLD: tld
    });
 
    // Parse expiration date
    let expirationDate = null;
    if (result.GetDomainInfo?.expiration) {
      expirationDate = new Date(result.GetDomainInfo.expiration);
    }
 
    // Parse nameservers
    const nameservers = [];
    if (result.GetDomainInfo?.services?.dns) {
      const dnsInfo = result.GetDomainInfo.services.dns;
      for (let i = 1; i <= 12; i++) {
        const ns = dnsInfo[`ns${i}`];
        if (ns) nameservers.push(ns);
      }
    }
 
    return {
      domain: domain,
      status: result.GetDomainInfo?.['domain-status'] || 'unknown',
      registration_date: result.GetDomainInfo?.['registration-date'] || null,
      expiration_date: expirationDate ? expirationDate.toISOString() : null,
      auto_renew: result.GetDomainInfo?.['auto-renew'] === 'True',
      nameservers: nameservers,
      registrar: 'enom',
      raw: result
    };
  } catch (error) {
    console.error('[eNom] Error getting domain info:', error.message);
    throw error;
  }
}
 
/**
 * Update domain nameservers
 * @param {string} domain - Domain name
 * @param {Array<string>} nameservers - Array of nameserver hostnames (2-12 nameservers)
 * @returns {Promise<object>} - Update result
 */
async function updateNameservers(domain, nameservers) {
  try {
    if (!nameservers || nameservers.length < 2) {
      throw new Error('At least 2 nameservers are required');
    }
 
    if (nameservers.length > 12) {
      throw new Error('Maximum 12 nameservers allowed');
    }
 
    // Split domain into SLD and TLD
    const parts = domain.split('.');
    const tld = parts.pop();
    const sld = parts.join('.');
 
    // Build nameserver parameters
    const nsParams = {};
    nameservers.forEach((ns, index) => {
      nsParams[`NS${index + 1}`] = ns;
    });
 
    const result = await makeRequest('ModifyNS', {
      SLD: sld,
      TLD: tld,
      ...nsParams
    });
 
    console.log(`[eNom] Successfully updated nameservers for ${domain}`);
 
    return {
      domain: domain,
      success: true,
      nameservers: nameservers,
      message: result.RRPText || 'Nameservers updated successfully',
      raw: result
    };
  } catch (error) {
    console.error('[eNom] Error updating nameservers:', error.message);
    throw error;
  }
}
 
/**
 * Get nameservers for a domain
 * @param {string} domain - Domain name
 * @returns {Promise<Array<string>>} - Array of nameserver hostnames
 */
async function getNameservers(domain) {
  try {
    const info = await getDomainInfo(domain);
    return info.nameservers || [];
  } catch (error) {
    console.error('[eNom] Error getting nameservers:', error.message);
    throw error;
  }
}
 
/**
 * Check multiple domains at once
 * @param {Array<string>} domains - Array of domain names
 * @returns {Promise<Array<object>>} - Array of availability info
 */
async function checkDomains(domains) {
  try {
    // Check domains sequentially to avoid rate limiting
    const results = [];
    for (const domain of domains) {
      try {
        const result = await checkDomain(domain);
        results.push(result);
      } catch (error) {
        results.push({
          domain: domain,
          available: false,
          status: 'error',
          error: error.message
        });
      }
    }
    return results;
  } catch (error) {
    console.error('[eNom] Error checking multiple domains:', error.message);
    throw error;
  }
}
 
/**
 * Register a domain
 * @param {object} params - Registration parameters
 * @returns {Promise<object>} - Registration result
 */
async function registerDomain(params) {
  const {
    domain,
    years = 1,
    nameservers = [],
    // Contact info
    registrantFirstName,
    registrantLastName,
    registrantEmail,
    registrantPhone,
    registrantAddress1,
    registrantCity,
    registrantStateProvince,
    registrantPostalCode,
    registrantCountry
  } = params;
 
  if (!registrantEmail || !registrantFirstName || !registrantLastName) {
    throw new Error('Registrant contact information is required');
  }
 
  console.log('[eNom] registerDomain called with:', {
    domain,
    years,
    nameservers,
    contact: {
      firstName: registrantFirstName,
      lastName: registrantLastName,
      email: registrantEmail,
      phone: registrantPhone,
      address: registrantAddress1,
      city: registrantCity,
      state: registrantStateProvince,
      postalCode: registrantPostalCode,
      country: registrantCountry
    }
  });
 
  try {
    // Split domain into SLD and TLD
    const parts = domain.split('.');
    const tld = parts.pop();
    const sld = parts.join('.');
 
    // Build nameserver parameters
    const nsParams = {};
    if (nameservers.length > 0) {
      nameservers.forEach((ns, index) => {
        nsParams[`NS${index + 1}`] = ns;
      });
    }
 
    // Build purchase parameters
    const purchaseParams = {
      SLD: sld,
      TLD: tld,
      NumYears: years,
      RegistrantFirstName: registrantFirstName,
      RegistrantLastName: registrantLastName,
      RegistrantEmailAddress: registrantEmail,
      RegistrantPhone: registrantPhone,
      RegistrantAddress1: registrantAddress1,
      RegistrantCity: registrantCity,
      RegistrantStateProvince: registrantStateProvince,
      RegistrantPostalCode: registrantPostalCode,
      RegistrantCountry: registrantCountry,
      ...nsParams
    };
 
    // Add Australian domain extended attributes (required for .au domains)
    // Default ABN: 20900142617 (Brent Stokes, QLD)
    if (tld.toLowerCase().includes('.au') || tld.toLowerCase() === 'au') {
      const abn = params.abn || '20900142617'; // Use provided ABN or default
      console.log('[eNom] Adding Australian extended attributes - ABN:', abn);
      
      purchaseParams['X-AU-REGISTRANT-ID-TYPE'] = 'ABN';
      purchaseParams['X-AU-REGISTRANT-ID-NUMBER'] = abn;
      
      // Optional: eligibility type and name (not always required)
      if (params.eligibilityType) {
        purchaseParams['X-ELIGIBILITY-TYPE'] = params.eligibilityType;
      }
      if (params.eligibilityName) {
        purchaseParams['X-ELIGIBILITY-NAME'] = params.eligibilityName;
      }
    }
 
    const result = await makeRequest('Purchase', purchaseParams);
 
    console.log('[eNom] Purchase API result:', JSON.stringify(result, null, 2));
 
    // Check for Order ID in response
    if (!result.OrderID && !result.orderid && !result.OrderId) {
      console.error('[eNom] No Order ID found in response. Full result:', result);
      throw new Error(`eNom API did not return an Order ID. Response: ${JSON.stringify(result)}`);
    }
 
    const expirationDate = new Date();
    expirationDate.setFullYear(expirationDate.getFullYear() + years);
 
    return {
      domain: domain,
      status: 'active',
      registration_date: new Date().toISOString(),
      expiration_date: expirationDate.toISOString(),
      registrar: 'enom',
      order_id: result.OrderID || result.orderid || result.OrderId,
      raw: result
    };
  } catch (error) {
    console.error('[eNom] Error registering domain:', error.message);
    throw error;
  }
}
 
/**
 * Lock domain (enable transfer lock/registrar lock)
 * @param {string} domain - Domain name
 * @returns {Promise<object>} - Lock result
 */
async function lockDomain(domain) {
  try {
    const parts = domain.split('.');
    const tld = parts.pop();
    const sld = parts.join('.');
 
    const result = await makeRequest('SetRegLock', {
      SLD: sld,
      TLD: tld,
      UnlockRegistrar: '0' // 0 = lock, 1 = unlock
    });
 
    return {
      domain: domain,
      locked: true,
      success: result.ErrCount === '0',
      raw: result
    };
  } catch (error) {
    console.error('[eNom] Error locking domain:', error.message);
    throw error;
  }
}
 
/**
 * Unlock domain (disable transfer lock/registrar lock)
 * @param {string} domain - Domain name
 * @returns {Promise<object>} - Unlock result
 */
async function unlockDomain(domain) {
  try {
    const parts = domain.split('.');
    const tld = parts.pop();
    const sld = parts.join('.');
 
    const result = await makeRequest('SetRegLock', {
      SLD: sld,
      TLD: tld,
      UnlockRegistrar: '1' // 0 = lock, 1 = unlock
    });
 
    return {
      domain: domain,
      locked: false,
      success: result.ErrCount === '0',
      raw: result
    };
  } catch (error) {
    console.error('[eNom] Error unlocking domain:', error.message);
    throw error;
  }
}
 
/**
 * Get registrar lock status
 * @param {string} domain - Domain name
 * @returns {Promise<object>} - Lock status
 */
async function getRegLock(domain) {
  try {
    const parts = domain.split('.');
    const tld = parts.pop();
    const sld = parts.join('.');
 
    const result = await makeRequest('GetRegLock', {
      SLD: sld,
      TLD: tld
    });
 
    return {
      domain: domain,
      locked: result['reg-lock'] === '1',
      raw: result
    };
  } catch (error) {
    console.error('[eNom] Error getting lock status:', error.message);
    throw error;
  }
}
 
/**
 * Get domain auth code (EPP code for transfers)
 * @param {string} domain - Domain name
 * @returns {Promise<object>} - Auth code result
 */
async function getAuthCode(domain) {
  try {
    const parts = domain.split('.');
    const tld = parts.pop();
    const sld = parts.join('.');
 
    const result = await makeRequest('GetDomainAuthInfo', {
      SLD: sld,
      TLD: tld
    });
 
    return {
      domain: domain,
      auth_code: result.DomainAuthInfo || null,
      success: result.ErrCount === '0',
      raw: result
    };
  } catch (error) {
    console.error('[eNom] Error getting auth code:', error.message);
    throw error;
  }
}
 
/**
 * Enable/disable auto-renewal
 * @param {string} domain - Domain name
 * @param {boolean} enabled - Enable or disable auto-renewal
 * @returns {Promise<object>} - Auto-renewal update result
 */
async function setAutoRenew(domain, enabled) {
  try {
    const parts = domain.split('.');
    const tld = parts.pop();
    const sld = parts.join('.');
 
    const result = await makeRequest('SetRenew', {
      SLD: sld,
      TLD: tld,
      RenewFlag: enabled ? '1' : '0'
    });
 
    return {
      domain: domain,
      auto_renew: enabled,
      success: result.ErrCount === '0',
      raw: result
    };
  } catch (error) {
    console.error('[eNom] Error setting auto-renew:', error.message);
    throw error;
  }
}
 
/**
 * Get domain contact information
 * @param {string} domain - Domain name
 * @returns {Promise<object>} - Contact information
 */
async function getContacts(domain) {
  try {
    const parts = domain.split('.');
    const tld = parts.pop();
    const sld = parts.join('.');
 
    const result = await makeRequest('GetContacts', {
      SLD: sld,
      TLD: tld
    });
 
    return {
      domain: domain,
      registrant: result.Registrant || null,
      admin: result.Admin || null,
      tech: result.Tech || null,
      billing: result.AuxBilling || null,
      raw: result
    };
  } catch (error) {
    console.error('[eNom] Error getting contacts:', error.message);
    throw error;
  }
}
 
/**
 * Renew domain
 * @param {string} domain - Domain name
 * @param {number} years - Number of years to renew
 * @returns {Promise<object>} - Renewal result
 */
async function renewDomain(domain, years = 1) {
  try {
    const parts = domain.split('.');
    const tld = parts.pop();
    const sld = parts.join('.');
 
    const result = await makeRequest('Extend', {
      SLD: sld,
      TLD: tld,
      NumYears: years
    });
 
    return {
      domain: domain,
      renewed: true,
      years: years,
      success: result.ErrCount === '0',
      raw: result
    };
  } catch (error) {
    console.error('[eNom] Error renewing domain:', error.message);
    throw error;
  }
}
 
/**
 * Get all domains in the eNom account
 * @returns {Promise<Array>} - List of all domains
 */
async function getAllDomains() {
  try {
    console.log('[eNom] Fetching all domains from account');
    
    // eNom GetDomains command returns all domains in account
    const result = await makeRequest('GetDomains', {});
    
    if (!result || !result.DomainDetail) {
      console.log('[eNom] No domains found or unexpected response format');
      return [];
    }
    
    // Handle both single domain (object) and multiple domains (array)
    let domains = [];
    if (Array.isArray(result.DomainDetail)) {
      domains = result.DomainDetail;
    } else if (result.DomainDetail) {
      domains = [result.DomainDetail];
    }
    
    console.log(`[eNom] Found ${domains.length} domains`);
    
    // Map to consistent format
    return domains.map(domain => ({
      name: domain.domainname || domain.sld + '.' + domain.tld,
      status: domain.expstatus || domain.status,
      expiration_date: domain.expiration_date || domain['expiration-date'],
      registration_date: domain.registration_date || domain['registration-date'],
      auto_renew: domain['auto-renew'] === '1' || domain.AutoRenew === '1',
      locked: domain['registrar-lock'] === '1',
      raw: domain
    }));
  } catch (error) {
    console.error('[eNom] Error getting all domains:', error.message);
    // Return empty array on error rather than throwing
    return [];
  }
}
 
module.exports = {
  checkDomain,
  checkDomains,
  getDomainInfo,
  updateNameservers,
  getNameservers,
  registerDomain,
  lockDomain,
  unlockDomain,
  getRegLock,
  getAuthCode,
  setAutoRenew,
  getContacts,
  renewDomain,
  getAllDomains,
  makeRequest
};