@startanaicompany/dns 1.3.0

package/lib/namesilo.js

@@ -0,0 +1,754 @@
+'use strict';
+
+const NAMESILO_BASE = 'https://www.namesilo.com/api';
+
+// ─── Custom Error ──────────────────────────────────────────────────────────
+class NameSiloError extends Error {
+  constructor(detail, code) {
+    super(detail || 'NameSilo API error');
+    this.name = 'NameSiloError';
+    this.code = code;
+    this.detail = detail;
+  }
+}
+
+// ─── Success codes ─────────────────────────────────────────────────────────
+const SUCCESS_CODES = new Set([300, 301, 302]);
+
+// ─── Core request function ─────────────────────────────────────────────────
+async function call(operation, params = {}) {
+  const key = process.env.NAMESILO_API_KEY;
+
+  // Use mock mode when: NAMESILO_MOCK=true explicitly set, OR no API key configured
+  if (process.env.NAMESILO_MOCK === 'true' || !key) {
+    return mockResponse(operation, params);
+  }
+
+  const url = new URL(`${NAMESILO_BASE}/${operation}`);
+  url.searchParams.set('version', '1');
+  url.searchParams.set('type', 'json');
+  url.searchParams.set('key', key);
+
+  Object.entries(params).forEach(([k, v]) => {
+    if (v !== undefined && v !== null) {
+      url.searchParams.set(k, String(v));
+    }
+  });
+
+  const res = await fetch(url.toString());
+
+  if (!res.ok) {
+    throw new NameSiloError(`HTTP ${res.status}: ${res.statusText}`, res.status);
+  }
+
+  let json;
+  try {
+    json = await res.json();
+  } catch (e) {
+    throw new NameSiloError('Invalid JSON response from NameSilo', 0);
+  }
+
+  const reply = json.reply || json;
+  const code = parseInt(reply.code, 10);
+  const detail = reply.detail || 'Unknown error';
+
+  if (SUCCESS_CODES.has(code)) {
+    return reply;
+  }
+
+  // Map known error codes to descriptive messages
+  const errorMessages = {
+    110: 'Invalid API key',
+    108: 'Missing required parameters',
+    200: 'Domain not active or not owned by this account',
+    261: 'Domain not available for registration',
+    280: 'Insufficient account funds',
+    101: 'Operation failed',
+    102: 'Invalid input',
+    103: 'Authorization failed',
+    104: 'Domain locked',
+    105: 'Domain already exists',
+    106: 'Domain transfer prohibited',
+    107: 'Domain not eligible for renewal',
+    109: 'Invalid domain name',
+    111: 'Invalid contact ID',
+    112: 'Invalid nameserver',
+    113: 'Invalid years value',
+    114: 'Domain already private',
+    115: 'Domain already public',
+    116: 'Domain already locked',
+    117: 'Domain already unlocked',
+    118: 'Domain already has auto-renewal enabled',
+    119: 'Domain already has auto-renewal disabled',
+  };
+
+  const message = errorMessages[code] || detail;
+  throw new NameSiloError(message, code);
+}
+
+// ─── Mock mode data ────────────────────────────────────────────────────────
+// In-memory storage for mock operations that require persistence between calls
+const _mockStore = {
+  emailForwards: {} // { domain: [{ email2, forward2 }] }
+};
+
+function mockResponse(operation, params) {
+  const base = { code: 300, detail: 'success', operationtype: operation };
+
+  switch (operation) {
+    case 'checkRegisterAvailability': {
+      const domains = (params.domains || '').split(',').filter(Boolean);
+      const available = {};
+      const unavailable = {};
+      domains.forEach((d, i) => {
+        // Mock: every other domain is unavailable for realism
+        if (i % 2 === 0) {
+          available[d] = { price: '12.99' };
+        } else {
+          unavailable[d] = {};
+        }
+      });
+      return { ...base, available, unavailable };
+    }
+
+    case 'registerDomain':
+      return {
+        ...base,
+        code: 302,
+        detail: 'Successful order',
+        domain: params.domain,
+        order_amount: '12.99',
+        total_amount: '12.99',
+        message: 'Your domain registration was successfully processed.'
+      };
+
+    case 'getPrices':
+      return {
+        ...base,
+        com: { registration: '12.99', renewal: '12.99', transfer: '12.99' },
+        net: { registration: '11.99', renewal: '11.99', transfer: '11.99' },
+        org: { registration: '10.99', renewal: '10.99', transfer: '10.99' },
+        io:  { registration: '39.99', renewal: '39.99', transfer: '39.99' },
+        dev: { registration: '12.99', renewal: '12.99', transfer: '12.99' },
+        app: { registration: '14.99', renewal: '14.99', transfer: '14.99' },
+        ai:  { registration: '69.99', renewal: '69.99', transfer: '69.99' },
+        co:  { registration: '24.99', renewal: '24.99', transfer: '24.99' },
+        xyz: { registration: '3.99',  renewal: '3.99',  transfer: '3.99'  },
+        me:  { registration: '19.99', renewal: '19.99', transfer: '19.99' }
+      };
+
+    case 'listDomains':
+      return {
+        ...base,
+        domains: {
+          domain: [
+            {
+              domain: 'example.com',
+              created: '2024-01-15',
+              expires: '2025-01-15',
+              status: 'Active',
+              locked: 'Yes',
+              private: 'No',
+              auto_renew: 'Yes',
+              traffic_type: 'Forwarding',
+              email_verified: 'Yes',
+              portfolio: ''
+            },
+            {
+              domain: 'mysite.io',
+              created: '2024-06-01',
+              expires: '2025-06-01',
+              status: 'Active',
+              locked: 'Yes',
+              private: 'Yes',
+              auto_renew: 'No',
+              traffic_type: 'Forwarding',
+              email_verified: 'Yes',
+              portfolio: ''
+            }
+          ]
+        }
+      };
+
+    case 'getDomainInfo':
+      return {
+        ...base,
+        domain: params.domain || 'example.com',
+        created: '2024-01-15',
+        expires: '2025-01-15',
+        status: 'Active',
+        locked: 'Yes',
+        private: 'No',
+        auto_renew: 'Yes',
+        nameservers: { nameserver: ['ns1.namesilo.com', 'ns2.namesilo.com'] },
+        contact_ids: {
+          registrant: '12345',
+          administrative: '12345',
+          technical: '12345',
+          billing: '12345'
+        }
+      };
+
+    case 'renewDomain':
+      return {
+        ...base,
+        code: 302,
+        detail: 'Successful order',
+        domain: params.domain,
+        years: params.years || 1,
+        order_amount: '12.99',
+        total_amount: '12.99'
+      };
+
+    case 'dnsListRecords':
+      return {
+        ...base,
+        domain: params.domain || 'example.com',
+        resource_record: [
+          { record_id: 'mock-rr-1', type: 'A',   host: params.domain, value: '93.184.216.34', ttl: '3600', distance: '0' },
+          { record_id: 'mock-rr-2', type: 'MX',  host: params.domain, value: 'mail.example.com', ttl: '3600', distance: '10' },
+          { record_id: 'mock-rr-3', type: 'TXT', host: params.domain, value: 'v=spf1 include:_spf.google.com ~all', ttl: '3600', distance: '0' }
+        ]
+      };
+
+    case 'dnsAddRecord':
+      return {
+        ...base,
+        record_id: 'mock-rr-' + Math.floor(Math.random() * 100000)
+      };
+
+    case 'dnsUpdateRecord':
+      return { ...base };
+
+    case 'dnsDeleteRecord':
+      return { ...base };
+
+    case 'changeNameServers':
+      return { ...base };
+
+    case 'contactList':
+      return {
+        ...base,
+        contact: [
+          {
+            contact_id: '12345',
+            fn: 'John',
+            ln: 'Doe',
+            ad: '123 Main St',
+            cy: 'Anytown',
+            st: 'CA',
+            zp: '12345',
+            ct: 'US',
+            ph: '3125551234',
+            em: 'john.doe@example.com',
+            org: 'ACME Corp'
+          }
+        ]
+      };
+
+    case 'contactAdd':
+      return {
+        ...base,
+        contact_id: 'mock-contact-' + Math.floor(Math.random() * 100000)
+      };
+
+    case 'domainLock':
+      return { ...base };
+
+    case 'domainUnlock':
+      return { ...base };
+
+    case 'addPrivacy':
+      return { ...base };
+
+    case 'removePrivacy':
+      return { ...base };
+
+    case 'addAutoRenewal':
+      return { ...base };
+
+    case 'removeAutoRenewal':
+      return { ...base };
+
+    case 'retrieveAuthCode':
+      return {
+        ...base,
+        domain: params.domain,
+        message: 'The auth code for your domain has been sent to the registrant email address on file.'
+      };
+
+    case 'getAccountBalance':
+      return {
+        ...base,
+        balance: '100.00'
+      };
+
+    case 'whoisInfo':
+      return {
+        ...base,
+        domain: params.domain || 'example.com',
+        registrar: 'NameSilo, LLC',
+        registrar_url: 'https://www.namesilo.com',
+        creation_date: '2024-01-15T00:00:00Z',
+        updated_date: '2024-06-01T00:00:00Z',
+        expiry_date: '2025-01-15T00:00:00Z',
+        status: 'clientTransferProhibited',
+        nameservers: { nameserver: ['ns1.namesilo.com', 'ns2.namesilo.com'] },
+        registrant: {
+          name: 'Domain Admin',
+          organization: 'NameSilo Privacy Protection',
+          email: 'proxy@namesilo.com',
+          country: 'US'
+        }
+      };
+
+    case 'listRegisteredNameServers':
+      return {
+        ...base,
+        hosts: [
+          { host: `ns1.${params.domain || 'example.com'}`, ip: '1.2.3.4' }
+        ]
+      };
+    case 'addRegisteredNameServer':
+    case 'modifyRegisteredNameServer':
+    case 'deleteRegisteredNameServer':
+      return { ...base };
+
+    case 'portfolioList':
+      return { ...base, portfolios: { portfolio: [{ name: 'my-portfolio', domains: 5 }] } };
+    case 'portfolioAdd':
+      return { ...base };
+    case 'portfolioDelete':
+      return { ...base };
+    case 'portfolioDomainAssociate':
+      return { ...base };
+
+    case 'listOrders':
+      return { ...base, orders: { order: [{ order_number: 'ORD-1001', domain: 'example.com', amount: '12.99', date: '2024-01-15', status: 'Complete' }] } };
+    case 'orderDetails':
+      return { ...base, order_number: params.order_number, domain: 'example.com', amount: '12.99', date: '2024-01-15', status: 'Complete' };
+
+    case 'domainPush':
+      return { ...base, domain: params.domain };
+    case 'registrantVerificationStatus':
+      return { ...base, verified: true, email: params.email || 'user@example.com' };
+    case 'emailVerification':
+      return { ...base, message: 'Verification email sent' };
+
+    case 'transferUpdateChangeEPPCode':
+      return { ...base };
+    case 'transferUpdateResendAdminEmail':
+      return { ...base };
+    case 'transferUpdateResubmitToRegistry':
+      return { ...base };
+    case 'registerDomainDrop':
+      return { ...base, code: 302, detail: 'Successful order', domain: params.domain, order_amount: '12.99' };
+
+    case 'listEmailForwards': {
+      const domain = params.domain || '';
+      const forwards = _mockStore.emailForwards[domain] || [];
+      return { ...base, forwards };
+    }
+
+    case 'configureEmailForward': {
+      const domain = params.domain || '';
+      if (!_mockStore.emailForwards[domain]) _mockStore.emailForwards[domain] = [];
+      // Remove existing forward for same address if any, then add
+      _mockStore.emailForwards[domain] = _mockStore.emailForwards[domain].filter(
+        f => f.email2 !== params.email2
+      );
+      _mockStore.emailForwards[domain].push({ email2: params.email2, forward2: params.forward2 });
+      return { ...base };
+    }
+
+    case 'deleteEmailForward': {
+      const domain = params.domain || '';
+      if (_mockStore.emailForwards[domain]) {
+        _mockStore.emailForwards[domain] = _mockStore.emailForwards[domain].filter(
+          f => f.email2 !== params.email2
+        );
+      }
+      return { ...base };
+    }
+
+    default:
+      return { ...base, code: 300, detail: 'success (mock)' };
+  }
+}
+
+// ─── Public API operations ─────────────────────────────────────────────────
+
+/**
+ * Check domain availability for registration.
+ * @param {string[]} domains - Array of FQDNs
+ */
+async function checkRegisterAvailability(domains) {
+  if (!Array.isArray(domains) || domains.length === 0) {
+    throw new NameSiloError('domains must be a non-empty array', 108);
+  }
+  return call('checkRegisterAvailability', { domains: domains.join(',') });
+}
+
+/**
+ * Register a domain.
+ * @param {string} domain - FQDN to register
+ * @param {number} years - Registration years (1-10)
+ * @param {Object} opts - Optional: auto_renew, private, contact_id
+ */
+async function registerDomain(domain, years = 1, opts = {}) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('registerDomain', {
+    domain,
+    years,
+    auto_renew: opts.auto_renew !== undefined ? (opts.auto_renew ? 1 : 0) : 1,
+    private: opts.private !== undefined ? (opts.private ? 1 : 0) : 0,
+    contact_id: opts.contact_id
+  });
+}
+
+/**
+ * Get current pricing for TLDs.
+ * @param {string[]} tlds - Optional array of TLDs to filter (without dot)
+ */
+async function getPrices(tlds = []) {
+  return call('getPrices');
+}
+
+/**
+ * List all domains in the account.
+ */
+async function listDomains() {
+  return call('listDomains');
+}
+
+/**
+ * Get detailed info about a specific domain.
+ * @param {string} domain - FQDN
+ */
+async function getDomainInfo(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('getDomainInfo', { domain });
+}
+
+/**
+ * Renew a domain.
+ * @param {string} domain - FQDN
+ * @param {number} years - Number of years to renew
+ */
+async function renewDomain(domain, years = 1) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('renewDomain', { domain, years });
+}
+
+/**
+ * List DNS records for a domain.
+ * @param {string} domain - FQDN
+ */
+async function dnsListRecords(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('dnsListRecords', { domain });
+}
+
+/**
+ * Add a DNS record.
+ * @param {string} domain
+ * @param {string} type - Record type (A, AAAA, CNAME, MX, TXT, etc.)
+ * @param {string} host - Hostname/subdomain
+ * @param {string} value - Record value
+ * @param {number} ttl - TTL in seconds (default 3600)
+ * @param {number} distance - MX priority / SRV distance
+ */
+async function dnsAddRecord(domain, type, host, value, ttl = 3600, distance = 0) {
+  if (!domain || !type || !host || !value) {
+    throw new NameSiloError('domain, type, host, and value are required', 108);
+  }
+  return call('dnsAddRecord', {
+    domain,
+    rrtype: type,
+    rrhost: host,
+    rrvalue: value,
+    rrttl: ttl,
+    rrdistance: distance
+  });
+}
+
+/**
+ * Update an existing DNS record.
+ * @param {string} domain
+ * @param {string} rrid - Record ID from dnsListRecords
+ * @param {string} host
+ * @param {string} value
+ * @param {number} ttl
+ * @param {number} distance
+ */
+async function dnsUpdateRecord(domain, rrid, host, value, ttl = 3600, distance = 0) {
+  if (!domain || !rrid || !host || !value) {
+    throw new NameSiloError('domain, rrid, host, and value are required', 108);
+  }
+  return call('dnsUpdateRecord', {
+    domain,
+    rrid,
+    rrhost: host,
+    rrvalue: value,
+    rrttl: ttl,
+    rrdistance: distance
+  });
+}
+
+/**
+ * Delete a DNS record.
+ * @param {string} domain
+ * @param {string} rrid - Record ID
+ */
+async function dnsDeleteRecord(domain, rrid) {
+  if (!domain || !rrid) {
+    throw new NameSiloError('domain and rrid are required', 108);
+  }
+  return call('dnsDeleteRecord', { domain, rrid });
+}
+
+/**
+ * Change nameservers for a domain.
+ * @param {string} domain
+ * @param {string[]} ns - Array of nameserver hostnames (2-13)
+ */
+async function changeNameServers(domain, ns) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  if (!Array.isArray(ns) || ns.length < 2) {
+    throw new NameSiloError('At least 2 nameservers required', 108);
+  }
+  const nsParams = {};
+  ns.forEach((n, i) => { nsParams[`ns${i + 1}`] = n; });
+  return call('changeNameServers', { domain, ...nsParams });
+}
+
+/**
+ * List contacts in the account.
+ */
+async function contactList() {
+  return call('contactList');
+}
+
+/**
+ * Add a contact to the account.
+ * @param {Object} contact - Contact details
+ */
+async function contactAdd(contact) {
+  const required = ['fn', 'ln', 'ad', 'cy', 'st', 'zp', 'ct', 'ph', 'em'];
+  for (const field of required) {
+    if (!contact[field]) {
+      throw new NameSiloError(`Contact field '${field}' is required`, 108);
+    }
+  }
+  return call('contactAdd', contact);
+}
+
+/**
+ * Lock a domain (prevent transfers).
+ * @param {string} domain
+ */
+async function domainLock(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('domainLock', { domain });
+}
+
+/**
+ * Unlock a domain (allow transfers).
+ * @param {string} domain
+ */
+async function domainUnlock(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('domainUnlock', { domain });
+}
+
+/**
+ * Enable WHOIS privacy for a domain.
+ * @param {string} domain
+ */
+async function addPrivacy(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('addPrivacy', { domain });
+}
+
+/**
+ * Disable WHOIS privacy for a domain.
+ * @param {string} domain
+ */
+async function removePrivacy(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('removePrivacy', { domain });
+}
+
+/**
+ * Enable auto-renewal for a domain.
+ * @param {string} domain
+ */
+async function addAutoRenewal(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('addAutoRenewal', { domain });
+}
+
+/**
+ * Disable auto-renewal for a domain.
+ * @param {string} domain
+ */
+async function removeAutoRenewal(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('removeAutoRenewal', { domain });
+}
+
+/**
+ * Request the EPP auth/transfer code for a domain (sent via email).
+ * @param {string} domain
+ */
+async function retrieveAuthCode(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('retrieveAuthCode', { domain });
+}
+
+/**
+ * Get the current account balance.
+ */
+async function getAccountBalance() {
+  return call('getAccountBalance');
+}
+
+/**
+ * Get WHOIS info for a domain.
+ * @param {string} domain
+ */
+async function whoisInfo(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('whoisInfo', { domain });
+}
+
+/**
+ * List registered nameservers for a domain.
+ */
+async function listRegisteredNameServers(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('listRegisteredNameServers', { domain });
+}
+
+/**
+ * Add/register a private nameserver.
+ * @param {string} domain
+ * @param {string} host - Nameserver hostname (e.g. ns1.mydomain.com)
+ * @param {string[]} ips - IP addresses for the nameserver
+ */
+async function addRegisteredNameServer(domain, host, ips) {
+  if (!domain || !host || !ips || !ips.length) {
+    throw new NameSiloError('domain, host, and ips are required', 108);
+  }
+  const params = { domain, host };
+  ips.forEach((ip, i) => { params[`ip${i + 1}`] = ip; });
+  return call('addRegisteredNameServer', params);
+}
+
+/**
+ * Modify a registered nameserver.
+ */
+async function modifyRegisteredNameServer(domain, host, ips) {
+  if (!domain || !host || !ips || !ips.length) {
+    throw new NameSiloError('domain, host, and ips are required', 108);
+  }
+  const params = { domain, host };
+  ips.forEach((ip, i) => { params[`ip${i + 1}`] = ip; });
+  return call('modifyRegisteredNameServer', params);
+}
+
+/**
+ * Delete a registered nameserver.
+ */
+async function deleteRegisteredNameServer(domain, host) {
+  if (!domain || !host) throw new NameSiloError('domain and host are required', 108);
+  return call('deleteRegisteredNameServer', { domain, host });
+}
+
+// ─── Portfolio Management ─────────────────────────────────────────────────
+async function portfolioList() { return call('portfolioList'); }
+async function portfolioAdd(portfolio) { return call('portfolioAdd', { portfolio }); }
+async function portfolioDelete(portfolio) { return call('portfolioDelete', { portfolio }); }
+async function portfolioDomainAssociate(portfolio, domains) {
+  return call('portfolioDomainAssociate', { portfolio, domains: Array.isArray(domains) ? domains.join(',') : domains });
+}
+
+// ─── Orders ───────────────────────────────────────────────────────────────
+async function listOrders() { return call('listOrders'); }
+async function orderDetails(orderNumber) {
+  if (!orderNumber) throw new NameSiloError('order_number is required', 108);
+  return call('orderDetails', { order_number: orderNumber });
+}
+
+// ─── Domain Push & Registrant Verification ────────────────────────────────
+async function domainPush(domain, push_user) {
+  if (!domain || !push_user) throw new NameSiloError('domain and push_user (email) are required', 108);
+  return call('domainPush', { domain, push_user });
+}
+async function registrantVerificationStatus() { return call('registrantVerificationStatus'); }
+async function emailVerification(email) {
+  if (!email) throw new NameSiloError('email is required', 108);
+  return call('emailVerification', { email });
+}
+
+async function transferUpdateChangeEPPCode(domain, auth) {
+  if (!domain || !auth) throw new NameSiloError('domain and auth are required', 108);
+  return call('transferUpdateChangeEPPCode', { domain, auth });
+}
+async function transferUpdateResendAdminEmail(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('transferUpdateResendAdminEmail', { domain });
+}
+async function transferUpdateResubmitToRegistry(domain) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('transferUpdateResubmitToRegistry', { domain });
+}
+async function registerDomainDrop(domain, opts = {}) {
+  if (!domain) throw new NameSiloError('domain is required', 108);
+  return call('registerDomainDrop', { domain, years: opts.years || 1, auto_renew: opts.auto_renew !== false ? 1 : 0, private: opts.private ? 1 : 0 });
+}
+
+// ─── Exports ───────────────────────────────────────────────────────────────
+module.exports = {
+  NameSiloError,
+  call,
+  checkRegisterAvailability,
+  registerDomain,
+  getPrices,
+  listDomains,
+  getDomainInfo,
+  renewDomain,
+  dnsListRecords,
+  dnsAddRecord,
+  dnsUpdateRecord,
+  dnsDeleteRecord,
+  changeNameServers,
+  contactList,
+  contactAdd,
+  domainLock,
+  domainUnlock,
+  addPrivacy,
+  removePrivacy,
+  addAutoRenewal,
+  removeAutoRenewal,
+  retrieveAuthCode,
+  getAccountBalance,
+  whoisInfo,
+  listRegisteredNameServers,
+  addRegisteredNameServer,
+  modifyRegisteredNameServer,
+  deleteRegisteredNameServer,
+  portfolioList,
+  portfolioAdd,
+  portfolioDelete,
+  portfolioDomainAssociate,
+  listOrders,
+  orderDetails,
+  domainPush,
+  registrantVerificationStatus,
+  emailVerification,
+  transferUpdateChangeEPPCode,
+  transferUpdateResendAdminEmail,
+  transferUpdateResubmitToRegistry,
+  registerDomainDrop
+};