@scalar/openapi-parser 0.25.4 → 0.25.6

package/dist/types/index.js

@@ -1 +1 @@
-//# sourceMappingURL=index.js.map
+export {};

package/dist/utils/betterAjvErrors/helpers.js

@@ -1,125 +1,151 @@
-import {
-  concatAll,
-  getChildren,
-  getErrors,
-  getSiblings,
-  isAdditionalPropertiesError,
-  isAnyOfError,
-  isEnumError,
-  isIfError,
-  isOneOfError,
-  isRequiredError,
-  isUnevaluatedPropertiesError,
-  notUndefined
-} from "./utils.js";
-import {
-  AdditionalPropValidationError,
-  DefaultValidationError,
-  EnumValidationError,
-  PatternValidationError,
-  RequiredValidationError,
-  UnevaluatedPropValidationError
-} from "./validation-errors/index.js";
+import { concatAll, getChildren, getErrors, getSiblings, isAdditionalPropertiesError, isAnyOfError, isEnumError, isIfError, isOneOfError, isRequiredError, isUnevaluatedPropertiesError, notUndefined, } from './utils.js';
+import { AdditionalPropValidationError, DefaultValidationError, EnumValidationError, PatternValidationError, RequiredValidationError, UnevaluatedPropValidationError, } from './validation-errors/index.js';
 const JSON_POINTERS_REGEX = /\/[\w_-]+(\/\d+)?/g;
+// Make a tree of errors from ajv errors array
 function makeTree(ajvErrors = []) {
-  const root = { children: {} };
-  ajvErrors.forEach((ajvError) => {
-    const instancePath = typeof ajvError.instancePath !== "undefined" ? ajvError.instancePath : ajvError.dataPath;
-    const paths = instancePath === "" ? [""] : instancePath.match(JSON_POINTERS_REGEX);
-    if (paths) {
-      paths.reduce((obj, path, i) => {
-        obj.children[path] = obj.children[path] || { children: {}, errors: [] };
-        if (i === paths.length - 1) {
-          obj.children[path].errors.push(ajvError);
+    const root = { children: {} };
+    ajvErrors.forEach((ajvError) => {
+        const instancePath = typeof ajvError.instancePath !== 'undefined' ? ajvError.instancePath : ajvError.dataPath;
+        // `dataPath === ''` is root
+        const paths = instancePath === '' ? [''] : instancePath.match(JSON_POINTERS_REGEX);
+        if (paths) {
+            paths.reduce((obj, path, i) => {
+                obj.children[path] = obj.children[path] || { children: {}, errors: [] };
+                if (i === paths.length - 1) {
+                    obj.children[path].errors.push(ajvError);
+                }
+                return obj.children[path];
+            }, root);
         }
-        return obj.children[path];
-      }, root);
-    }
-  });
-  return root;
+    });
+    return root;
 }
 function filterRedundantErrors(root, parent, key) {
-  const errors = getErrors(root);
-  const hasOneOfError = errors.some(isOneOfError);
-  const hasAnyOfError = errors.some(isAnyOfError);
-  const hasRequiredError = errors.some(isRequiredError);
-  const hasIfError = errors.some(isIfError);
-  const hasAdditionalPropertiesError = errors.some(isAdditionalPropertiesError);
-  const hasUnevaluatedPropertiesError = errors.some(isUnevaluatedPropertiesError);
-  const hasChildren = Object.keys(root.children || {}).length > 0;
-  if (hasIfError && (hasAdditionalPropertiesError || hasUnevaluatedPropertiesError)) {
-    root.errors = errors.filter((error) => !isIfError(error));
-  }
-  if (hasOneOfError && hasRequiredError) {
-    if (hasAdditionalPropertiesError || hasUnevaluatedPropertiesError) {
-      root.errors = errors.filter((error) => !isRequiredError(error) && !isOneOfError(error));
-    } else if (hasChildren) {
-      delete root.errors;
-    } else {
-      root.errors = errors.filter((error) => isOneOfError(error));
+    const errors = getErrors(root);
+    const hasOneOfError = errors.some(isOneOfError);
+    const hasAnyOfError = errors.some(isAnyOfError);
+    const hasRequiredError = errors.some(isRequiredError);
+    const hasIfError = errors.some(isIfError);
+    const hasAdditionalPropertiesError = errors.some(isAdditionalPropertiesError);
+    const hasUnevaluatedPropertiesError = errors.some(isUnevaluatedPropertiesError);
+    const hasChildren = Object.keys(root.children || {}).length > 0;
+    /**
+     * If there is an `if` error with `additionalProperties` or `unevaluatedProperties` error,
+     * filter out the `if` error as it's just noise from the if/then/else conditional.
+     */
+    if (hasIfError && (hasAdditionalPropertiesError || hasUnevaluatedPropertiesError)) {
+        root.errors = errors.filter((error) => !isIfError(error));
+    }
+    /**
+     * If there is a `oneOf` error with a `required` error:
+     * 1. If there are other errors at this level (like additionalProperties), keep those
+     * 2. If there are child errors, don't clear them - they're more meaningful
+     * The `required` error is likely from a failed oneOf branch (e.g., Reference requiring $ref).
+     */
+    if (hasOneOfError && hasRequiredError) {
+        if (hasAdditionalPropertiesError || hasUnevaluatedPropertiesError) {
+            // Filter out the required and oneOf errors, keep the meaningful ones at this level
+            root.errors = errors.filter((error) => !isRequiredError(error) && !isOneOfError(error));
+        }
+        else if (hasChildren) {
+            // Clear parent errors, keep children as they're more meaningful
+            delete root.errors;
+        }
+        else {
+            // No other errors, keep oneOf as it's all we have
+            root.errors = errors.filter((error) => isOneOfError(error));
+        }
+    }
+    else if (hasOneOfError && !hasRequiredError && hasChildren) {
+        /**
+         * If there is only a `oneOf` error (without required complications):
+         * If there are child errors, clear the oneOf error to surface the children.
+         * Children will have more specific information about why each branch failed.
+         */
+        // Clear the generic oneOf errors, let children surface
+        delete root.errors;
     }
-  } else if (hasOneOfError && !hasRequiredError && hasChildren) {
-    delete root.errors;
-  } else if (hasOneOfError && !hasRequiredError && !hasChildren) {
-    const oneOfErrors = errors.filter(isOneOfError);
-    if (oneOfErrors.length > 1) {
-      root.errors = [oneOfErrors[0]];
+    else if (hasOneOfError && !hasRequiredError && !hasChildren) {
+        /**
+         * If we have multiple oneOf errors (duplicates from different branches),
+         * keep only one to avoid noise.
+         */
+        const oneOfErrors = errors.filter(isOneOfError);
+        if (oneOfErrors.length > 1) {
+            // Keep only the first oneOf error
+            root.errors = [oneOfErrors[0]];
+        }
+    }
+    else if (hasRequiredError && !hasOneOfError) {
+        /**
+         * If there is a `required` error (without oneOf complications),
+         * then we can just skip everything else.
+         * And, also `required` should have more priority than `anyOf`. @see #8
+         */
+        root.errors = errors.filter(isRequiredError);
+        root.children = {};
     }
-  } else if (hasRequiredError && !hasOneOfError) {
-    root.errors = errors.filter(isRequiredError);
-    root.children = {};
-  }
-  if (hasAnyOfError) {
-    if (Object.keys(root.children).length > 0) {
-      delete root.errors;
+    /**
+     * If there is an `anyOf` error that means we have more meaningful errors
+     * inside children. So we will just remove all errors from this level.
+     *
+     * If there are no children, then we don't delete the errors since we should
+     * have at least one error to report.
+     */
+    if (hasAnyOfError) {
+        if (Object.keys(root.children).length > 0) {
+            delete root.errors;
+        }
     }
-  }
-  if (root.errors?.length && getErrors(root).every(isEnumError)) {
-    if (getSiblings(parent)(root).filter(notUndefined).some(getErrors)) {
-      delete parent.children[key];
+    /**
+     * If all errors are `enum` and siblings have any error then we can safely
+     * ignore the node.
+     *
+     * **CAUTION**
+     * Need explicit `root.errors` check because `[].every(fn) === true`
+     * https://en.wikipedia.org/wiki/Vacuous_truth#Vacuous_truths_in_mathematics
+     */
+    if (root.errors?.length && getErrors(root).every(isEnumError)) {
+        if (getSiblings(parent)(root)
+            // Remove any reference which becomes `undefined` later
+            .filter(notUndefined)
+            .some(getErrors)) {
+            delete parent.children[key];
+        }
     }
-  }
-  Object.entries(root.children).forEach(([k, child]) => filterRedundantErrors(child, root, k));
+    Object.entries(root.children).forEach(([k, child]) => filterRedundantErrors(child, root, k));
 }
 function createErrorInstances(root, options) {
-  const errors = getErrors(root);
-  if (errors.length && errors.every(isEnumError)) {
-    const uniqueValues = new Set(concatAll([])(errors.map((e) => e.params.allowedValues)));
-    const allowedValues = [...uniqueValues];
-    const error = errors[0];
-    return [
-      new EnumValidationError(
-        {
-          ...error,
-          params: { allowedValues }
-        },
-        options
-      )
-    ];
-  }
-  return concatAll(
-    errors.reduce((ret, error) => {
-      switch (error.keyword) {
-        case "additionalProperties":
-          return ret.concat(new AdditionalPropValidationError(error, options));
-        case "pattern":
-          return ret.concat(new PatternValidationError(error, options));
-        case "required":
-          return ret.concat(new RequiredValidationError(error, options));
-        case "unevaluatedProperties":
-          return ret.concat(new UnevaluatedPropValidationError(error, options));
-        default:
-          return ret.concat(new DefaultValidationError(error, options));
-      }
-    }, [])
-  )(getChildren(root).map((child) => createErrorInstances(child, options)));
+    const errors = getErrors(root);
+    if (errors.length && errors.every(isEnumError)) {
+        const uniqueValues = new Set(concatAll([])(errors.map((e) => e.params.allowedValues)));
+        const allowedValues = [...uniqueValues];
+        const error = errors[0];
+        return [
+            new EnumValidationError({
+                ...error,
+                params: { allowedValues },
+            }, options),
+        ];
+    }
+    return concatAll(errors.reduce((ret, error) => {
+        switch (error.keyword) {
+            case 'additionalProperties':
+                return ret.concat(new AdditionalPropValidationError(error, options));
+            case 'pattern':
+                return ret.concat(new PatternValidationError(error, options));
+            case 'required':
+                return ret.concat(new RequiredValidationError(error, options));
+            case 'unevaluatedProperties':
+                return ret.concat(new UnevaluatedPropValidationError(error, options));
+            default:
+                return ret.concat(new DefaultValidationError(error, options));
+        }
+    }, []))(getChildren(root).map((child) => createErrorInstances(child, options)));
 }
-function prettify(ajvErrors, options) {
-  const tree = makeTree(ajvErrors || []);
-  filterRedundantErrors(tree);
-  return createErrorInstances(tree, options);
+export default function prettify(ajvErrors, options) {
+    const tree = makeTree(ajvErrors || []);
+    // @ts-expect-error TODO
+    filterRedundantErrors(tree);
+    return createErrorInstances(tree, options);
 }
-export {
-  prettify as default
-};
-//# sourceMappingURL=helpers.js.map

package/dist/utils/betterAjvErrors/index.js

@@ -1,16 +1,12 @@
-import prettify from "./helpers.js";
-function betterAjvErrors(schema, data, errors, options = {}) {
-  const { indent = null, json = null } = options;
-  const jsonRaw = json || JSON.stringify(data, null, indent);
-  const customErrorToStructure = (error) => error.getError();
-  const customErrors = prettify(errors, {
-    data,
-    schema,
-    jsonRaw
-  });
-  return customErrors.map(customErrorToStructure);
+import prettify from './helpers.js';
+export function betterAjvErrors(schema, data, errors, options = {}) {
+    const { indent = null, json = null } = options;
+    const jsonRaw = json || JSON.stringify(data, null, indent);
+    const customErrorToStructure = (error) => error.getError();
+    const customErrors = prettify(errors, {
+        data,
+        schema,
+        jsonRaw,
+    });
+    return customErrors.map(customErrorToStructure);
 }
-export {
-  betterAjvErrors
-};
-//# sourceMappingURL=index.js.map

package/dist/utils/betterAjvErrors/utils.js

@@ -1,34 +1,21 @@
+// Basic
 const eq = (x) => (y) => x === y;
 const not = (fn) => (x) => !fn(x);
 const getValues = (o) => Object.values(o);
-const notUndefined = (x) => x !== void 0;
+export const notUndefined = (x) => x !== undefined;
+// Error
 const isXError = (x) => (error) => error.keyword === x;
-const isRequiredError = isXError("required");
-const isAnyOfError = isXError("anyOf");
-const isOneOfError = isXError("oneOf");
-const isIfError = isXError("if");
-const isEnumError = isXError("enum");
-const isAdditionalPropertiesError = isXError("additionalProperties");
-const isUnevaluatedPropertiesError = isXError("unevaluatedProperties");
-const getErrors = (node) => node?.errors || [];
-const getChildren = (node) => node && getValues(node.children) || [];
-const getSiblings = (parent) => (node) => getChildren(parent).filter(not(eq(node)));
-const concatAll = (
-  /* ::<T> */
-  (xs) => (ys) => ys.reduce((zs, z) => zs.concat(z), xs)
-);
-export {
-  concatAll,
-  getChildren,
-  getErrors,
-  getSiblings,
-  isAdditionalPropertiesError,
-  isAnyOfError,
-  isEnumError,
-  isIfError,
-  isOneOfError,
-  isRequiredError,
-  isUnevaluatedPropertiesError,
-  notUndefined
-};
-//# sourceMappingURL=utils.js.map
+export const isRequiredError = isXError('required');
+export const isAnyOfError = isXError('anyOf');
+export const isOneOfError = isXError('oneOf');
+export const isIfError = isXError('if');
+export const isEnumError = isXError('enum');
+export const isAdditionalPropertiesError = isXError('additionalProperties');
+export const isUnevaluatedPropertiesError = isXError('unevaluatedProperties');
+export const getErrors = (node) => node?.errors || [];
+// Node
+export const getChildren = (node) => (node && getValues(node.children)) || [];
+export const getSiblings = (parent /*: Node */) => (node /*: Node */) => getChildren(parent).filter(not(eq(node)));
+export const concatAll = 
+/* ::<T> */
+(xs /*: $ReadOnlyArray<T> */) => (ys /* : $ReadOnlyArray<T> */) => ys.reduce((zs, z) => zs.concat(z), xs);

package/dist/utils/betterAjvErrors/validation-errors/additional-prop.js

@@ -1,19 +1,15 @@
-import BaseValidationError from "./base.js";
-class AdditionalPropValidationError extends BaseValidationError {
-  constructor(...args) {
-    super(...args);
-    this.name = "AdditionalPropValidationError";
-    this.options.isIdentifierLocation = true;
-  }
-  getError() {
-    const { params } = this.options;
-    return {
-      message: `Property ${params.additionalProperty} is not expected to be here`,
-      path: this.instancePath
-    };
-  }
+import BaseValidationError from './base.js';
+export default class AdditionalPropValidationError extends BaseValidationError {
+    constructor(...args) {
+        super(...args);
+        this.name = 'AdditionalPropValidationError';
+        this.options.isIdentifierLocation = true;
+    }
+    getError() {
+        const { params } = this.options;
+        return {
+            message: `Property ${params.additionalProperty} is not expected to be here`,
+            path: this.instancePath,
+        };
+    }
 }
-export {
-  AdditionalPropValidationError as default
-};
-//# sourceMappingURL=additional-prop.js.map

package/dist/utils/betterAjvErrors/validation-errors/base.js

@@ -1,22 +1,21 @@
-class BaseValidationError {
-  constructor(options = { isIdentifierLocation: false }, { data, schema, jsonAst, jsonRaw }) {
-    this.options = options;
-    this.data = data;
-    this.schema = schema;
-    this.jsonAst = jsonAst;
-    this.jsonRaw = jsonRaw;
-  }
-  /**
-   * @return {string}
-   */
-  get instancePath() {
-    return typeof this.options.instancePath !== "undefined" ? this.options.instancePath : this.options.dataPath;
-  }
-  getError() {
-    throw new Error(`Implement the 'getError' method inside ${this.constructor.name}!`);
-  }
+// import { codeFrameColumns } from '@babel/code-frame';
+// import chalk from 'chalk';
+// import { getMetaFromPath } from '@/json/index'
+export default class BaseValidationError {
+    constructor(options = { isIdentifierLocation: false }, { data, schema, jsonAst, jsonRaw }) {
+        this.options = options;
+        this.data = data;
+        this.schema = schema;
+        this.jsonAst = jsonAst;
+        this.jsonRaw = jsonRaw;
+    }
+    /**
+     * @return {string}
+     */
+    get instancePath() {
+        return typeof this.options.instancePath !== 'undefined' ? this.options.instancePath : this.options.dataPath;
+    }
+    getError() {
+        throw new Error(`Implement the 'getError' method inside ${this.constructor.name}!`);
+    }
 }
-export {
-  BaseValidationError as default
-};
-//# sourceMappingURL=base.js.map

package/dist/utils/betterAjvErrors/validation-errors/default.js

@@ -1,19 +1,15 @@
-import BaseValidationError from "./base.js";
-class DefaultValidationError extends BaseValidationError {
-  constructor(...args) {
-    super(...args);
-    this.name = "DefaultValidationError";
-    this.options.isSkipEndLocation = true;
-  }
-  getError() {
-    const { keyword, message } = this.options;
-    return {
-      message: `${keyword} ${message}`,
-      path: this.instancePath
-    };
-  }
+import BaseValidationError from './base.js';
+export default class DefaultValidationError extends BaseValidationError {
+    constructor(...args) {
+        super(...args);
+        this.name = 'DefaultValidationError';
+        this.options.isSkipEndLocation = true;
+    }
+    getError() {
+        const { keyword, message } = this.options;
+        return {
+            message: `${keyword} ${message}`,
+            path: this.instancePath,
+        };
+    }
 }
-export {
-  DefaultValidationError as default
-};
-//# sourceMappingURL=default.js.map

package/dist/utils/betterAjvErrors/validation-errors/enum.js

@@ -1,40 +1,36 @@
-import pointer from "jsonpointer";
-import leven from "leven";
-import BaseValidationError from "./base.js";
-class EnumValidationError extends BaseValidationError {
-  constructor(...args) {
-    super(...args);
-    this.name = "EnumValidationError";
-  }
-  getError() {
-    const { message, params } = this.options;
-    const bestMatch = this.findBestMatch();
-    const allowedValues = params.allowedValues.join(", ");
-    const output = {
-      message: `${message}: ${allowedValues}`,
-      path: this.instancePath
-    };
-    if (bestMatch !== null) {
-      output.suggestion = `Did you mean ${bestMatch}?`;
+import pointer from 'jsonpointer';
+import leven from 'leven';
+import BaseValidationError from './base.js';
+export default class EnumValidationError extends BaseValidationError {
+    constructor(...args) {
+        super(...args);
+        this.name = 'EnumValidationError';
     }
-    return output;
-  }
-  findBestMatch() {
-    const {
-      params: { allowedValues }
-    } = this.options;
-    const currentValue = this.instancePath === "" ? this.data : pointer.get(this.data, this.instancePath);
-    if (!currentValue) {
-      return null;
+    getError() {
+        const { message, params } = this.options;
+        const bestMatch = this.findBestMatch();
+        const allowedValues = params.allowedValues.join(', ');
+        const output = {
+            message: `${message}: ${allowedValues}`,
+            path: this.instancePath,
+        };
+        if (bestMatch !== null) {
+            output.suggestion = `Did you mean ${bestMatch}?`;
+        }
+        return output;
+    }
+    findBestMatch() {
+        const { params: { allowedValues }, } = this.options;
+        const currentValue = this.instancePath === '' ? this.data : pointer.get(this.data, this.instancePath);
+        if (!currentValue) {
+            return null;
+        }
+        const bestMatch = allowedValues
+            .map((value) => ({
+            value,
+            weight: leven(value, currentValue.toString()),
+        }))
+            .sort((x, y) => (x.weight > y.weight ? 1 : x.weight < y.weight ? -1 : 0))[0];
+        return allowedValues.length === 1 || bestMatch.weight < bestMatch.value.length ? bestMatch.value : null;
     }
-    const bestMatch = allowedValues.map((value) => ({
-      value,
-      weight: leven(value, currentValue.toString())
-    })).sort((x, y) => x.weight > y.weight ? 1 : x.weight < y.weight ? -1 : 0)[0];
-    return allowedValues.length === 1 || bestMatch.weight < bestMatch.value.length ? bestMatch.value : null;
-  }
 }
-export {
-  EnumValidationError as default
-};
-//# sourceMappingURL=enum.js.map

package/dist/utils/betterAjvErrors/validation-errors/index.js

@@ -1,15 +1,6 @@
-import { default as default2 } from "./additional-prop.js";
-import { default as default3 } from "./default.js";
-import { default as default4 } from "./enum.js";
-import { default as default5 } from "./pattern.js";
-import { default as default6 } from "./required.js";
-import { default as default7 } from "./unevaluated-prop.js";
-export {
-  default2 as AdditionalPropValidationError,
-  default3 as DefaultValidationError,
-  default4 as EnumValidationError,
-  default5 as PatternValidationError,
-  default6 as RequiredValidationError,
-  default7 as UnevaluatedPropValidationError
-};
-//# sourceMappingURL=index.js.map
+export { default as AdditionalPropValidationError } from './additional-prop.js';
+export { default as DefaultValidationError } from './default.js';
+export { default as EnumValidationError } from './enum.js';
+export { default as PatternValidationError } from './pattern.js';
+export { default as RequiredValidationError } from './required.js';
+export { default as UnevaluatedPropValidationError } from './unevaluated-prop.js';

package/dist/utils/betterAjvErrors/validation-errors/pattern.js

@@ -1,19 +1,15 @@
-import BaseValidationError from "./base.js";
-class PatternValidationError extends BaseValidationError {
-  constructor(...args) {
-    super(...args);
-    this.name = "PatternValidationError";
-    this.options.isIdentifierLocation = true;
-  }
-  getError() {
-    const { params, propertyName } = this.options;
-    return {
-      message: `Property "${propertyName}" must match pattern ${params.pattern}`,
-      path: this.instancePath
-    };
-  }
+import BaseValidationError from './base.js';
+export default class PatternValidationError extends BaseValidationError {
+    constructor(...args) {
+        super(...args);
+        this.name = 'PatternValidationError';
+        this.options.isIdentifierLocation = true;
+    }
+    getError() {
+        const { params, propertyName } = this.options;
+        return {
+            message: `Property "${propertyName}" must match pattern ${params.pattern}`,
+            path: this.instancePath,
+        };
+    }
 }
-export {
-  PatternValidationError as default
-};
-//# sourceMappingURL=pattern.js.map

package/dist/utils/betterAjvErrors/validation-errors/required.js

@@ -1,18 +1,14 @@
-import BaseValidationError from "./base.js";
-class RequiredValidationError extends BaseValidationError {
-  constructor(...args) {
-    super(...args);
-    this.name = "RequiredValidationError";
-  }
-  getError() {
-    const { message } = this.options;
-    return {
-      message: `${message}`,
-      path: this.instancePath
-    };
-  }
+import BaseValidationError from './base.js';
+export default class RequiredValidationError extends BaseValidationError {
+    constructor(...args) {
+        super(...args);
+        this.name = 'RequiredValidationError';
+    }
+    getError() {
+        const { message } = this.options;
+        return {
+            message: `${message}`,
+            path: this.instancePath,
+        };
+    }
 }
-export {
-  RequiredValidationError as default
-};
-//# sourceMappingURL=required.js.map