@nictool/dns-resource-record 1.2.1 → 1.2.2

package/.codeclimate.yml

@@ -0,0 +1,25 @@
+checks:
+  return-statements:
+    enabled: false
+  similar-code:
+    enabled: false
+  file-lines:
+    config:
+      threshold: 500
+  method-lines:
+    config:
+      threshold: 50
+  method-complexity:
+    config:
+      threshold: 10
+
+plugins:
+  eslint:
+    enabled: true
+    channel: 'eslint-8'
+    config:
+      config: '.eslintrc.yaml'
+
+ratings:
+  paths:
+    - '**.js'

package/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: msimerson

package/.github/workflows/ci.yml

@@ -0,0 +1,43 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+env:
+  CI: true
+
+jobs:
+  lint:
+    uses: NicTool/.github/.github/workflows/lint.yml@main
+
+  coverage:
+    uses: NicTool/.github/.github/workflows/coverage.yml@main
+    secrets: inherit
+
+  test:
+    needs: get-lts
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        node-version: ${{ fromJson(needs.get-lts.outputs.active) }}
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        name: Node ${{ matrix.node-version }} on ${{ matrix.os }}
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm install
+      - run: npm test
+
+  get-lts:
+    needs: lint
+    runs-on: ubuntu-latest
+    steps:
+      - id: get
+        uses: msimerson/node-lts-versions@v1
+    outputs:
+      lts: ${{ steps.get.outputs.lts }}
+      active: ${{ steps.get.outputs.active }}

package/.github/workflows/codeql.yml

@@ -0,0 +1,14 @@
+name: CodeQL
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [main]
+  schedule:
+    - cron: '18 7 * * 4'
+
+jobs:
+  codeql:
+    uses: NicTool/.github/.github/workflows/codeql.yml@main

package/.github/workflows/publish.yml

@@ -0,0 +1,16 @@
+name: publish
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - package.json
+
+env:
+  CI: true
+
+jobs:
+  publish:
+    uses: NicTool/.github/.github/workflows/publish.yml@main
+    secrets: inherit

package/.gitmodules

@@ -0,0 +1,3 @@
+[submodule ".release"]
+	path = .release
+	url = https://github.com/msimerson/.release

package/.prettierrc.yml

@@ -0,0 +1,3 @@
+trailingComma: 'all'
+semi: false
+singleQuote: true

package/CHANGELOG.md

@@ -4,6 +4,12 @@ Notable changes to this project are documented in this file.
 
 #### Unreleased
 
+### [1.2.2] - 2024-11-17
+
+- dep(eslint): update to v9 & config
+- chore: tighten up fromBind regex
+- packaging tweaks (#43)
+
 ### [1.2.1] - 2024-03-10
 
 - fix(nsec3param): fixed setHash fname typo
@@ -295,3 +301,6 @@ Notable changes to this project are documented in this file.
 [1.1.6]: https://github.com/NicTool/dns-resource-record/releases/tag/1.1.6
 [1.1.8]: https://github.com/NicTool/dns-resource-record/releases/tag/1.1.8
 [1.2.1]: https://github.com/NicTool/dns-resource-record/releases/tag/1.2.1
+[1.2.2]: https://github.com/NicTool/dns-resource-record/releases/tag/v1.2.2
+[1.1.7]: https://github.com/NicTool/dns-resource-record/releases/tag/1.1.7
+[1.2.0]: https://github.com/NicTool/dns-resource-record/releases/tag/1.2.0

package/DEVELOP.md

@@ -0,0 +1,9 @@
+# Release process
+
+In your local repo:
+
+```sh
+git submodule update --init --recursive
+```
+
+Read and follow the instructions in .release/README.md

package/README.md

@@ -20,7 +20,7 @@ This module is used to:
 |                       **MaraDNS**                        |                    | :white_check_mark: |
 |                          **JS**                          | :white_check_mark: | :white_check_mark: |
 
-This package intends to import and export RFC compliant DNS resource records. Please [raise an issue](https://github.com/NicTool/dns-resource-record/issues) if you a valid resource record fails to pass or an invalid resource record passes.
+This package intends to import and export RFC compliant DNS resource records. Please [raise an issue](https://github.com/NicTool/dns-resource-record/issues) if a valid resource record fails to pass or an invalid resource record passes.
 
 This package is for working with _individual_ Resource Records. For working with zones of RRs, use [dns-zone](https://github.com/NicTool/dns-zone).
 
@@ -239,6 +239,8 @@ PRs are welcome, especially PRs with tests.
 
 - [Dictionary of DNS terms](https://nictool.github.io/web/Dictionary)
 - [Wikipedia, List of DNS Record Types](https://en.wikipedia.org/wiki/List_of_DNS_record_types)
+- @nictool/[dns-zone](https://www.npmjs.com/package/@nictool/dns-zone)
+- @nictool/[dns-nameserver](https://www.npmjs.com/package/@nictool/dns-nameserver)
 
 ## TODO
 

package/eslint.config.mjs

@@ -0,0 +1,41 @@
+import globals from 'globals'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import js from '@eslint/js'
+import { FlatCompat } from '@eslint/eslintrc'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all,
+})
+
+export default [
+  {
+    languageOptions: {
+      ecmaVersion: 'latest',
+      globals: {
+        ...globals.node,
+        ...globals.browser,
+        ...globals.mocha,
+      },
+      sourceType: 'module',
+    },
+
+    rules: {
+      // 'no-undef': [ 'warn' ],
+      'no-unused-vars': [
+        'error',
+        {
+          args: 'none',
+        },
+      ],
+
+      'dot-notation': 'error',
+      'prefer-const': 'warn',
+    },
+  },
+  js.configs.recommended,
+]

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "@nictool/dns-resource-record",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "DNS Resource Records",
   "main": "index.js",
+  "file": [
+    "lib",
+    "rr",
+    "CHANGELOG.md",
+    "rr.js"
+  ],
   "type": "module",
   "scripts": {
     "format:check": "npm run prettier; npm run lint",
     "format": "npm run prettier -- --write && npm run lint --fix",
-    "lint": "npx eslint **/*.js",
+    "lint": "npx eslint@9 **/*.js",
     "lint:fix": "npm run lint -- --fix",
     "prettier": "npx prettier --ignore-path .gitignore --check .",
     "prettier:fix": "npx prettier --ignore-path .gitignore --write .",
@@ -39,6 +45,9 @@
   },
   "homepage": "https://github.com/NicTool/dns-resource-record#readme",
   "devDependencies": {
-    "mocha": "^10.3.0"
+    "@eslint/js": "^9.15.0",
+    "eslint": "^9.15.0",
+    "globals": "^15.12.0",
+    "mocha": "^10.8.2"
   }
 }

package/rr/caa.js

@@ -108,9 +108,11 @@ export default class CAA extends RR {
 
   fromBind(opts) {
     // test.example.com  3600  IN  CAA flags, tags, value
-    const fields = opts.bindline.match(
-      /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+(\w+)\s+("[^"]+"|[^\s]+?)\s*$/i,
-    )
+    const fields = opts.bindline
+      .trim()
+      .match(
+        /^([\S]+)\s+([0-9]{1,10})\s+(IN)\s+(CAA)\s+([0-9]+)\s+(\w+)\s+("[^"]+"|[\S]+?)$/i,
+      )
     if (!fields) this.throwHelp(`unable to parse: ${opts.bindline}`)
 
     const [owner, ttl, c, type, flags, tag, value] = fields.slice(1)

package/rr/hinfo.js

@@ -41,9 +41,11 @@ export default class HINFO extends RR {
   /******  IMPORTERS   *******/
   fromBind(opts) {
     // test.example.com  3600  IN  HINFO   DEC-2060 TOPS20
-    const match = opts.bindline.match(
-      /([^\s]+)\s+([0-9]+)\s+(IN)\s+(HINFO)\s+("[^"]+"|[^\s]+)\s+("[^"]+"|[^\s]+)/i,
-    )
+    const match = opts.bindline
+      .trim()
+      .match(
+        /^([\S]+)\s+([0-9]{1,10})\s+(IN)\s+(HINFO)\s+("[^"]+"|[\S]+)\s+("[^"]+"|[\S]+)/i,
+      )
     if (!match) this.throwHelp(`unable to parse HINFO: ${opts.bindline}`)
     const [owner, ttl, c, type, cpu, os] = match.slice(1)
 

package/rr/openpgpkey.js

@@ -30,9 +30,9 @@ export default class OPENPGPKEY extends RR {
   fromBind(obj) {
     // test.example.com  3600  IN  OPENPGPKEY  <base64 public key>
     // eslint-disable-next-line no-unused-vars
-    const [ignore, owner, ttl, c, type, publickey] = obj.bindline.match(
-      /^([\S]+)\s+(\d+)\s+(\w+)\s+(\w+)\s+([\W\w]*)$/,
-    )
+    const [ignore, owner, ttl, c, type, publickey] = obj.bindline
+      .trim()
+      .match(/^([\S]+)\s+(\d{1,10})\s+(IN)\s+(OPENPGPKEY)\s+([\W\w]*)$/)
 
     return new OPENPGPKEY({
       owner,

package/rr/tlsa.js

@@ -60,9 +60,11 @@ export default class TLSA extends RR {
 
   fromBind(opts) {
     // test.example.com  3600  IN  TLSA, usage, selector, match, data
-    const match = opts.bindline.split(
-      /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+(.*?)\s*$/,
-    )
+    const match = opts.bindline
+      .trim()
+      .split(
+        /^([^\s]+)\s+([0-9]{1,10})\s+(IN)\s+(TLSA)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+(.*?)$/,
+      )
     if (!match) this.throwHelp(`unable to parse TLSA: ${opts.bindline}`)
     const [owner, ttl, c, type, usage, selector, matchtype, cad] =
       match.slice(1)

package/rr/txt.js

@@ -70,9 +70,9 @@ 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*$/,
-    )
+    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)
 

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)
+    })
+  })
+}