@nictool/dns-resource-record 1.2.0 → 1.2.2

package/rr/tsig.js

@@ -13,7 +13,15 @@ export default class TSIG extends RR {
   }
 
   getRdataFields(arg) {
-    return ['algorithm name', 'time signed', 'fudge', 'mac', 'original id', 'error', 'other']
+    return [
+      'algorithm name',
+      'time signed',
+      'fudge',
+      'mac',
+      'original id',
+      'error',
+      'other',
+    ]
   }
 
   getRFCs() {
@@ -34,7 +42,7 @@ export default class TSIG extends RR {
       ttl: parseInt(ttl, 10),
       class: c,
       type: type,
-      'algorithm': algorithm,
+      algorithm: algorithm,
       // 'time signed': opts.bindline,
       // fudge
       // mac

package/rr/txt.js

@@ -54,7 +54,7 @@ export default class TXT extends RR {
     // generic: :fqdn:n:rdata:ttl:timestamp:location
     // eslint-disable-next-line prefer-const
     let [fqdn, n, rdata, ttl, ts, loc] = str.substring(1).split(':')
-    if (n != 16) throw new Error('TXT fromTinydns, invalid n')
+    if (n != 16) this.throwHelp('TXT fromTinydns, invalid n')
 
     rdata = TINYDNS.octalToChar(rdata)
     let s = ''
@@ -70,10 +70,10 @@ export default class TXT extends RR {
 
   fromBind(opts) {
     // test.example.com  3600  IN  TXT  "..."
-    const match = opts.bindline.split(
-      /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+?\s*(.*?)\s*$/,
-    )
-    if (!match) throw new Error(`unable to parse TXT: ${opts.bindline}`)
+    const match = opts.bindline
+      .trim()
+      .split(/^([\S]{1,255})\s+([0-9]{1,10})\s+(IN)\s+(\w{3})\s+?\s*(.*?)$/i)
+    if (!match) this.throwHelp(`unable to parse TXT: ${opts.bindline}`)
     const [owner, ttl, c, type, rdata] = match.slice(1)
 
     return new this.constructor({

package/rr/uri.js

@@ -21,7 +21,7 @@ export default class URI extends RR {
   }
 
   setTarget(val) {
-    if (!val) throw new Error(`URI: target is required, ${this.citeRFC()}`)
+    if (!val) this.throwHelp(`URI: target is required`)
 
     this.set('target', val)
   }
@@ -30,7 +30,7 @@ export default class URI extends RR {
   fromTinydns(opts) {
     // URI via generic, :fqdn:n:rdata:ttl:timestamp:lo
     const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
-    if (n != 256) throw new Error('URI fromTinydns, invalid n')
+    if (n != 256) this.throwHelp('URI fromTinydns, invalid n')
 
     return new URI({
       type: 'URI',

package/rr/wks.js

@@ -28,15 +28,16 @@ export default class WKS extends RR {
 
   fromBind(opts) {
     // test.example.com  3600  IN  WKS 192.168.1.1 TCP 25
-    const [owner, ttl, c, type, address, protocol, bitmap] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, address, protocol, bitmap] =
+      opts.bindline.split(/\s+/)
     return new WKS({
       owner,
       ttl: parseInt(ttl, 10),
       class: c,
       type,
-      address,  // 32-bit int
+      address, // 32-bit int
       protocol, // 8-bit int, 6=TCP, 17=UDP
-      bitmap,   // var len bit map, must be multiple of 8
+      bitmap, // var len bit map, must be multiple of 8
     })
   }
 

package/rr.js

@@ -1,3 +1,5 @@
+import util from 'node:util'
+
 export default class RR extends Map {
   constructor(opts) {
     super()
@@ -21,7 +23,7 @@ export default class RR extends Map {
     for (const f of this.getFields('rdata')) {
       const fnName = `set${this.ucfirst(f)}`
       if (this[fnName] === undefined)
-        throw new Error(`Missing ${fnName} in class ${this.get('type')}`)
+        this.throwHelp(`Missing ${fnName} in class ${this.get('type')}`)
       this[fnName](opts[f])
     }
 
@@ -51,7 +53,7 @@ export default class RR extends Map {
         this.set('class', c)
         break
       default:
-        throw new Error(`invalid class ${c}`)
+        this.throwHelp(`invalid class ${c}`)
     }
   }
 
@@ -74,20 +76,20 @@ export default class RR extends Map {
   }
 
   setOwner(n) {
-    if (n === undefined) throw new Error(`owner is required`)
+    if (n === undefined) this.throwHelp(`owner is required`)
 
     if (n.length < 1 || n.length > 255)
-      throw new Error(
+      this.throwHelp(
         'Domain names must have 1-255 octets (characters): RFC 2181',
       )
 
-    this.isFullyQualified('', 'owner', n)
+    this.isFullyQualified(this.constructor.name, 'owner', n)
     this.hasValidLabels(n)
 
     // wildcard records: RFC 1034, 4592
     if (/\*/.test(n)) {
       if (!/^\*\./.test(n) && !/\.\*\./.test(n))
-        throw new Error('only *.something or * (by itself) is a valid wildcard')
+        this.throwHelp('only *.something or * (by itself) is a valid wildcard')
     }
 
     this.set('owner', n.toLowerCase())
@@ -97,11 +99,11 @@ export default class RR extends Map {
     if (t === undefined) t = this?.default?.ttl
     if (t === undefined) {
       if (['SOA', 'SSHPF'].includes(this.get('type'))) return
-      throw new Error('TTL is required, no default available')
+      this.throwHelp('TTL is required, no default available')
     }
 
     if (typeof t !== 'number')
-      throw new Error(`TTL must be numeric (${typeof t})`)
+      this.throwHelp(`TTL must be numeric (${typeof t})`)
 
     // RFC 1035, 2181
     this.is32bitInt(this.owner, 'TTL', t)
@@ -113,17 +115,27 @@ export default class RR extends Map {
     switch (t) {
       case '':
       case undefined:
-        throw new Error(`type is required`)
+        this.throwHelp(`type is required`)
     }
 
     if (t.toUpperCase() !== this.constructor.name)
-      throw new Error(`type ${t} doesn't match ${this.constructor.name}`)
+      this.throwHelp(`type ${t} doesn't match ${this.constructor.name}`)
 
     this.set('type', t.toUpperCase())
   }
 
+  throwHelp(e) {
+    if (this.constructor.name === 'RR') throw new Error(e)
+
+    const example = this.getCanonical
+      ? `Example ${this.constructor.name}:\n${util.inspect(this.getCanonical(), { depth: null })}\n\n`
+      : `${this.constructor.name} records have the fields: ${this.getFields().join(', ')}\n\n`
+
+    throw new Error(`${e}\n\n${example}${this.citeRFC()}\n`)
+  }
+
   citeRFC() {
-    return `see RFC ${this.getRFCs()}`
+    return `see RFC${this.getRFCs().length > 1 ? 's' : ''} ${this.getRFCs()}`
   }
 
   fullyQualify(hostname, origin) {
@@ -194,7 +206,7 @@ export default class RR extends Map {
 
   getFQDN(field, zone_opts = {}) {
     let fqdn = this.get(field)
-    if (!fqdn) throw new Error(`empty value for field ${field}`)
+    if (!fqdn) this.throwHelp(`empty value for field ${field}`)
     if (!fqdn.endsWith('.')) fqdn += '.'
 
     if (zone_opts.hide?.origin && zone_opts.origin) {
@@ -235,7 +247,7 @@ export default class RR extends Map {
     const fq = hostname.endsWith('.') ? hostname.slice(0, -1) : hostname
     for (const label of fq.split('.')) {
       if (label.length < 1 || label.length > 63)
-        throw new Error('Labels must have 1-63 octets (characters), RFC 2181')
+        this.throwHelp('Labels must have 1-63 octets (characters), RFC 2181')
     }
   }
 
@@ -248,7 +260,7 @@ export default class RR extends Map {
     )
       return true
 
-    throw new Error(
+    this.throwHelp(
       `${type} ${field} must be a 8-bit integer (in the range 0-255)`,
     )
   }
@@ -262,7 +274,7 @@ export default class RR extends Map {
     )
       return true
 
-    throw new Error(
+    this.throwHelp(
       `${type} ${field} must be a 16-bit integer (in the range 0-65535)`,
     )
   }
@@ -276,7 +288,7 @@ export default class RR extends Map {
     )
       return true
 
-    throw new Error(
+    this.throwHelp(
       `${type} ${field} must be a 32-bit integer (in the range 0-2147483647)`,
     )
   }
@@ -285,10 +297,10 @@ export default class RR extends Map {
     return /^["']/.test(val) && /["']$/.test(val)
   }
 
-  isFullyQualified(type, blah, hostname) {
+  isFullyQualified(type, field, hostname) {
     if (hostname.endsWith('.')) return true
 
-    throw new Error(`${type}: ${blah} must be fully qualified`)
+    this.throwHelp(`${type}: ${field} must be fully qualified`)
   }
 
   isValidHostname(type, field, hostname) {
@@ -296,7 +308,7 @@ export default class RR extends Map {
     if (!allowed.test(hostname)) return true
 
     const matches = allowed.exec(hostname)
-    throw new Error(
+    this.throwHelp(
       `${type}, ${field} has invalid hostname character (${matches[0]})`,
     )
   }
@@ -320,7 +332,7 @@ export default class RR extends Map {
   }
 
   toMaraGeneric() {
-    // throw new Error(`\nMaraDNS does not support ${type} records yet and this package does not support MaraDNS generic records. Yet.\n`)
+    // this.throwHelp(`\nMaraDNS does not support ${type} records yet and this package does not support MaraDNS generic records. Yet.\n`)
     return `${this.get('owner')}\t+${this.get('ttl')}\tRAW ${this.getTypeId()}\t'${this.getRdataFields()
       .map((f) => this.getQuoted(f))
       .join(' ')}' ~\n`

package/test/a.js

@@ -0,0 +1,75 @@
+import A from '../rr/a.js'
+import * as base from './base.js'
+
+const defaults = { class: 'IN', ttl: 3600, type: 'A', address: '192.0.2.127' }
+
+const validRecords = [
+  {
+    ...defaults,
+    owner: 'test.example.com.',
+    testB: 'test.example.com.\t3600\tIN\tA\t192.0.2.127\n',
+    testT: '+test.example.com:192.0.2.127:3600::\n',
+  },
+  {
+    ...defaults,
+    owner: 'test.example.com.',
+    ttl: 2147483647,
+    testB: 'test.example.com.\t2147483647\tIN\tA\t192.0.2.127\n',
+    testT: '+test.example.com:192.0.2.127:2147483647::\n',
+  },
+  {
+    ...defaults,
+    owner: 'a.',
+    ttl: 86400,
+    testB: 'a.\t86400\tIN\tA\t192.0.2.127\n',
+    testT: '+a:192.0.2.127:86400::\n',
+  },
+  {
+    ...defaults,
+    owner: '*.example.com.',
+    testB: '*.example.com.\t3600\tIN\tA\t192.0.2.127\n',
+    testT: '+*.example.com:192.0.2.127:3600::\n',
+  },
+]
+
+const invalidRecords = [
+  { ...defaults, owner: '', msg: /RFC/ },
+  { ...defaults, owner: 'something*', msg: /fully/ },
+  { ...defaults, owner: 'some*thing', msg: /fully/ },
+  { ...defaults, owner: '*something', msg: /fully/ },
+  { ...defaults, owner: 'something.*', msg: /fully/ },
+  { ...defaults, address: 'hosts.not.valid.here', msg: /address must be IPv4/ },
+  { ...defaults, address: '', msg: /address is required/ },
+  { ...defaults, address: undefined, msg: /address is required/ },
+  { ...defaults, address: '1.x.2.3', msg: /address must be IPv4/ },
+  { ...defaults, address: '.1.2.3', msg: /address must be IPv4/ },
+  { ...defaults, type: '', msg: /type is required/ },
+  { ...defaults, type: undefined, msg: /type is required/ },
+  { ...defaults, ttl: '', msg: /TTL must be numeric/ },
+  { ...defaults, ttl: -299, msg: /TTL must be a 32-bit integer/ },
+  { ...defaults, ttl: 2147483648, msg: /TTL must be a 32-bit integer/ },
+]
+
+// copy invalid properties to a valid object
+for (let i = 0; i < invalidRecords.length; i++) {
+  const temp = JSON.parse(JSON.stringify(validRecords[0]))
+  Object.assign(temp, invalidRecords[i])
+  invalidRecords[i] = temp
+}
+
+describe('A record', function () {
+  base.valid(A, validRecords)
+  base.invalid(A, invalidRecords)
+
+  base.getDescription(A)
+  base.getRFCs(A, validRecords[0])
+  base.getRdataFields(A, ['address'])
+  base.getFields(A, ['address'])
+  base.getTypeId(A, 1)
+
+  base.toBind(A, validRecords)
+  base.toTinydns(A, validRecords)
+
+  base.fromBind(A, validRecords)
+  base.fromTinydns(A, validRecords)
+})

package/test/aaaa.js

@@ -0,0 +1,86 @@
+import assert from 'assert'
+
+import * as base from './base.js'
+import AAAA from '../rr/aaaa.js'
+
+const defaults = { class: 'IN', ttl: 3600, type: 'AAAA' }
+
+const validRecords = [
+  {
+    ...defaults,
+    owner: 'test.example.com.',
+    address: '2001:0db8:0020:000a:0000:0000:0000:0004',
+    testB: 'test.example.com.\t3600\tIN\tAAAA\t2001:db8:20:a::4\n',
+    testT:
+      ':test.example.com:28:\\040\\001\\015\\270\\000\\040\\000\\012\\000\\000\\000\\000\\000\\000\\000\\004:3600::\n',
+  },
+]
+
+const invalidRecords = [
+  {
+    ...defaults,
+    owner: 'test.example.com.',
+    address: '192.0.2.204',
+    msg: /address must be IPv6/,
+  },
+]
+
+describe('AAAA record', function () {
+  base.valid(AAAA, validRecords)
+  base.invalid(AAAA, invalidRecords)
+
+  base.getDescription(AAAA)
+  base.getRFCs(AAAA, validRecords[0])
+  base.getFields(AAAA, ['address'])
+  base.getTypeId(AAAA, 28)
+
+  base.toBind(AAAA, validRecords)
+  base.toTinydns(AAAA, validRecords)
+
+  base.fromBind(AAAA, validRecords)
+  base.fromTinydns(AAAA, validRecords)
+
+  for (const val of validRecords) {
+    it(`imports tinydns AAAA (generic) record (${val.owner})`, async function () {
+      const r = new AAAA({ tinyline: val.testT })
+      if (process.env.DEBUG) console.dir(r)
+      for (const f of ['owner', 'address', 'ttl']) {
+        assert.deepStrictEqual(
+          r.get(f),
+          val[f],
+          `${f}: ${r.get(f)} !== ${val[f]}`,
+        )
+      }
+    })
+  }
+
+  const tests = [
+    { e: '2001:0db8:0020:000a:0000:0000:0000:0004', c: '2001:db8:20:a::4' },
+    { e: '0000:0000:0000:0000:0000:0000:0000:0000', c: '::' },
+    { e: '0000:0000:0000:0000:0000:0000:0000:0001', c: '::1' },
+    { e: '2001:0db8:0000:0000:0000:0000:0002:0001', c: '2001:db8::2:1' },
+    { e: '2001:0db8:0000:0001:0001:0001:0001:0001', c: '2001:db8:0:1:1:1:1:1' },
+    {
+      e: '2001:0DB8:0000:0000:0008:0800:200C:417A',
+      c: '2001:DB8::8:800:200C:417A',
+    },
+  ]
+
+  describe('compress', function () {
+    const r = new AAAA(null)
+    for (const t of tests) {
+      it(`compresses IPv6 address (${t.e})`, function () {
+        assert.equal(r.compress(t.e), t.c)
+      })
+    }
+  })
+
+  describe('expand', function () {
+    const r = new AAAA(null)
+    for (const t of tests) {
+      it(`expands IPv6 address (${t.c})`, function () {
+        assert.equal(r.expand(t.c), t.e)
+      })
+    }
+  })
+})

package/test/base.js

@@ -0,0 +1,148 @@
+import assert from 'assert'
+
+export function valid(type, validRecords, defaults) {
+  describe('valid', function () {
+    for (const val of validRecords) {
+      // console.log(val)
+      it(`parses record: ${val.owner}`, function () {
+        if (defaults) val.default = defaults
+        const r = new type(val)
+        if (defaults) delete val.default
+        if (process.env.DEBUG) console.dir(r)
+
+        for (const k of Object.keys(val)) {
+          if (/^test/.test(k)) continue
+          assert.strictEqual(
+            r.get(k),
+            val[k],
+            `${type.name} ${k} ${r.get(k)} !== ${val[k]}`,
+          )
+        }
+      })
+    }
+  })
+}
+
+export function invalid(type, invalidRecords, defaults) {
+  describe('invalid', function () {
+    for (const inv of invalidRecords) {
+      if (defaults) inv.default = defaults
+      it(`throws on record (${inv.owner})`, function () {
+        assert.throws(
+          () => {
+            new type(inv)
+          },
+          {
+            message: inv.msg,
+          },
+        )
+      })
+    }
+  })
+}
+
+export function toBind(type, validRecords) {
+  describe('toBind', function () {
+    for (const val of validRecords) {
+      it(`exports to BIND: ${val.owner}`, function () {
+        const r = new type(val).toBind()
+        if (process.env.DEBUG) console.dir(r)
+        assert.strictEqual(r, val.testB)
+      })
+    }
+  })
+}
+
+export function toTinydns(type, validRecords) {
+  describe('toTinydns', function () {
+    for (const val of validRecords) {
+      if (val.testT === undefined) continue
+      it(`exports to tinydns: ${val.owner}`, function () {
+        const r = new type(val).toTinydns()
+        if (process.env.DEBUG) console.dir(r)
+        assert.strictEqual(r, val.testT)
+      })
+    }
+  })
+}
+
+export function getDescription(type) {
+  describe('getDescription', function () {
+    const desc = new type(null).getDescription()
+    it(`gets description: ${desc}`, function () {
+      assert.ok(desc)
+    })
+  })
+}
+
+export function getRFCs(type, valid) {
+  describe('getRFCs', function () {
+    const r = new type(null)
+    const rfcs = r.getRFCs()
+    it(`can retrieve RFCs: ${rfcs.join(',')}`, function () {
+      assert.ok(rfcs.length)
+    })
+  })
+}
+
+function checkFromNS(type, validRecords, nsName, nsLineName) {
+  for (const val of validRecords) {
+    const testLine = nsLineName === 'bindline' ? val.testB : val.testT
+    if (testLine == undefined) continue
+    it(`imports ${nsName} record: ${val.owner}`, function () {
+      const r = new type({ [nsLineName]: testLine })
+      if (process.env.DEBUG) console.dir(r)
+      for (const f of r.getFields()) {
+        if (f === 'class') continue
+        let expected = val[f]
+        if (f === 'data' && Array.isArray(expected))
+          expected = expected.join('') // TXT
+        assert.deepStrictEqual(
+          r.get(f),
+          expected,
+          `${f}: ${r.get(f)} !== ${expected}`,
+        )
+      }
+    })
+  }
+}
+
+export function fromTinydns(type, validRecords) {
+  describe('fromTinydns', function () {
+    checkFromNS(type, validRecords, 'tinydns', 'tinyline')
+  })
+}
+
+export function fromBind(type, validRecords) {
+  describe('fromBind', function () {
+    checkFromNS(type, validRecords, 'BIND', 'bindline')
+  })
+}
+
+export function getRdataFields(type, rdataFields) {
+  describe('getRdataFields', function () {
+    const r = new type(null)
+    it(`can retrieve rdata fields: (${r.getRdataFields('rdata')})`, function () {
+      assert.deepEqual(r.getRdataFields('rdata'), rdataFields)
+    })
+  })
+}
+
+export function getFields(type, rdataFields) {
+  describe('getFields', function () {
+    const r = new type(null)
+    it(`can retrieve record fields`, function () {
+      assert.deepEqual(r.getFields('rdata'), rdataFields)
+      assert.deepEqual(r.getFields(), r.getFields('common').concat(rdataFields))
+    })
+  })
+}
+
+export function getTypeId(type, val) {
+  describe('getTypeId', function () {
+    const r = new type(null)
+    it(`can retrieve record type ID (${r.getTypeId()})`, function () {
+      assert.deepEqual(r.getTypeId(), val)
+    })
+  })
+}

package/test/caa.js

@@ -0,0 +1,111 @@
+import assert from 'assert'
+
+import * as base from './base.js'
+
+import CAA from '../rr/caa.js'
+
+const validRecords = [
+  {
+    owner: 'ns1.example.com.',
+    ttl: 3600,
+    class: 'IN',
+    type: 'CAA',
+    flags: 0,
+    tag: 'issue',
+    value: 'http://letsencrypt.org',
+    testB: `ns1.example.com.\t3600\tIN\tCAA\t0\tissue\t"http://letsencrypt.org"\n`,
+    testT:
+      ':ns1.example.com:257:\\000\\005issue"http\\072\\057\\057letsencrypt.org":3600::\n',
+  },
+  {
+    owner: 'ns2.example.com.',
+    ttl: 3600,
+    class: 'IN',
+    type: 'CAA',
+    flags: 0,
+    tag: 'issue',
+    value: 'mailto:lets-crypt.org',
+    testB: `ns2.example.com.\t3600\tIN\tCAA\t0\tissue\t"mailto:lets-crypt.org"\n`,
+    testT:
+      ':ns2.example.com:257:\\000\\005issue"mailto\\072lets-crypt.org":3600::\n',
+  },
+  {
+    owner: 'example.net.',
+    ttl: 86400,
+    type: 'CAA',
+    flags: 0,
+    tag: 'issuewild',
+    value: 'https://letsencrypt.org',
+    testB:
+      'example.net.\t86400\tIN\tCAA\t0\tissuewild\t"https://letsencrypt.org"\n',
+    testT:
+      ':example.net:257:\\000\\011issuewild"https\\072\\057\\057letsencrypt.org":86400::\n',
+  },
+  {
+    owner: 'certs.example.com.',
+    ttl: 86400,
+    type: 'CAA',
+    flags: 0,
+    tag: 'issue',
+    value: 'ca1.example.net',
+    testB: 'certs.example.com.\t86400\tIN\tCAA\t0\tissue\t"ca1.example.net"\n',
+    testT: ':certs.example.com:257:\\000\\005issue"ca1.example.net":86400::\n',
+  },
+]
+
+const invalidRecords = [
+  {
+    owner: 'example.com.',
+    type: 'CAA',
+    flags: 128,
+    tag: 'iodef',
+    value: 'letsencrypt.org', // missing iodef prefix
+    msg: /RFC/,
+  },
+  {
+    owner: 'example.com.',
+    type: 'CAA',
+    flags: 128,
+    tag: 'invalid', // invalid
+    value: 'http://letsencrypt.org',
+    msg: /RFC/,
+  },
+  {
+    owner: 'example.com.',
+    type: 'CAA',
+    flags: 15, // invalid
+    tag: 'issue',
+    value: 'http://letsencrypt.org',
+    msg: /RFC/,
+  },
+]
+
+describe('CAA record', function () {
+  base.valid(CAA, validRecords)
+  base.invalid(CAA, invalidRecords, { ttl: 3600 })
+
+  base.getDescription(CAA)
+  base.getRFCs(CAA, validRecords[0])
+  base.getFields(CAA, ['flags', 'tag', 'value'])
+  base.getTypeId(CAA, 257)
+
+  base.toBind(CAA, validRecords)
+  base.toTinydns(CAA, validRecords)
+
+  base.fromBind(CAA, validRecords)
+  base.fromTinydns(CAA, validRecords)
+
+  for (const val of validRecords) {
+    it(`imports tinydns CAA (generic) record`, async function () {
+      const r = new CAA({ tinyline: val.testT })
+      if (process.env.DEBUG) console.dir(r)
+      for (const f of ['owner', 'flags', 'tag', 'value', 'ttl']) {
+        assert.deepStrictEqual(
+          r.get(f),
+          val[f],
+          `${f}: ${r.get(f)} !== ${val[f]}`,
+        )
+      }
+    })
+  }
+})