ata-validator 1.8.2 → 1.10.0

package/lib/enrich-error.js

@@ -35,6 +35,7 @@ function expectedFor (err) {
     case 'minimum': return err.params && err.params.limit != null ? `≥${err.params.limit}` : undefined;
     case 'maximum': return err.params && err.params.limit != null ? `≤${err.params.limit}` : undefined;
     case 'format': return err.params && err.params.format ? `format '${err.params.format}'` : undefined;
+    case 'pattern': return err.params && err.params.pattern ? `string matching /${err.params.pattern}/` : undefined;
     case 'enum': return err.params && err.params.allowedValues
       ? `one of [${err.params.allowedValues.map(reprValue).join(', ')}]`
       : undefined;
@@ -73,6 +74,59 @@ function pickReceived (err, data) {
  * Pure: returns a new object. Source frames and suggestions are added by
  * other helpers later in the pipeline.
  */
+// Observation-first wording. `message` stays as it is for parity, so this is a
+// separate field a consumer opts into.
+function detailFor (err, out) {
+  const p = err.params || {};
+  switch (err.keyword) {
+    case 'type':
+      return `expected ${p.type}, found ${typeNameOf(out.received)}`;
+    case 'required':
+      return `missing required property "${p.missingProperty}"`;
+    case 'additionalProperties':
+      return `unknown property "${p.additionalProperty}"`;
+    case 'unevaluatedProperties':
+      return `unevaluated property "${p.unevaluatedProperty}"`;
+    case 'enum':
+      return out.expected ? `expected ${out.expected}, found ${out.received}` : undefined;
+    case 'const':
+      return out.expected ? `expected ${out.expected}, found ${out.received}` : undefined;
+    case 'format':
+      return `not a valid ${p.format}: ${out.received}`;
+    case 'minimum': case 'maximum': case 'exclusiveMinimum': case 'exclusiveMaximum':
+      return `expected ${out.expected}, found ${out.received}`;
+    case 'minLength': case 'maxLength':
+      return `expected ${out.expected}, found ${out.received}`;
+    default:
+      return out.expected ? `expected ${out.expected}, found ${out.received}` : undefined;
+  }
+}
+
+// Derived from the repr in `received`, which is already a JSON-ish string.
+function typeNameOf (received) {
+  if (received === undefined) return 'nothing';
+  if (received === 'null') return 'null';
+  if (received === 'true' || received === 'false') return 'boolean';
+  if (received.startsWith('"')) return 'string';
+  if (received.startsWith('[array')) return 'array';
+  if (received.startsWith('{') || received.startsWith('[object')) return 'object';
+  if (/^-?\d/.test(received)) return 'number';
+  return 'value';
+}
+
+// Cause before effect, applied only as a tie-break within one container.
+// Ordering across the document is by position, done in the renderer.
+const RANK = {
+  required: 0, additionalProperties: 0, unevaluatedProperties: 0,
+  unevaluatedItems: 0, dependentRequired: 0, propertyNames: 0,
+  type: 1,
+  oneOf: 3, anyOf: 3, allOf: 3, not: 3,
+};
+function rankFor (keyword) {
+  const r = RANK[keyword];
+  return r === undefined ? 2 : r;
+}
+
 function enrich (rawErr, opts) {
   const data = opts && opts.data;
   const positions = opts && opts.positions;
@@ -129,6 +183,28 @@ function enrich (rawErr, opts) {
   const sugg = suggestFor(out, opts && opts.data);
   if (sugg) out.suggestion = sugg;
 
+  const detail = detailFor(rawErr, out);
+  if (detail !== undefined) out.detail = detail;
+  out.rank = rankFor(keyword);
+
+  // Token-level anchor. `dataFrame` already carries the value span; `anchor`
+  // adds the key span so a caret can sit on the property that is wrong rather
+  // than on the object containing it.
+  if (opts && opts.positions) {
+    const named = (rawErr.params && (rawErr.params.additionalProperty || rawErr.params.unevaluatedProperty)) || null;
+    const own = opts.positions[path];
+    const child = named ? opts.positions[(path === '' ? '' : path) + '/' + named] : null;
+    const src = child || own;
+    if (src) {
+      out.anchor = { line: src.line, col: src.col, length: src.length };
+      if (src.keyOffset !== undefined) {
+        out.anchor.keyLine = src.keyLine;
+        out.anchor.keyCol = src.keyCol;
+        out.anchor.keyLength = src.keyLength;
+      }
+    }
+  }
+
   return out;
 }
 

package/lib/formats.js

@@ -0,0 +1,57 @@
+'use strict';
+
+// Format predicates that read the string once, with no regular expression
+// and no allocation. Each has a twin that emits the same check as source for
+// the code generator; tests/test_formats_single_pass.js holds the two
+// together and fuzzes both against the regular-expression forms they replaced.
+// Measured, interleaved medians: date 45.7 to 14.2 ns, ipv4 54.5 to 27.1 ns.
+// uuid was tried the same way and measured 57.3 against 59.4 ns: V8's regular
+// expression for a fixed-length hex pattern is already that fast, so it stays.
+
+function isDigit (c) { return c >= 48 && c <= 57; }
+
+function date (s) {
+  if (s.length !== 10) return false;
+  for (let i = 0; i < 10; i++) {
+    const c = s.charCodeAt(i);
+    if (i === 4 || i === 7) { if (c !== 45) return false; } else if (!isDigit(c)) return false;
+  }
+  const m = (s.charCodeAt(5) - 48) * 10 + (s.charCodeAt(6) - 48);
+  const d = (s.charCodeAt(8) - 48) * 10 + (s.charCodeAt(9) - 48);
+  return m >= 1 && m <= 12 && d >= 1 && d <= 31;
+}
+
+// Four decimal octets, no leading zeros, no empty octets, nothing else.
+function ipv4 (s) {
+  const n = s.length;
+  if (n < 7 || n > 15) return false;
+  let octets = 0, value = 0, digits = 0;
+  for (let i = 0; i <= n; i++) {
+    const c = i < n ? s.charCodeAt(i) : 46;
+    if (c === 46) {
+      if (digits === 0 || value > 255) return false;
+      octets++; value = 0; digits = 0;
+      if (octets > 4) return false;
+    } else if (isDigit(c)) {
+      if (digits === 1 && value === 0) return false;
+      value = value * 10 + (c - 48); digits++;
+      if (digits > 3) return false;
+    } else return false;
+  }
+  return octets === 4;
+}
+
+// Source twins. `v` is the expression holding the string; when `isStr` is
+// false the check is wrapped in a typeof guard, matching FORMAT_CODEGEN's
+// convention. Each returns a statement that `return false`s on mismatch.
+function guard (v, isStr, body) { return isStr ? `{${body}}` : `if(typeof ${v}==='string'){${body}}`; }
+
+function dateSource (v, isStr) {
+  return guard(v, isStr, `if(${v}.length!==10)return false;for(let _i=0;_i<10;_i++){const _c=${v}.charCodeAt(_i);if(_i===4||_i===7){if(_c!==45)return false}else if(_c<48||_c>57)return false}const _m=(${v}.charCodeAt(5)-48)*10+(${v}.charCodeAt(6)-48),_d=(${v}.charCodeAt(8)-48)*10+(${v}.charCodeAt(9)-48);if(_m<1||_m>12||_d<1||_d>31)return false`);
+}
+
+function ipv4Source (v, isStr) {
+  return guard(v, isStr, `const _n=${v}.length;if(_n<7||_n>15)return false;let _o=0,_val=0,_dg=0;for(let _i=0;_i<=_n;_i++){const _c=_i<_n?${v}.charCodeAt(_i):46;if(_c===46){if(_dg===0||_val>255)return false;_o++;_val=0;_dg=0;if(_o>4)return false}else if(_c>=48&&_c<=57){if(_dg===1&&_val===0)return false;_val=_val*10+(_c-48);_dg++;if(_dg>3)return false}else return false}if(_o!==4)return false`);
+}
+
+module.exports = { date, ipv4, dateSource, ipv4Source };

package/lib/interpreter.js

@@ -247,16 +247,17 @@ function multipleOfOk(d, m) {
   return Math.abs(q - Math.round(q)) < 1e-9;
 }
 
+const _formats = require('./formats');
 const FORMAT_CHECKS = {
   email: (s) => { const at = s.indexOf('@'); return at > 0 && at < s.length - 1 && s.indexOf('.', at) > at + 1; },
-  date: (s) => { if (s.length !== 10 || !/^\d{4}-\d{2}-\d{2}$/.test(s)) return false; const m = +s.slice(5, 7), d = +s.slice(8, 10); return m >= 1 && m <= 12 && d >= 1 && d <= 31; },
+  date: _formats.date,
   'date-time': (s) => /^\d{4}-\d{2}-\d{2}[Tt]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/.test(s) && !isNaN(Date.parse(s)),
   time: (s) => /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d(\.\d+)?([Zz]|[+-]\d{2}:\d{2})?$/.test(s),
   duration: (s) => /^P(?:\d+Y)?(?:\d+M)?(?:\d+W)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?$/.test(s) && s !== 'P' && !s.endsWith('T'),
   uuid: (s) => s.length === 36 && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s),
   uri: (s) => /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(s) && !/[\s\u0000-\u001f\u007f]/.test(s),
   'uri-reference': (s) => !/[\s\u0000-\u001f\u007f]/.test(s),
-  ipv4: (s) => { const p = s.split('.'); return p.length === 4 && p.every((n) => { const v = +n; return n !== '' && v >= 0 && v <= 255 && String(v) === n; }); },
+  ipv4: _formats.ipv4,
   ipv6: (s) => s !== '' && /^[0-9a-fA-F:.]+$/.test(s) && s.split(':').length >= 3 && s.split(':').length <= 8,
   hostname: (s) => s.length > 0 && s.length <= 253 && /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test(s),
   regex: (s) => { try { new RegExp(s, 'u'); return true; } catch { try { new RegExp(s); return true; } catch { return false; } } },