@aoxborrow/registrar-client 0.9.0 → 0.9.1

package/README.md

@@ -425,6 +425,35 @@ sandbox (Name.com offers no domain deletion/reset there); it is excluded from th
 default offline suite. Transfer completion and production behavior need separate
 verification; sandbox transfers are not deterministic.
 
+## DNS record syntax
+
+Pure functions for checking DNS record syntax and putting records in one
+canonical form, with no network calls, so a UI can validate what someone types
+before it reaches a registrar.
+
+```ts
+import { findCnameConflicts, prepareEntry, toDnsEntry } from '@aoxborrow/registrar-client';
+
+// throws DnsSyntaxError with a message safe to show a person
+prepareEntry(toDnsEntry({ type: 'MX', name: '@', value: 'Mail.Example.net.', priority: 10 }));
+// → { owner: '@', kind: 'MX', ttl: 3600, rdata: '10 mail.example.net' }
+
+findCnameConflicts(records.map(r => toDnsEntry(r))); // [{ owner, kind, detail }]
+```
+
+- Names are folded to lowercase with one trailing dot removed, and are never
+  joined to a zone: `www` and `www.example.com` are different owners, and `@`
+  stays `@`. Underscore labels (`_dmarc`) and one leftmost `*` are allowed.
+- Data syntax is checked for A, AAAA, CNAME, NS, MX (including null MX), TXT,
+  SRV, CAA and DS. Any other type is trimmed and passed through, so a
+  provider-specific type still round-trips.
+- `findCnameConflicts` and `findRepeatedRecords` check a whole set of records.
+- `toDnsEntry` adapts a `DnsRecord` (separate MX/SRV number fields) to the
+  entry shape the checks take.
+
+These are DNS rules only. Each provider still applies its own limits, such as
+a minimum TTL or the record types it accepts.
+
 ## Sandbox environments
 
 Providers that offer a test environment accept `{ environment: 'sandbox' }` at

package/dist/index.cjs

@@ -2238,20 +2238,32 @@ function fromRecord(raw) {
   if (raw.type === "MX") {
     const match = /^(\d+)\s+(.+)$/.exec(raw.value);
     if (!match) throw invalid("MX record");
-    return { ...common, value: match[2], priority: Number(match[1]) };
+    return { ...common, value: canonicalValue("MX", match[2]), priority: Number(match[1]) };
   }
   if (raw.type === "SRV") {
     const match = /^(\d+)\s+(\d+)\s+(\d+)\s+(.+)$/.exec(raw.value);
     if (!match) throw invalid("SRV record");
     return {
       ...common,
-      value: match[4],
+      value: canonicalValue("SRV", match[4]),
       priority: Number(match[1]),
       weight: Number(match[2]),
       port: Number(match[3])
     };
   }
-  return { ...common, value: raw.value };
+  return { ...common, value: canonicalValue(raw.type, raw.value) };
+}
+function canonicalValue(type, value) {
+  const kind = type.toUpperCase();
+  if (kind === "TXT") return unquoteTxt(value);
+  if (["CNAME", "NS", "MX", "SRV"].includes(kind))
+    return value === "." ? "." : value.replace(/\.$/, "");
+  return value;
+}
+function unquoteTxt(value) {
+  const chunk = /"((?:[^"\\]|\\.)*)"/g;
+  if (!/^\s*"(?:[^"\\]|\\.)*"(?:\s+"(?:[^"\\]|\\.)*")*\s*$/.test(value)) return value;
+  return [...value.matchAll(chunk)].map((m) => m[1].replace(/\\(.)/g, "$1")).join("");
 }
 function recordSpec(record, domain, strict = true) {
   const type = record.type.toUpperCase();
@@ -2272,7 +2284,7 @@ function recordSpec(record, domain, strict = true) {
     if (!Number.isInteger(record.priority) || record.priority < 0 || record.priority > 65535)
       reject("MX/SRV priority is required");
     result.priority = record.priority;
-    result.target = record.value;
+    result.target = canonicalValue(type, record.value);
     if (type === "SRV") {
       if (![record.weight, record.port].every((n) => Number.isInteger(n) && n >= 0 && n <= 65535))
         reject("SRV weight and port are required");
@@ -2289,7 +2301,7 @@ function recordSpec(record, domain, strict = true) {
       result.tag = match[2];
       result.value = match[3];
     }
-  } else result.value = record.value;
+  } else result.value = canonicalValue(type, record.value);
   return result;
 }
 function recordSignature(record) {
@@ -8006,6 +8018,330 @@ function createRegistrar(name, credentials, options) {
   return new RegistrarClass(credentials, options);
 }
 
+// src/dns-records.ts
+var DnsSyntaxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DnsSyntaxError";
+  }
+};
+var NAME_LIMIT = 253;
+var LABEL_LIMIT = 63;
+var TTL_LIMIT = 2147483647;
+var TEXT_OCTETS = 255;
+var TEXT_TOTAL_OCTETS = 65535 - Math.ceil(65535 / (TEXT_OCTETS + 1));
+var UINT16_MAX = 65535;
+var DIGEST_HEX_LENGTH = {
+  1: 40,
+  2: 64,
+  3: 64,
+  4: 96
+};
+var KINDS_ALLOWED_BESIDE_CNAME = /* @__PURE__ */ new Set(["CNAME", "RRSIG", "NSEC", "NSEC3"]);
+function mapAsciiLabel(label) {
+  const folded = label.toLowerCase();
+  if (folded.length < 1 || folded.length > LABEL_LIMIT) return null;
+  if (!/^[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?$/.test(folded)) return null;
+  return folded;
+}
+var labelMapper = mapAsciiLabel;
+function useLabelMapper(mapper) {
+  labelMapper = mapper;
+}
+function resetLabelMapper() {
+  labelMapper = mapAsciiLabel;
+}
+function prepareName(input, role = "owner") {
+  const trimmed = input.trim();
+  if (!trimmed) throw new DnsSyntaxError("Name is empty");
+  const bare = trimmed.endsWith(".") ? trimmed.slice(0, -1) : trimmed;
+  if (!bare) throw new DnsSyntaxError("Name is empty");
+  if (bare === "@") {
+    if (role === "target") throw new DnsSyntaxError("Origin token @ cannot be a record target");
+    return "@";
+  }
+  const labels = bare.split(".");
+  if (labels.some((label) => label.length === 0)) {
+    throw new DnsSyntaxError("Name contains an empty label");
+  }
+  const starLabels = labels.filter((label) => label.includes("*"));
+  if (starLabels.length > 0) {
+    if (role !== "owner") {
+      throw new DnsSyntaxError("A wildcard is only valid as an owner name");
+    }
+    const starCount = starLabels.reduce(
+      (count, label) => count + (label.match(/\*/g)?.length ?? 0),
+      0
+    );
+    if (starCount > 1) throw new DnsSyntaxError("A name can contain only one wildcard");
+    if (labels[0] !== "*") throw new DnsSyntaxError("A wildcard must be its own leftmost label");
+  }
+  const mapped = labels.map((label) => {
+    if (label === "*") return "*";
+    const ascii = labelMapper(label);
+    if (!ascii) throw new DnsSyntaxError(`Label is not a valid DNS label: ${label}`);
+    return ascii.toLowerCase();
+  });
+  const name = mapped.join(".");
+  if (name.length > NAME_LIMIT) throw new DnsSyntaxError("Name is longer than 253 characters");
+  return name;
+}
+function isIpv4(text2) {
+  const octets = text2.split(".");
+  if (octets.length !== 4) return false;
+  return octets.every((octet) => {
+    if (!/^\d{1,3}$/.test(octet)) return false;
+    const value = Number(octet);
+    return value >= 0 && value <= 255 && String(value) === octet;
+  });
+}
+function isIpv6(text2) {
+  let body = text2;
+  const embedded = text2.match(/^(.+):(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
+  if (embedded) {
+    if (!isIpv4(embedded[2])) return false;
+    body = `${embedded[1]}:0:0`;
+  }
+  const compressedAt = body.indexOf("::");
+  if (compressedAt !== -1) {
+    if (body.indexOf("::", compressedAt + 1) !== -1) return false;
+    const groupsOf = (side) => side === "" ? [] : side.split(":");
+    const head = groupsOf(body.slice(0, compressedAt));
+    const tail = groupsOf(body.slice(compressedAt + 2));
+    if (head.length + tail.length > 7) return false;
+    return [...head, ...tail].every((group) => /^[0-9a-fA-F]{1,4}$/.test(group));
+  }
+  const groups = body.split(":");
+  return groups.length === 8 && groups.every((group) => /^[0-9a-fA-F]{1,4}$/.test(group));
+}
+function utf8OctetCount(text2) {
+  let count = 0;
+  for (const char of text2) {
+    const code = char.codePointAt(0) ?? 0;
+    if (code <= 127) count += 1;
+    else if (code <= 2047) count += 2;
+    else if (code <= 65535) count += 3;
+    else count += 4;
+  }
+  return count;
+}
+function decimalInRange(token, limit) {
+  if (!/^(0|[1-9][0-9]*)$/.test(token)) return null;
+  const value = Number(token);
+  if (value > limit) return null;
+  return value;
+}
+function prepareIpv4(text2) {
+  if (!isIpv4(text2)) throw new DnsSyntaxError("IPv4 address is invalid");
+  return text2;
+}
+function prepareIpv6(text2) {
+  if (!isIpv6(text2)) throw new DnsSyntaxError("IPv6 address is invalid");
+  return text2.toLowerCase();
+}
+function prepareHostTarget(text2, owner, rejectSelf) {
+  const withoutDot = text2.endsWith(".") ? text2.slice(0, -1) : text2;
+  if (isIpv4(withoutDot) || isIpv6(withoutDot)) {
+    throw new DnsSyntaxError("Target must be a domain name, not an address");
+  }
+  const target = prepareName(text2, "target");
+  if (rejectSelf && owner !== void 0 && prepareName(owner, "owner") === target) {
+    throw new DnsSyntaxError("CNAME target is the same name as its owner");
+  }
+  return target;
+}
+function prepareMailExchange(text2) {
+  const parts = text2.split(/\s+/);
+  if (parts.length !== 2) {
+    throw new DnsSyntaxError('MX data must be "<priority> <mail host>"');
+  }
+  const priority = decimalInRange(parts[0], UINT16_MAX);
+  if (priority === null) throw new DnsSyntaxError("MX priority must be an integer from 0 to 65535");
+  return `${priority} ${prepareServiceHost(parts[1])}`;
+}
+function prepareServiceHost(text2) {
+  return text2 === "." ? "." : prepareHostTarget(text2, void 0, false);
+}
+function prepareService(text2) {
+  const parts = text2.split(/\s+/);
+  if (parts.length !== 4) {
+    throw new DnsSyntaxError('SRV data must be "<priority> <weight> <port> <target>"');
+  }
+  const [priority, weight, port] = parts.slice(0, 3).map((part) => decimalInRange(part, UINT16_MAX));
+  if (priority === null)
+    throw new DnsSyntaxError("SRV priority must be an integer from 0 to 65535");
+  if (weight === null) throw new DnsSyntaxError("SRV weight must be an integer from 0 to 65535");
+  if (port === null) throw new DnsSyntaxError("SRV port must be an integer from 0 to 65535");
+  return `${priority} ${weight} ${port} ${prepareServiceHost(parts[3])}`;
+}
+function prepareAuthorization(text2) {
+  const match = /^(\S+)\s+(\S+)\s+([\s\S]+)$/.exec(text2);
+  if (!match) throw new DnsSyntaxError('CAA data must be "<flags> <tag> <value>"');
+  const flags = decimalInRange(match[1], 255);
+  if (flags === null) throw new DnsSyntaxError("CAA flags must be an integer from 0 to 255");
+  if (!/^[a-z0-9]{1,15}$/i.test(match[2])) {
+    throw new DnsSyntaxError("CAA tag must be 1 to 15 letters or digits");
+  }
+  const quoted = /^"((?:[^"\\]|\\.)*)"$/.exec(match[3]);
+  const value = quoted ? quoted[1] : match[3];
+  if (!quoted && value.includes('"')) {
+    throw new DnsSyntaxError("CAA value must be one quoted or unquoted string");
+  }
+  return `${flags} ${match[2].toLowerCase()} "${value}"`;
+}
+function prepareText(text2) {
+  if (utf8OctetCount(text2) > TEXT_TOTAL_OCTETS) {
+    throw new DnsSyntaxError(`TXT data is longer than ${TEXT_TOTAL_OCTETS} octets`);
+  }
+  return text2;
+}
+function readSignerFields(text2) {
+  const parts = text2.trim().split(/\s+/);
+  if (parts.length !== 4)
+    throw new DnsSyntaxError('DS data must be "<key tag> <algorithm> <digest type> <digest>"');
+  const keyTag = decimalInRange(parts[0], UINT16_MAX);
+  const algorithm = decimalInRange(parts[1], 255);
+  const digestType = decimalInRange(parts[2], 255);
+  if (keyTag === null || algorithm === null || digestType === null || !parts[3]) {
+    throw new DnsSyntaxError('DS data must be "<key tag> <algorithm> <digest type> <digest>"');
+  }
+  const digest = parts[3].toLowerCase();
+  if (!/^[0-9a-f]+$/.test(digest)) throw new DnsSyntaxError("DS digest must be hexadecimal");
+  const expectedLength = DIGEST_HEX_LENGTH[digestType];
+  if (expectedLength !== void 0 && digest.length !== expectedLength) {
+    throw new DnsSyntaxError(
+      `DS digest must be ${expectedLength} hex characters for digest type ${digestType}`
+    );
+  }
+  return { keyTag, algorithm, digestType, digest };
+}
+function readDelegationSigner(rdata) {
+  return readSignerFields(rdata);
+}
+function prepareSignerText(text2) {
+  const signer = readSignerFields(text2);
+  return `${signer.keyTag} ${signer.algorithm} ${signer.digestType} ${signer.digest}`;
+}
+function prepareRdata(kind, rdata, owner) {
+  const token = kind.trim().toUpperCase();
+  const text2 = rdata.trim();
+  if (!text2) throw new DnsSyntaxError("Record data is empty");
+  switch (token) {
+    case "A":
+      return prepareIpv4(text2);
+    case "AAAA":
+      return prepareIpv6(text2);
+    case "CNAME":
+      return prepareHostTarget(text2, owner, true);
+    case "NS":
+      return prepareHostTarget(text2, void 0, false);
+    case "MX":
+      return prepareMailExchange(text2);
+    case "TXT":
+      return prepareText(text2);
+    case "SRV":
+      return prepareService(text2);
+    case "CAA":
+      return prepareAuthorization(text2);
+    case "DS":
+      return prepareSignerText(text2);
+    default:
+      return text2;
+  }
+}
+function prepareEntry(entry) {
+  if (!Number.isInteger(entry.ttl) || entry.ttl < 0 || entry.ttl > TTL_LIMIT) {
+    throw new DnsSyntaxError("TTL must be an integer from 0 to 2147483647");
+  }
+  const kind = entry.kind.trim().toUpperCase();
+  if (!kind) throw new DnsSyntaxError("Record type is empty");
+  return {
+    owner: prepareName(entry.owner, "owner"),
+    kind,
+    ttl: entry.ttl,
+    rdata: prepareRdata(kind, entry.rdata, entry.owner)
+  };
+}
+function syntaxClash(entry, error) {
+  const detail = error instanceof Error ? error.message : "Invalid record";
+  return { owner: entry.owner, kind: entry.kind, detail };
+}
+function findCnameConflicts(entries) {
+  const clashes = [];
+  const byOwner = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    let owner;
+    let kind;
+    try {
+      owner = prepareName(entry.owner, "owner");
+      kind = entry.kind.trim().toUpperCase();
+      if (!kind) throw new DnsSyntaxError("Record type is empty");
+    } catch (error) {
+      clashes.push(syntaxClash(entry, error));
+      continue;
+    }
+    const group = byOwner.get(owner) ?? [];
+    group.push({ ...entry, owner, kind });
+    byOwner.set(owner, group);
+  }
+  for (const [owner, group] of byOwner) {
+    const aliasCount = group.filter((entry) => entry.kind === "CNAME").length;
+    if (aliasCount === 0) continue;
+    if (aliasCount > 1) {
+      clashes.push({
+        owner,
+        kind: "CNAME",
+        detail: "A name can have only one CNAME target"
+      });
+    }
+    const others = [...new Set(group.map((entry) => entry.kind))].filter(
+      (kind) => !KINDS_ALLOWED_BESIDE_CNAME.has(kind)
+    );
+    if (others.length > 0) {
+      clashes.push({
+        owner,
+        kind: "CNAME",
+        detail: `A CNAME cannot share a name with ${others.join(", ")}`
+      });
+    }
+  }
+  return clashes;
+}
+function findRepeatedRecords(entries) {
+  const clashes = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    let prepared;
+    try {
+      prepared = prepareEntry(entry);
+    } catch (error) {
+      clashes.push(syntaxClash(entry, error));
+      continue;
+    }
+    if (prepared.kind === "CNAME") continue;
+    const key = `${prepared.owner}\0${prepared.kind}\0${prepared.rdata}`;
+    if (seen.has(key)) {
+      clashes.push({
+        owner: prepared.owner,
+        kind: prepared.kind,
+        detail: `Repeated ${prepared.kind} data at this name`
+      });
+    }
+    seen.add(key);
+  }
+  return clashes;
+}
+function toDnsEntry(record, defaultTtl = 3600) {
+  const kind = record.type.trim().toUpperCase();
+  const numbers = kind === "MX" ? [record.priority] : kind === "SRV" ? [record.priority, record.weight, record.port] : [];
+  return {
+    owner: record.name,
+    kind,
+    ttl: record.ttl ?? defaultTtl,
+    rdata: [...numbers.map((n) => n === void 0 ? "" : String(n)), record.value.trim()].join(" ")
+  };
+}
+
 exports.ALL_FEATURES = ALL_FEATURES;
 exports.AbortError = AbortError;
 exports.AuthenticationError = AuthenticationError;
@@ -8017,6 +8353,7 @@ exports.ConfigurationError = ConfigurationError;
 exports.ConnectionError = ConnectionError;
 exports.ConsentRequiredError = ConsentRequiredError;
 exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.DnsSyntaxError = DnsSyntaxError;
 exports.Domain101Registrar = Domain101Registrar;
 exports.DynadotRegistrar = DynadotRegistrar;
 exports.EXTENDED_FEATURES = EXTENDED_FEATURES;
@@ -8050,19 +8387,30 @@ exports.createDomain = createDomain;
 exports.createRegistrar = createRegistrar;
 exports.ensureArray = ensureArray;
 exports.filterDomains = filterDomains;
+exports.findCnameConflicts = findCnameConflicts;
+exports.findRepeatedRecords = findRepeatedRecords;
 exports.isCoreFeature = isCoreFeature;
+exports.isIpv4 = isIpv4;
+exports.isIpv6 = isIpv6;
 exports.listPortfolio = listPortfolio;
 exports.markNotSent = markNotSent;
 exports.normalizeDomain = normalizeDomain;
 exports.normalizeNameservers = normalizeNameservers;
 exports.parseDate = parseDate;
 exports.parseXml = parseXml;
+exports.prepareEntry = prepareEntry;
+exports.prepareName = prepareName;
+exports.prepareRdata = prepareRdata;
+exports.readDelegationSigner = readDelegationSigner;
 exports.registrars = registrars;
 exports.requireConsent = requireConsent;
+exports.resetLabelMapper = resetLabelMapper;
 exports.selectBaseUrl = selectBaseUrl;
 exports.settableForwards = settableForwards;
 exports.sleep = sleep;
+exports.toDnsEntry = toDnsEntry;
 exports.toRegistrarError = toRegistrarError;
+exports.useLabelMapper = useLabelMapper;
 exports.wasNotSent = wasNotSent;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map