ata-validator 1.32.3 → 1.33.0

package/index.js

@@ -1254,7 +1254,7 @@ class Validator {
     } else if (cached && cached.jsFn !== undefined) {
       // `full` says the error and combined functions exist too. An entry
       // without it still carries a verdict function worth reusing; the pair is
-      // built by _buildDeferred below if something asks for an error, and the
+      // built by _buildErr/_buildCombined below when something asks, and the
       // entry is upgraded then. `undefined` in `combined`/`errFn` means not
       // built yet; `null` means the compiler declined. Those two must never
       // blur: reading the first as the second is the bug this cache had once
@@ -1272,7 +1272,7 @@ class Validator {
       // are the other two thirds of a cold first call (8.2, 10.4 and 7.8 ms on
       // a 120-property config schema, most of it V8 compiling each generator
       // the first time it is entered), and a caller that never reads an error
-      // never needs them. _buildDeferred compiles them on the first rejection.
+      // never needs them. _buildErr/_buildCombined compile them on demand.
       jsCombinedFn = undefined;
       jsErrFn = undefined;
       _isCodegen = !!_cgFn;
@@ -1348,24 +1348,32 @@ class Validator {
           )));
     const useSimdjsonForLarge = !hasArrayTraversal;
 
-    // Builds the two generators the compile step left out, once, and upgrades
-    // the shared cache entry. `undefined` means not built yet; `null` means the
-    // compiler declined. Conflating those is what once cost every schema its
-    // generated error function for the life of the process, so they stay apart.
-    const _buildDeferred = () => {
-      if (jsCombinedFn !== undefined && jsErrFn !== undefined) return;
-      const uf2 = this._userFormats;
-      if (jsCombinedFn === undefined) jsCombinedFn = compileToJSCombined(schemaObj, VALID_RESULT, sm, uf2) || null;
-      if (jsErrFn === undefined) jsErrFn = compileToJSCodegenWithErrors(schemaObj, sm, uf2) || null;
-      if (!uf2) {
-        const entry = _compileCache.get(mapKey);
-        if (entry && entry.jsFn === jsFn) {
-          entry.combined = jsCombinedFn;
-          entry.errFn = jsErrFn;
-          entry.full = true;
-        }
+    // Build the generators the compile step left out, each only when something
+    // asks for it, and upgrade the shared cache entry. A first rejection needs
+    // one of the two, not both; building both was a millisecond of V8 compiling
+    // a generator nobody called. `undefined` means not built yet; `null` means
+    // the compiler declined. Conflating those is what once cost every schema
+    // its generated error function for the life of the process, so they stay
+    // apart, and `full` is set only once both exist.
+    const _upgradeCacheEntry = () => {
+      if (this._userFormats) return;
+      const entry = _compileCache.get(mapKey);
+      if (entry && entry.jsFn === jsFn) {
+        if (jsCombinedFn !== undefined) entry.combined = jsCombinedFn;
+        if (jsErrFn !== undefined) entry.errFn = jsErrFn;
+        if (jsCombinedFn !== undefined && jsErrFn !== undefined) entry.full = true;
       }
     };
+    const _buildCombined = () => {
+      if (jsCombinedFn !== undefined) return;
+      jsCombinedFn = compileToJSCombined(schemaObj, VALID_RESULT, sm, this._userFormats) || null;
+      _upgradeCacheEntry();
+    };
+    const _buildErr = () => {
+      if (jsErrFn !== undefined) return;
+      jsErrFn = compileToJSCodegenWithErrors(schemaObj, sm, this._userFormats) || null;
+      _upgradeCacheEntry();
+    };
 
     if (jsFn) {
       // errFn: use JS codegen if safe, else native fallback (only when native
@@ -1414,7 +1422,7 @@ class Validator {
       let _errOnlyImpl = null;
       const errOnly = (d) => {
         if (_errOnlyImpl === null) {
-          _buildDeferred();
+          _buildErr();
           let safe = null;
           if (jsErrFn) {
             try {
@@ -1452,7 +1460,7 @@ class Validator {
       const combinedIfSafe = () => {
         if (_combinedProbed) return _safeCombined;
         _combinedProbed = true;
-        _buildDeferred();
+        _buildCombined();
         if (jsCombinedFn) {
           try {
             const probe = {};
@@ -2333,7 +2341,7 @@ class Validator {
       _rememberInstance(this);
       // A partial entry: the verdict function is real, the other two are not
       // built yet rather than declined. `undefined` is the not-built marker
-      // the full compile's _buildDeferred looks for; `null` would read as
+      // the full compile's _buildErr/_buildCombined look for; `null` would read as
       // "the compiler declined" and cost the schema its error function, which
       // is the bug this cache had once already. `isCodegen` rides along so a
       // validator that later reuses this entry reports the same engine it

package/lib/clone-emit.js

@@ -267,22 +267,32 @@ function stripDefaultsDeep(node) {
 }
 
 const _CLONE_PRIMITIVE = new Set(['string', 'number', 'integer', 'boolean', 'null']);
+// Whether every value this schema accepts is a primitive, so a copy has
+// nothing inside it to strip and takes the value as it is. A primitive type
+// says so directly. With no type, an enum or const whose values are all
+// primitives says so too: `{ enum: ['USD', 'EUR'] }` is how such a field is
+// usually written, and it declined parse() for the whole schema. So does an
+// anyOf or oneOf whose every branch says so: a value that passes matched one
+// of them. `number | null` arrives from zod's JSON Schema in that form.
+function isPrimitiveOnly(s) {
+  if (!s || typeof s !== 'object' || s.$ref) return false;
+  if (s.type !== undefined) {
+    const types = Array.isArray(s.type) ? s.type : [s.type];
+    return types.every((t) => _CLONE_PRIMITIVE.has(t));
+  }
+  const isPrim = (v) => v === null || (typeof v !== 'object' && typeof v !== 'function');
+  if (Array.isArray(s.enum) && s.enum.length > 0 && s.enum.every(isPrim) && s.const === undefined) return true;
+  if (s.const !== undefined && isPrim(s.const) && s.enum === undefined) return true;
+  for (const k of ['anyOf', 'oneOf']) {
+    if (Array.isArray(s[k]) && s[k].length > 0 && s[k].every(isPrimitiveOnly)) return true;
+  }
+  return false;
+}
+
 function emitValueExpr(prop, read, depth) {
   if (!prop || typeof prop !== 'object') return null;
   if (prop.$ref) return null;
-  const types = Array.isArray(prop.type) ? prop.type : [prop.type];
-  if (types.every((t) => _CLONE_PRIMITIVE.has(t))) return read;
-  // No type, but an enum or const whose values are all primitives: whatever
-  // passes can only be one of those values, so there is nothing inside it to
-  // strip and the value is copied as it is. `{ enum: ['USD', 'EUR'] }` is how
-  // such a field is usually written, and it declined parse() for the whole
-  // schema.
-  if (prop.type === undefined) {
-    const isPrim = (v) => v === null || (typeof v !== 'object' && typeof v !== 'function');
-    if (Array.isArray(prop.enum) && prop.enum.length > 0 && prop.enum.every(isPrim) &&
-        prop.const === undefined) return read;
-    if (prop.const !== undefined && isPrim(prop.const) && prop.enum === undefined) return read;
-  }
+  if (isPrimitiveOnly(prop)) return read;
   const isRecordable = (s) => s.properties ||
     (s.additionalProperties && typeof s.additionalProperties === 'object');
   if (prop.type === 'object' && isRecordable(prop)) {
@@ -291,8 +301,9 @@ function emitValueExpr(prop, read, depth) {
   if (prop.type === 'array' && prop.items && typeof prop.items === 'object' &&
       !Array.isArray(prop.items)) {
     const it = prop.items;
-    const itemTypes = Array.isArray(it.type) ? it.type : [it.type];
-    if (itemTypes.every((t) => _CLONE_PRIMITIVE.has(t))) return read;
+    // A fresh array, not the input's: handing the same array back let a
+    // caller who changed the copy change the input with it.
+    if (isPrimitiveOnly(it)) return `${read}.slice()`;
     if (it.type === 'object' && isRecordable(it)) {
       const el = '_e' + depth;
       const inner = emitClone(it, el, depth + 1);