@nictool/dns-resource-record 1.8.0 → 1.8.2

package/CHANGELOG.md

@@ -4,6 +4,15 @@ Notable changes to this project are documented in this file.
 
 #### Unreleased
 
+### [1.8.2] - 2026-07-27
+
+- lib/nictool: imported getMap,applyMap,unApplyMap
+- rr/bind: quote character strings in presentation format
+
+### [1.8.1] - 2026-07-25
+
+- rr/bind: merge charstrs for opaque rdata types
+
 ### [1.8.0] - 2026-05-25
 
 - lib/wire.js — hardened readWireName()
@@ -432,3 +441,5 @@ Notable changes to this project are documented in this file.
 [1.6.1]: https://github.com/NicTool/dns-resource-record/releases/tag/v1.6.1
 [1.7.0]: https://github.com/NicTool/dns-resource-record/releases/tag/v1.7.0
 [1.8.0]: https://github.com/NicTool/dns-resource-record/releases/tag/v1.8.0
+[1.8.1]: https://github.com/NicTool/dns-resource-record/releases/tag/v1.8.1
+[1.8.2]: https://github.com/NicTool/dns-resource-record/releases/tag/v1.8.2

package/README.md

@@ -373,7 +373,7 @@ Master zone file expansions (relative domain names) are handled by [dns-zone](ht
 
 The `toBind()` method accepts a zone-options object (typically supplied by
 [dns-zone](https://github.com/NicTool/dns-zone) when emitting full zone files)
-to elide redundant per-record output:
+to omit redundant per-record output:
 
 ```js
 record.toBind({

package/index.js

@@ -1,4 +1,5 @@
 import RR from './rr.js'
+import { registerRdataFormats } from './lib/nictool.js'
 import A from './rr/a.js'
 import AAAA from './rr/aaaa.js'
 import APL from './rr/apl.js'
@@ -90,6 +91,8 @@ for (const c of classes) {
   typeMap[c.typeName] = id
 }
 
+registerRdataFormats(classes)
+
 export {
   A,
   AAAA,
@@ -134,4 +137,6 @@ export {
   typeMap,
 }
 
+export { getMap, applyMap, unApplyMap } from './lib/nictool.js'
+
 export default RR

package/lib/bind.js

@@ -51,8 +51,12 @@ export function parseBindLine(line, RRClasses) {
   return res
 }
 
+function fieldTypeOf(def) {
+  return Array.isArray(def) ? def[1] : null
+}
+
 export function fromBind(rrInstance, opts) {
-  const { owner, ttl, cls, rdata } = opts
+  const { owner, ttl, class: cls, rdata } = opts
   const result = {
     owner,
     ttl,
@@ -62,15 +66,23 @@ export function fromBind(rrInstance, opts) {
 
   const fields = rrInstance.getFields('rdata')
   const rdataDefs = rrInstance.constructor.rdataFields ?? []
+  const opaqueTypes = new Set(['str', 'hex', 'base64'])
   for (let i = 0; i < fields.length; i++) {
     const isLastField = i === fields.length - 1
+
+    // RFC 1035 §5.1: opaque rdata (hex digests, base64 keys) may be split across
+    // whitespace and parenthesized continuations; rejoin it into one value.
+    if (isLastField && opaqueTypes.has(fieldTypeOf(rdataDefs[i]))) {
+      result[fields[i]] = rdata.slice(i).join('')
+      break
+    }
+
     if (isLastField && rrInstance.isQuotedField(fields[i])) {
       // Collect all remaining tokens for TXT/etc
       const tokens = rdata.slice(i).map((s) => s.replace(/^"|"$/g, ''))
       // For `charstrs` (TXT), preserve multi-string boundaries (RFC 1035 §3.3.14).
       // For `qstr`/`qcharstr` (single character-string), join into one string.
-      const def = rdataDefs[i]
-      const fieldType = Array.isArray(def) ? def[1] : null
+      const fieldType = fieldTypeOf(rdataDefs[i])
       result[fields[i]] = fieldType === 'charstrs' && tokens.length > 1 ? tokens : tokens.join('')
       break
     }

package/lib/nictool.js

@@ -0,0 +1,286 @@
+/**
+ * NicTool 2.x storage columns <-> RFC/IETF resource-record field names.
+ *
+ * NicTool stores every record type in the same handful of columns — `address`
+ * holds the rdata, with `weight`, `priority`, `other` and `description` reused
+ * per type — while this library names fields as the RFCs do. These maps
+ * translate between the two, so a record read straight from the NicTool schema
+ * can be handed to the matching RR class and exported with toBind() or
+ * toTinydns().
+ *
+ * Types whose rdata packs several fields into `address` (NAPTR, NSEC3, SOA...)
+ * are unpacked explicitly in unApplyMap.
+ */
+
+/**
+ * Values are arrays for the packed types, so freeze those too. Freezing makes
+ * the caches safe to share: mutating a map is a TypeError under ESM's strict mode
+ */
+function freezeMap(map) {
+  for (const value of Object.values(map)) {
+    if (Array.isArray(value)) Object.freeze(value)
+  }
+  return Object.freeze(map)
+}
+
+// A zone export maps once per record — millions of them for a large install —
+// so build each type's map, and its entries, once.
+const mapCache = new Map()
+const entriesCache = new WeakMap()
+
+function mapEntries(map) {
+  let entries = entriesCache.get(map)
+  if (entries === undefined) {
+    entries = Object.entries(map)
+    entriesCache.set(map, entries)
+  }
+  return entries
+}
+
+export function getMap(rrType) {
+  let map = mapCache.get(rrType)
+  if (map === undefined) {
+    map = freezeMap(mapFor(rrType))
+    mapCache.set(rrType, map)
+  }
+  return map
+}
+
+function mapFor(rrType) {
+  switch (rrType) {
+    case 'CAA':
+      return {
+        weight: 'flags',
+        other: 'tag',
+        address: 'value',
+      }
+    case 'CERT':
+      return {
+        other: 'cert type',
+        priority: 'key tag',
+        weight: 'algorithm',
+        address: 'certificate',
+      }
+    case 'CNAME':
+      return { address: 'cname' }
+    case 'DNAME':
+      return { address: 'target' }
+    case 'DNSKEY':
+      return {
+        address: 'publickey',
+        weight: 'flags',
+        priority: 'protocol',
+        other: 'algorithm',
+      }
+    case 'DS':
+      return {
+        address: 'digest',
+        weight: 'digest type',
+        priority: 'algorithm',
+        other: 'key tag',
+      }
+    case 'HINFO':
+      return { address: 'os', other: 'cpu' }
+    case 'HTTPS':
+      return {
+        address: 'target name',
+        other: 'params',
+      }
+    case 'IPSECKEY':
+      return {
+        address: 'gateway',
+        description: 'publickey',
+        weight: 'precedence',
+        priority: 'gateway type',
+        other: 'algorithm',
+      }
+    case 'KEY':
+      return {
+        address: 'publickey',
+        weight: 'protocol',
+        priority: 'algorithm',
+        other: 'flags',
+      }
+    case 'MX':
+      return { weight: 'preference', address: 'exchange' }
+    case 'NAPTR':
+      return {
+        weight: 'order',
+        priority: 'preference',
+        address: ['flags', 'service', 'regexp'],
+        description: 'replacement',
+      }
+    case 'NS':
+      return { address: 'dname' }
+    case 'NSEC':
+      return {
+        address: 'next domain',
+        description: 'type bit maps',
+      }
+    case 'NSEC3':
+      return {
+        address: ['hash algorithm', 'flags', 'iterations', 'salt', 'type bit maps', 'next hashed owner name'],
+      }
+    case 'NSEC3PARAM':
+      return {
+        address: ['hash algorithm', 'flags', 'iterations', 'salt'],
+      }
+    case 'NXT':
+      return {
+        address: 'next domain',
+        description: 'type bit map',
+      }
+    case 'OPENPGPKEY':
+      return { address: 'public key' }
+    case 'PTR':
+      return { address: 'dname' }
+    case 'SMIMEA':
+      return {
+        address: 'certificate association data',
+        weight: 'matching type',
+        priority: 'selector',
+        other: 'certificate usage',
+      }
+    case 'SOA':
+      return {
+        address: ['mname', 'rname', 'serial', 'refresh', 'retry', 'expire', 'minimum'],
+      }
+    case 'SPF':
+      return { address: 'data' }
+    case 'SSHFP':
+      return {
+        address: 'fingerprint',
+        weight: 'algorithm',
+        priority: 'fptype',
+      }
+    case 'SRV':
+      return { address: 'target', other: 'port' }
+    case 'SVCB':
+      return {
+        address: 'target name',
+        other: 'params',
+      }
+    case 'TLSA':
+      return {
+        weight: 'certificate usage',
+        priority: 'selector',
+        address: 'certificate association data',
+        other: 'matching type',
+      }
+    case 'TXT':
+      return { address: 'data' }
+    case 'URI':
+      return { address: 'target' }
+    default:
+      // Types NicTool stores without column overloading need no translation.
+      return {}
+  }
+}
+
+export function applyMap(obj, map) {
+  // map dns-r-r (RFC/IETF) field names to NicTool 2.0 DB fields
+
+  for (const [key, value] of mapEntries(map)) {
+    if (Array.isArray(value)) {
+      obj[key] = `'${value.map((a) => obj[a]).join("','")}'`
+      for (const f of value) {
+        delete obj[f]
+      }
+      // No `delete obj[value]` here: an array key stringifies to
+      // "flags,service,regexp" and would delete an unrelated property.
+      continue
+    }
+
+    obj[key] = obj[value]
+    delete obj[value]
+  }
+}
+
+// Integers on the wire. `certtype` is numeric but also accepts mnemonics
+// ("PKIX"), so a value is converted only when it actually looks numeric —
+// the declared format alone is not enough.
+const NUMERIC_FORMATS = new Set(['u8', 'u16', 'u32', 'certtype'])
+
+/**
+ * type -> the fields that class declares as integers, from its static
+ * rdataFields. NicTool's `other` column is VARCHAR, so MySQL hands back "1"
+ * where the RR setter demands an integer; `weight` and `priority` are SMALLINT
+ * and only arrive as strings from a file store or hand-edited data.
+ *
+ * Keyed on the type because a bare field name is ambiguous: `flags` is u8 in
+ * CAA, u16 in DNSKEY and a character string in NAPTR.
+ *
+ * Populated by index.js, which is where the classes are already enumerated;
+ * importing them here would close an import cycle.
+ */
+const numericFields = new Map()
+
+export function registerRdataFormats(classes) {
+  for (const rrClass of classes) {
+    const numeric = new Set()
+    for (const entry of rrClass.rdataFields ?? []) {
+      if (Array.isArray(entry) && NUMERIC_FORMATS.has(entry[1])) numeric.add(entry[0])
+    }
+    numericFields.set(rrClass.typeName, numeric)
+  }
+}
+
+export function unApplyMap(obj, map) {
+  // map NicTool 2.0 DB fields to dns-r-r (RFC/IETF) field names
+  let packed = false
+
+  if (obj.type === 'NAPTR') {
+    const [flags, service, regexp] = obj.address.slice(1, -1).split("','")
+    obj.flags = flags ?? ''
+    obj.service = service ?? ''
+    obj.regexp = regexp ?? ''
+    delete obj.address
+    packed = true
+  }
+  if (obj.type === 'NSEC3') {
+    const [algo, flags, iters, salt, bitmaps, next] = obj.address.slice(1, -1).split("','")
+    obj['hash algorithm'] = /^\d+$/.test(algo) ? parseInt(algo, 10) : (algo ?? '')
+    obj.flags = /^\d+$/.test(flags) ? parseInt(flags, 10) : (flags ?? '')
+    obj.iterations = /^\d+$/.test(iters) ? parseInt(iters, 10) : (iters ?? '')
+    obj.salt = salt
+    obj['type bit maps'] = bitmaps
+    obj['next hashed owner name'] = next
+    delete obj.address
+    packed = true
+  }
+  if (obj.type === 'NSEC3PARAM') {
+    const [algo, flags, iters, salt] = obj.address.slice(1, -1).split("','")
+    obj['hash algorithm'] = /^\d+$/.test(algo) ? parseInt(algo, 10) : (algo ?? '')
+    obj.flags = /^\d+$/.test(flags) ? parseInt(flags, 10) : (flags ?? '')
+    obj.iterations = /^\d+$/.test(iters) ? parseInt(iters, 10) : (iters ?? '')
+    obj.salt = salt
+    delete obj.address
+    packed = true
+  }
+  if (obj.type === 'SOA') {
+    const [one, two, three, four, five, six, seven] = obj.address.slice(1, -1).split("','")
+    obj.mname = one
+    obj.rname = two
+    obj.serial = parseInt(three, 10)
+    obj.refresh = parseInt(four, 10)
+    obj.retry = parseInt(five, 10)
+    obj.expire = parseInt(six, 10)
+    obj.minimum = parseInt(seven, 10)
+    delete obj.address
+    packed = true
+  }
+
+  const numeric = numericFields.get(obj.type)
+
+  for (const [key, value] of mapEntries(map)) {
+    if (packed && key === 'address') continue
+    const stored = obj[key]
+    // Only a string can need converting, and skipping the rest keeps the
+    // numeric columns MySQL already types correctly off this path entirely.
+    obj[value] =
+      typeof stored === 'string' && numeric?.has(value) && /^\d+$/.test(stored)
+        ? parseInt(stored, 10)
+        : stored
+    delete obj[key]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nictool/dns-resource-record",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "description": "DNS Resource Records",
   "main": "index.js",
   "exports": {
@@ -71,8 +71,8 @@
   ],
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "eslint": "^10.4.0",
-    "globals": "^17.6.0"
+    "eslint": "^10.8.0",
+    "globals": "^17.8.0"
   },
   "prettier": {
     "printWidth": 110,

package/rr/ds.js

@@ -7,7 +7,12 @@ export default class DS extends RR {
   static typeName = 'DS'
   static typeId = 43
   static RFCs = [4034, 4509, 9619]
-  static rdataFields = [['key tag', 'u16'], 'algorithm', 'digest type', ['digest', 'str']]
+  static rdataFields = [
+    ['key tag', 'u16'],
+    ['algorithm', 'u8'],
+    ['digest type', 'u8'],
+    ['digest', 'str'],
+  ]
   static tags = ['dnssec']
 
   constructor(opts) {

package/rr/ipseckey.js

@@ -8,7 +8,13 @@ export default class IPSECKEY extends RR {
   static typeName = 'IPSECKEY'
   static typeId = 45
   static RFCs = [4025]
-  static rdataFields = ['precedence', 'gateway type', 'algorithm', 'gateway', 'publickey']
+  static rdataFields = [
+    ['precedence', 'u8'],
+    ['gateway type', 'u8'],
+    ['algorithm', 'u8'],
+    'gateway',
+    'publickey',
+  ]
   static tags = ['security']
 
   constructor(opts) {

package/rr/txt.js

@@ -84,7 +84,11 @@ export default class TXT extends RR {
   }
 
   toMaraDNS() {
-    const data = asQuotedStrings(this.get('data')).replace(/"/g, "'")
+    // csv2 quotes with ' and has its own escaping, so the RFC 1035 rules below
+    // are presentation-format only and must not reach the payload. The chunk
+    // delimiter differs too; joining with it beats rewriting quotes after the
+    // fact, which also hit quotes belonging to the payload.
+    const data = asQuotedStrings(this.get('data'), { escape: false, delimiter: "' '" })
     return `${this.get('owner')}\t+${this.get('ttl')}\t${this.get('type')}\t'${data}' ~\n`
   }
 
@@ -125,19 +129,25 @@ export default class TXT extends RR {
   }
 }
 
-function asQuotedStrings(data) {
+// RFC 1035 §5.1: inside a quoted character-string, \ and " are escaped. The
+// 255-byte limit counts wire bytes, so chunk on the unescaped value and escape
+// each chunk afterwards.
+const escapeCharString = (s) => String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+
+function asQuotedStrings(data, { escape = true, delimiter = '" "' } = {}) {
   // RFC 1035 character-strings are 255 bytes max; chunk by UTF-8 bytes,
   // not JS chars, so non-ASCII TXT data doesn't overflow the 255-byte limit.
   const enc = new TextEncoder()
+  const esc = escape ? escapeCharString : (s) => s
 
   if (Array.isArray(data)) {
     const anyTooLong = data.some((s) => enc.encode(s).length > 255)
-    if (!anyTooLong) return data.join('" "')
-    return chunkByBytes(data.join(''), 255).join('" "')
+    if (!anyTooLong) return data.map(esc).join(delimiter)
+    return chunkByBytes(data.join(''), 255).map(esc).join(delimiter)
   }
 
-  if (enc.encode(data).length <= 255) return data
-  return chunkByBytes(data, 255).join('" "')
+  if (enc.encode(data).length <= 255) return esc(data)
+  return chunkByBytes(data, 255).map(esc).join(delimiter)
 }
 
 function chunkByBytes(str, maxBytes) {