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()
    const bodies = []

    for (const domain of domains) {
      bodies.push(
        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
        })
      )
    }

    const domainList = await Promise.all(bodies)

    for (const body of domainList) {
      const index = domainList.indexOf(body)

      records.set(
        domains[index],
        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
    })
  }
}