now-cli/lib/domain-records.js

// Ours
const Now = require("../lib");

module.exports = class DomainRecords extends Now {
  async getRecord(id) {
    const all = (await this.ls()).entries();
    for (const [domain, records] of all) {
      for (const record of records) {
        if (record.id === id) {
          record.domain = domain;
          return record;
        }
      }
    }
    return null;
  }

  async ls(dom) {
    let domains;

    if (dom) {
      domains = [dom];
    } else {
      const ret = await this.listDomains();
      domains = ret
        .filter(x => !x.isExternal)
        .map(x => x.name)
        .sort((a, b) => a.localeCompare(b));
    }

    const records = new Map();
    for (const domain of domains) {
      const body = await this.retry(async (bail, attempt) => {
        const url = `/domains/${domain}/records`;
        if (this._debug) {
          console.time(`> [debug] #${attempt} GET ${url}`);
        }
        const res = await this._fetch(url);
        if (this._debug) {
          console.timeEnd(`> [debug] #${attempt} GET ${url}`);
        }
        const body = await res.json();

        if (res.status === 404 && body.code === "not_found") {
          return bail(new Error(body.message));
        } else if (res.status !== 200) {
          throw new Error(`Failed to get DNS records for domain "${domain}"`);
        }

        return body;
      });
      records.set(
        domain,
        body.records.sort((a, b) => a.slug.localeCompare(b.slug))
      );
    }

    return records;
  }

  create(domain, data) {
    const url = `/domains/${domain}/records`;

    return this.retry(async (bail, attempt) => {
      if (this._debug) {
        console.time(`> [debug] #${attempt} POST ${url}`);
      }
      const res = await this._fetch(url, {
        method: "POST",
        body: data
      });
      if (this._debug) {
        console.timeEnd(`> [debug] #${attempt} POST ${url}`);
      }

      const body = await res.json();
      if (res.status === 400) {
        return bail(
          new Error(body.error ? body.error.message : "Unknown error")
        );
      } else if (res.status === 403) {
        const err = new Error(
          `Not authorized to access the domain "${domain}"`
        );
        err.userError = true;
        return bail(err);
      } else if (res.status === 404) {
        let err;

        if (body.error.code === "not_found") {
          err = new Error(`The domain "${domain}" was not found`);
          err.userError = true;
          return bail(err);
        }
      }

      if (res.status !== 200) {
        throw new Error(body.error ? body.error.message : "Unknown error");
      }

      return body;
    });
  }

  delete(domain, recordId) {
    const url = `/domains/${domain}/records/${recordId}`;

    return this.retry(async (bail, attempt) => {
      if (this._debug) {
        console.time(`> [debug] #${attempt} DELETE ${url}`);
      }
      const res = await this._fetch(url, { method: "DELETE" });
      if (this._debug) {
        console.timeEnd(`> [debug] #${attempt} DELETE ${url}`);
      }

      const body = await res.json();
      if (res.status === 403) {
        const err = new Error(`Not authorized to access domain ${domain}`);
        err.userError = true;
        return bail(err);
      } else if (res.status === 404) {
        let err;

        if (body.error.code === "not_found") {
          err = new Error(body.error.message);
          err.userError = true;
          return bail(err);
        }
      }

      if (res.status !== 200) {
        throw new Error(body.error ? body.error.message : "Unkown error");
      }

      return body;
    });
  }
};