moniker.js

Go to the documentation of this file.

// services/moniker.js
// Moniker Domain Registration API
// Documentation: https://testapi.moniker.com
 
const axios = require('axios');
 
// Configure API credentials and base URL
/**
 *
 */
function getConfig() {
  const isProduction = process.env.NODE_ENV === 'production';
  
  // Moniker requires UserKey and ApiKey for authentication
  const userKey = process.env.MONIKER_USER_KEY || 'monikeruser';
  const apiKey = process.env.MONIKER_API_KEY || 'monikerapi';
  const apiPassword = process.env.MONIKER_API_PASSWORD;
  const baseURL = process.env.MONIKER_BASE_URL || 'https://testapi.moniker.com';
 
  if (userKey === 'monikeruser' && apiKey === 'monikerapi') {
    console.log('[Moniker] Using TEST API with default credentials');
  } else if (isProduction) {
    console.log('[Moniker] Using PRODUCTION API');
  } else {
    console.log('[Moniker] Using configured API credentials');
  }
 
  return {
    baseURL,
    userKey,
    apiKey,
    apiPassword
  };
}
 
/**
 * Make a request to the Moniker API
 * @param {string} endpoint - API endpoint (e.g., 'Domain/Check')
 * @param {object} params - Additional query parameters
 * @returns {Promise<object>} - API response
 */
async function makeRequest(endpoint, params = {}) {
  const config = getConfig();
  
  try {
    const requestParams = {
      UserKey: config.userKey,
      ApiKey: config.apiKey,
      ...params
    };
    
    // Add ApiPassword if available (some endpoints may need it)
    if (config.apiPassword) {
      requestParams.ApiPassword = config.apiPassword;
    }
    
    const response = await axios.get(`${config.baseURL}/${endpoint}`, {
      params: requestParams,
      timeout: 10000
    });
 
    // Moniker API returns key=value pairs, one per line
    // Parse this format into an object
    const data = {};
    const lines = response.data.split('\n');
    
    for (const line of lines) {
      const trimmed = line.trim();
      if (trimmed && trimmed.includes('=')) {
        const [key, ...valueParts] = trimmed.split('=');
        data[key] = valueParts.join('='); // Rejoin in case value contains =
      }
    }
 
    return data;
  } catch (error) {
    console.error(`[Moniker] API Error on ${endpoint}:`, error.message);
    if (error.response) {
      console.error('[Moniker] Response:', error.response.data);
    }
    throw error;
  }
}
 
 
/**
 * Check domain availability
 * @param {string} domain - Domain name to check
 * @returns {Promise<object>} - Availability info
 */
async function checkDomain(domain) {
  try {
    const result = await makeRequest('Domain/Check', {
      Domain: domain
    });
 
    // Moniker API response fields:
    // status=AVAILABLE or UNAVAILABLE
    // domain=example.com
    // price_ispremium=YES/NO
    const available = result.status === 'AVAILABLE';
 
    return {
      domain: result.domain || domain,
      available: available,
      status: result.status || 'unknown',
      isPremium: result.price_ispremium === 'YES',
      minRegPeriod: result.minregperiod,
      maxRegPeriod: result.maxregperiod,
      price: null, // Pricing requires separate API call
      currency: 'USD',
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] Error checking domain:', 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 for test API
    const results = await Promise.all(
      domains.map(domain => checkDomain(domain))
    );
    return results;
  } catch (error) {
    console.error('[Moniker] 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 = [],
    ownercontact,
    admincontact,
    techcontact,
    billingcontact
  } = params;
 
  if (!ownercontact) {
    throw new Error('Owner contact information is required');
  }
 
  try {
    // Note: Test API may not support actual registration
    // This is a placeholder for the production implementation
    const result = await makeRequest('Domain/Register', {
      Domain: domain,
      Period: years,
      // Add contact and nameserver parameters based on Moniker API docs
    });
 
    return {
      domain: domain,
      status: result.Status || 'pending',
      registration_date: new Date().toISOString(),
      expiration_date: new Date(Date.now() + (years * 365 * 24 * 60 * 60 * 1000)).toISOString(),
      registrar: 'moniker',
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] Error registering domain:', error.message);
    throw error;
  }
}
 
 
/**
 * Get domain info
 * @param {string} domain - Domain name
 * @returns {Promise<object>} - Domain information
 */
async function getDomainInfo(domain) {
  try {
    const result = await makeRequest('Domain/Info', {
      Domain: domain
    });
 
    return {
      domain: domain,
      status: result.Status || 'unknown',
      registration_date: result.CreatedDate || null,
      expiration_date: result.ExpirationDate || null,
      nameservers: result.Nameservers || [],
      registrar: 'moniker',
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] Error getting domain info:', error.message);
    throw error;
  }
}
 
/**
 * Update domain nameservers
 * @param {string} domain - Domain name
 * @param {Array<string>} nameservers - Array of nameserver hostnames
 * @returns {Promise<object>} - Update result
 */
async function updateNameservers(domain, nameservers) {
  try {
    const result = await makeRequest('Domain/UpdateNameservers', {
      Domain: domain,
      Nameservers: nameservers.join(',')
    });
 
    return {
      domain: domain,
      nameservers: nameservers,
      updated: true,
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] Error updating nameservers:', error.message);
    throw error;
  }
}
 
/**
 * Get DNS zone records
 * @param {string} domain - Domain name
 * @returns {Promise<Array>} - DNS records
 */
async function getDNSRecords(domain) {
  try {
    const result = await makeRequest('DNS/List', {
      Domain: domain
    });
 
    // Convert API response to standard format
    return result.Records || [];
  } catch (error) {
    console.error('[Moniker] Error getting DNS records:', error.message);
    // Return empty array if zone doesn't exist
    return [];
  }
}
 
/**
 * Update DNS zone record
 * @param {string} domain - Domain name
 * @param {object} record - DNS record
 * @returns {Promise<object>} - Update result
 */
async function updateDNSRecord(domain, record) {
  try {
    const result = await makeRequest('DNS/Update', {
      Domain: domain,
      Type: record.type,
      Name: record.name,
      Value: record.value,
      TTL: record.ttl || 3600,
      Priority: record.priority
    });
 
    return {
      domain: domain,
      record: record,
      updated: true,
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] Error updating DNS record:', error.message);
    throw error;
  }
}
 
/**
 * Transfer domain in
 * @param {object} params - Transfer parameters
 * @returns {Promise<object>} - Transfer result
 */
async function transferDomain(params) {
  const {
    domain,
    authcode,
    years = 1,
    ownercontact
  } = params;
 
  if (!authcode) {
    throw new Error('Authorization code (EPP code) is required for transfer');
  }
 
  try {
    const result = await makeRequest('Domain/Transfer', {
      Domain: domain,
      AuthCode: authcode,
      Period: years
    });
 
    return {
      domain: domain,
      status: 'transfer_pending',
      registrar: 'moniker',
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] Error transferring domain:', error.message);
    throw error;
  }
}
 
/**
 * Renew domain
 * @param {string} domain - Domain name
 * @param {number} years - Years to renew for
 * @returns {Promise<object>} - Renewal result
 */
async function renewDomain(domain, years = 1) {
  try {
    const result = await makeRequest('Domain/Renew', {
      Domain: domain,
      Period: years
    });
 
    return {
      domain: domain,
      renewed: true,
      expiration_date: result.ExpirationDate || null,
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] Error renewing domain:', error.message);
    throw error;
  }
}
 
/**
 * Lock domain (enable transfer lock)
 * @param {string} domain - Domain name
 * @returns {Promise<object>} - Lock result
 */
async function lockDomain(domain) {
  try {
    const result = await makeRequest('Domain/SetLock', {
      Domain: domain,
      LockStatus: 'true'
    });
 
    return {
      domain: domain,
      locked: true,
      success: true,
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] Error locking domain:', error.message);
    throw error;
  }
}
 
/**
 * Unlock domain (disable transfer lock)
 * @param {string} domain - Domain name
 * @returns {Promise<object>} - Unlock result
 */
async function unlockDomain(domain) {
  try {
    const result = await makeRequest('Domain/SetLock', {
      Domain: domain,
      LockStatus: 'false'
    });
 
    return {
      domain: domain,
      locked: false,
      success: true,
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] Error unlocking domain:', error.message);
    throw error;
  }
}
 
/**
 * Get domain auth/transfer code (EPP code)
 * @param {string} domain - Domain name
 * @returns {Promise<object>} - Auth code result
 */
async function getAuthCode(domain) {
  try {
    const result = await makeRequest('Domain/GetAuthCode', {
      Domain: domain
    });
 
    return {
      domain: domain,
      auth_code: result.AuthCode || result.EPPCode || null,
      success: true,
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] Error getting auth code:', error.message);
    throw error;
  }
}
 
/**
 * Enable/disable auto-renew
 * @param {string} domain - Domain name
 * @param {boolean} enabled - Enable or disable auto-renew
 * @returns {Promise<object>} - Auto-renew update result
 */
async function setAutoRenew(domain, enabled) {
  try {
    const result = await makeRequest('Domain/SetAutoRenew', {
      Domain: domain,
      AutoRenew: enabled ? 'true' : 'false'
    });
 
    return {
      domain: domain,
      auto_renew: enabled,
      success: true,
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] 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 result = await makeRequest('Domain/GetContacts', {
      Domain: domain
    });
 
    return {
      domain: domain,
      registrant: result.Registrant || null,
      admin: result.Admin || null,
      tech: result.Tech || null,
      billing: result.Billing || null,
      raw: result
    };
  } catch (error) {
    console.error('[Moniker] Error getting contacts:', error.message);
    throw error;
  }
}
 
/**
 * Get all domains in the Moniker account
 * @returns {Promise<Array>} - List of all domains
 */
async function getAllDomains() {
  try {
    console.log('[Moniker] Fetching all domains from account');
    
    // Moniker API endpoint to list all domains
    const result = await makeRequest('Domain/GetDomains', {});
    
    if (!result || !result.Domains) {
      console.log('[Moniker] No domains found or unexpected response format');
      return [];
    }
    
    // Handle both single domain (object) and multiple domains (array)
    let domains = [];
    if (Array.isArray(result.Domains.Domain)) {
      domains = result.Domains.Domain;
    } else if (result.Domains.Domain) {
      domains = [result.Domains.Domain];
    }
    
    console.log(`[Moniker] Found ${domains.length} domains`);
    
    // Map to consistent format with domain name
    return domains.map(domain => ({
      name: domain.Name || domain.DomainName,
      status: domain.Status,
      expiration_date: domain.ExpirationDate,
      registration_date: domain.RegistrationDate,
      auto_renew: domain.AutoRenew === 'true',
      locked: domain.Locked === 'true',
      raw: domain
    }));
  } catch (error) {
    console.error('[Moniker] Error getting all domains:', error.message);
    // Return empty array on error rather than throwing
    return [];
  }
}
 
module.exports = {
  checkDomain,
  checkDomains,
  registerDomain,
  getDomainInfo,
  updateNameservers,
  getDNSRecords,
  updateDNSRecord,
  transferDomain,
  renewDomain,
  lockDomain,
  unlockDomain,
  getAuthCode,
  setAutoRenew,
  getContacts,
  getAllDomains
};