@jarenjs/validate 0.8.4 → 0.9.2

package/src/dynamic-ref.js

@@ -0,0 +1,121 @@
+//@ts-check
+
+/**
+ * Dynamic Reference Resolution Module
+ * 
+ * This module handles $recursiveRef (draft 2019-09) and $dynamicRef (draft 2020-12)
+ * which require runtime resolution based on dynamic scope.
+ * 
+ * Key concepts:
+ * - $recursiveRef: References the nearest parent schema with $recursiveAnchor: true
+ * - $dynamicRef: References the nearest parent schema with matching $dynamicAnchor
+ * 
+ * Unlike regular $ref, these require runtime resolution because the target depends
+ * on the dynamic context where the schema is used.
+ */
+
+import { isObjectClass, isStringType } from '@jarenjs/core';
+
+/**
+ * Check if a schema has $recursiveAnchor: true.
+ * @param {object} schema - The schema object
+ * @returns {boolean}
+ */
+export function hasRecursiveAnchor(schema) {
+  return isObjectClass(schema) && schema.$recursiveAnchor === true;
+}
+
+/**
+ * Get the $dynamicAnchor name from a schema.
+ * @param {object} schema - The schema object
+ * @returns {string|null}
+ */
+export function getDynamicAnchorName(schema) {
+  if (!isObjectClass(schema)) return null;
+  return isStringType(schema.$dynamicAnchor) ? schema.$dynamicAnchor : null;
+}
+
+/**
+ * Collect ALL dynamic anchors of a schema RESOURCE: every $dynamicAnchor
+ * reachable from the given schema without crossing into an embedded
+ * resource (a subschema that declares its own $id).
+ *
+ * Per draft 2020-12, entering a schema resource during evaluation brings
+ * every $dynamicAnchor of that resource into the dynamic scope - wherever
+ * it sits ($defs, allOf branches, properties, ...), not just at the root.
+ *
+ * @param {object} schema - The resource root schema object
+ * @returns {Array<{name: string, schema: object, validator: (function|null)}>}
+ */
+export function collectDynamicAnchorsDeep(schema) {
+  const anchors = [];
+  if (!isObjectClass(schema)) return anchors;
+
+  const seen = new Set();
+  const queue = [{ node: schema, isRoot: true }];
+  while (queue.length > 0) {
+    const { node, isRoot } = queue.shift();
+    if (!isObjectClass(node) && !Array.isArray(node)) continue;
+    if (seen.has(node)) continue;
+    seen.add(node);
+
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; ++i) {
+        queue.push({ node: node[i], isRoot: false });
+      }
+      continue;
+    }
+
+    // A nested $id starts a new (embedded) resource - its anchors enter
+    // the dynamic scope only when that resource itself is entered.
+    if (!isRoot && isStringType(node.$id)) continue;
+
+    const anchorName = getDynamicAnchorName(node);
+    if (anchorName) {
+      anchors.push({ name: anchorName, schema: node, validator: null });
+    }
+
+    for (const key of Object.keys(node)) {
+      queue.push({ node: node[key], isRoot: false });
+    }
+  }
+
+  return anchors;
+}
+
+/**
+ * Collect all dynamic anchors from a schema's immediate definitions ($defs/definitions).
+ * This is used to find all $dynamicAnchor definitions that should be in scope
+ * when following a $ref from this schema.
+ *
+ * IMPORTANT: This only collects from the IMMEDIATE $defs of the given schema,
+ * not recursively.
+ *
+ * @param {object} schema - The schema object
+ * @returns {Array<{name: string, schema: object}>} Array of {name, schema} objects
+ */
+export function collectDynamicAnchors(schema) {
+  const anchors = [];
+  if (!isObjectClass(schema)) return anchors;
+
+  // Check $defs first (draft 2020-12), then definitions (draft 7 and earlier)
+  const defs = schema.$defs || schema.definitions;
+  if (isObjectClass(defs)) {
+    for (const key of Object.keys(defs)) {
+      const def = defs[key];
+      if (isObjectClass(def)) {
+        // Check if this definition has a $dynamicAnchor
+        const anchorName = getDynamicAnchorName(def);
+        if (anchorName) {
+          anchors.push({ name: anchorName, schema: def, key });
+        }
+        // Note: We do NOT recurse into nested $defs here.
+        // Dynamic anchors from nested $defs of a $ref target should NOT be
+        // automatically in scope - they should only be registered when that
+        // schema is actually evaluated.
+      }
+    }
+  }
+
+  return anchors;
+}

package/src/enum.js

@@ -0,0 +1,148 @@
+//@ts-check
+
+import {
+  isObjectType,
+  isScalarType,
+} from '@jarenjs/core';
+
+import {
+  equalsDeep,
+} from '@jarenjs/core/object';
+
+import {
+  getArrayClassMinItems,
+} from './tools.js';
+import { isDollarDataReference } from './dollar-data.js';
+
+// export const exampleEnumDataStructure = {
+//   allOf: [
+//     {
+//       enum: {
+//         source: false, // jsonpath!!
+//         data: [
+//           { color: 0xFFFFFF, name: 'white', type: 'greys' },
+//           { color: 0x000000, name: 'black', type: 'greys' },
+//           null, // this null will not be included in resulting enum array.
+//           { color: 0xFF0000, name: 'red', type: 'reds' },
+//           { color: 0x00FF00, name: 'green', type: 'greens' },
+//           { color: 0x0000FF, name: 'blue', type: 'blues' },
+//         ],
+//         group: 'type',
+//         label: 'name',
+//         value: 'color',
+//       },
+//     },
+//     {
+//       enum: {
+//         source: false, // jsonpath!!
+//         data: [
+//           [0xFFFFFF, 'white', 'greys'],
+//           [0x000000, 'black', 'greys'],
+//           null, // null will be ignored
+//           [0xFF0000, 'red', 'reds'],
+//           [0x00FF00, 'green', 'greens'],
+//           [0x0000FF, 'blue', 'blues'],
+//         ],
+//         group: 2,
+//         label: 1,
+//         value: 0,
+//       },
+//     },
+//     {
+//       enum: {
+//         data: [
+//           { value: 0xFFFFFF, label: 'white', group: 'greys' },
+//           { value: 0x000000, label: 'black', group: 'greys' },
+//           null, // null will be ignored
+//           { value: 0xFF0000, label: 'red', group: 'reds' },
+//           { value: 0x00FF00, label: 'green', group: 'greens' },
+//           { value: 0x0000FF, label: 'blue', group: 'blues' },
+//         ],
+//       },
+//     },
+//     {
+//       enum: {
+//         data: [
+//           [0xFFFFFF, 'white', 'greys'],
+//           [0x000000, 'black', 'greys'],
+//           null, // null will be ignored
+//           [0xFF0000, 'red', 'reds'],
+//           [0x00FF00, 'green', 'greens'],
+//           [0x0000FF, 'blue', 'blues'],
+//         ],
+//       },
+//     },
+//   ],
+// };
+
+function compileConst(schemaObj, jsonSchema) {
+  const constant = jsonSchema.const;
+  if (constant === undefined)
+    return undefined;
+
+  if (isDollarDataReference(constant))
+    return undefined;
+
+  const addError = schemaObj.createErrorHandler(constant, 'const');
+
+  if (constant === null || isScalarType(constant)) {
+    return function validatePrimitiveConst(data, dataPath) {
+      return constant === data
+        || addError(data, dataPath);
+    };
+  }
+  else {
+    return function validateComplexConst(data, dataPath) {
+      return equalsDeep(constant, data)
+        || addError(data, dataPath);
+    };
+  }
+}
+
+function compileEnum(schemaObj, jsonSchema) {
+  const enums = getArrayClassMinItems(jsonSchema.enum, 1);
+  if (enums == null) return undefined;
+
+  let hasObjects = false;
+  for (let i = 0; i < enums.length; ++i) {
+    const e = enums[i];
+    if (e != null && typeof e === 'object') {
+      hasObjects = true;
+      break;
+    }
+  }
+
+  const addError = schemaObj.createErrorHandler(enums, 'enum');
+
+  if (hasObjects === false) {
+    return function validateEnumSimple(data, dataPath) {
+      return data === undefined
+        ? true
+        : enums.includes(data)
+          ? true
+          : addError(data, dataPath);
+    };
+  }
+  else {
+    return function validateEnumDeep(data, dataPath) {
+      if (data === undefined) return true;
+      if (data === null || typeof data !== 'object')
+        return enums.includes(data)
+          ? true
+          : addError(data, dataPath);
+
+      for (let i = 0; i < enums.length; ++i) {
+        if (equalsDeep(enums[i], data) === true)
+          return true;
+      }
+      return addError(data, dataPath);
+    };
+  }
+}
+
+export function compileEnumBasic(schemaObj, jsonSchema) {
+  return [
+    compileConst(schemaObj, jsonSchema),
+    compileEnum(schemaObj, jsonSchema),
+  ];
+}

package/src/format.js

@@ -0,0 +1,66 @@
+import {
+  isStringType,
+  isFn,
+} from '@jarenjs/core';
+
+/** @typedef {import('./index.js').FormatCompiler} FormatCompiler */
+
+/**
+ * Registers a single format compiler under a name.
+ * Existing registrations are never overwritten.
+ * @param {Record<string, FormatCompiler>} registered - The formats registry object
+ * @param {string} name - The format name (e.g. 'email', 'uri', 'date-time')
+ * @param {FormatCompiler} formatCompiler - The compiler to register
+ * @returns {boolean} True when the compiler was registered
+ */
+export function registerFormatCompiler(registered, name, formatCompiler) {
+  if (registered[name] == null) {
+    if (isFn(formatCompiler)) {
+      registered[name] = formatCompiler;
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Registers multiple format compilers at once.
+ * Existing registrations are never overwritten.
+ * @param {Record<string, FormatCompiler>} registered - The formats registry object
+ * @param {Record<string, FormatCompiler>} formatCompilers - Object mapping format names to compiler functions
+ * @returns {Record<string, FormatCompiler>} The registry object passed in
+ */
+export function registerFormatCompilers(registered, formatCompilers) {
+  const keys = Object.keys(formatCompilers);
+  for (let i = 0; i < keys.length; ++i) {
+    const key = keys[i];
+    const item = formatCompilers[key];
+    registerFormatCompiler(registered, key, item);
+  }
+  return registered;
+}
+
+export function getSchemaFormatCompiler(registered, name) {
+  if (isStringType(name))
+    return registered[name];
+  else
+    return undefined;
+}
+
+export function compileFormatBasic(schemaObj, jsonSchema) {
+  if (!isStringType(jsonSchema.format))
+    return undefined;
+
+  // From draft 2020-12 on, format is annotation-only unless assertion is
+  // enabled (formatAssertion option or format-assertion vocabulary).
+  if (schemaObj.options.formatAssertion === false)
+    return undefined;
+  const compiler = getSchemaFormatCompiler(
+    schemaObj.formats,
+    jsonSchema.format);
+
+  if (compiler)
+    return compiler(schemaObj, jsonSchema);
+  else
+    return undefined;
+}