@scalar/openapi-parser 0.8.6 → 0.8.7

package/dist/utils/betterAjvErrors/helpers.js

@@ -1 +1,108 @@
-import{getErrors as r,isRequiredError as e,isAnyOfError as t,isEnumError as n,getSiblings as o,notUndefined as a,concatAll as i,getChildren as c}from"./utils.js";import s from"./validation-errors/additional-prop.js";import d from"./validation-errors/default.js";import l from"./validation-errors/enum.js";import u from"./validation-errors/pattern.js";import h from"./validation-errors/required.js";import m from"./validation-errors/unevaluated-prop.js";const p=/\/[\w_-]+(\/\d+)?/g;function f(r=[]){const e={children:{}};return r.forEach((r=>{const t=void 0!==r.instancePath?r.instancePath:r.dataPath,n=""===t?[""]:t.match(p);n&&n.reduce(((e,t,o)=>(e.children[t]=e.children[t]||{children:{},errors:[]},o===n.length-1&&e.children[t].errors.push(r),e.children[t])),e)})),e}function w(i,c,s){r(i).forEach((r=>{e(r)&&(i.errors=[r],i.children={})})),r(i).some(t)&&Object.keys(i.children).length>0&&delete i.errors,i.errors?.length&&r(i).every(n)&&o(c)(i).filter(a).some(r)&&delete c.children[s],Object.entries(i.children).forEach((([r,e])=>w(e,i,r)))}function v(e,t){const o=r(e);if(o.length&&o.every(n)){const r=[...new Set(i([])(o.map((r=>r.params.allowedValues))))],e=o[0];return[new l({...e,params:{allowedValues:r}},t)]}return i(o.reduce(((r,e)=>{switch(e.keyword){case"additionalProperties":return r.concat(new s(e,t));case"pattern":return r.concat(new u(e,t));case"required":return r.concat(new h(e,t));case"unevaluatedProperties":return r.concat(new m(e,t));default:return r.concat(new d(e,t))}}),[]))(c(e).map((r=>v(r,t))))}function j(r,e){const t=f(r||[]);return w(t),v(t,e)}export{v as createErrorInstances,j as default,w as filterRedundantErrors,f as makeTree};
+import { getErrors, isRequiredError, isAnyOfError, isEnumError, getSiblings, notUndefined, concatAll, getChildren } from './utils.js';
+import EnumValidationError from './validation-errors/enum.js';
+import DefaultValidationError from './validation-errors/default.js';
+import UnevaluatedPropValidationError from './validation-errors/unevaluated-prop.js';
+import RequiredValidationError from './validation-errors/required.js';
+import PatternValidationError from './validation-errors/pattern.js';
+import AdditionalPropValidationError from './validation-errors/additional-prop.js';
+
+/* eslint-disable no-param-reassign */
+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;
+        // `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 root;
+}
+function filterRedundantErrors(root, parent, key) {
+    /**
+     * If there is a `required` error then we can just skip everythig else.
+     * And, also `required` should have more priority than `anyOf`. @see #8
+     */
+    getErrors(root).forEach((error) => {
+        if (isRequiredError(error)) {
+            root.errors = [error];
+            root.children = {};
+        }
+    });
+    /**
+     * 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 (getErrors(root).some(isAnyOfError)) {
+        if (Object.keys(root.children).length > 0) {
+            delete root.errors;
+        }
+    }
+    /**
+     * 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));
+}
+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)));
+}
+function prettify(ajvErrors, options) {
+    const tree = makeTree(ajvErrors || []);
+    // @ts-expect-error TODO
+    filterRedundantErrors(tree);
+    return createErrorInstances(tree, options);
+}
+
+export { createErrorInstances, prettify as default, filterRedundantErrors, makeTree };

package/dist/utils/betterAjvErrors/index.js

@@ -1 +1,15 @@
-import n from"./helpers.js";function r(r,t,o,e={}){const{indent:l=null,json:s=null}=e,a=s||JSON.stringify(t,null,l);return n(o,{data:t,schema:r,jsonRaw:a}).map((n=>n.getError()))}export{r as betterAjvErrors};
+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);
+}
+
+export { betterAjvErrors };

package/dist/utils/betterAjvErrors/utils.js

@@ -1 +1,31 @@
-const r=r=>void 0!==r,e=r=>e=>e.keyword===r,n=e("required"),t=e("anyOf"),c=e("enum"),o=r=>r&&r.errors||[],u=r=>{return r&&(e=r.children,Object.values(e))||[];var e},a=r=>e=>{return u(r).filter((t=e,n=r=>t===r,r=>!n(r)));var n,t},d=r=>e=>e.reduce(((r,e)=>r.concat(e)),r);export{d as concatAll,u as getChildren,o as getErrors,a as getSiblings,t as isAnyOfError,c as isEnumError,n as isRequiredError,r as notUndefined};
+// Basic
+const eq = (x) => (y) => x === y;
+const not = (fn) => (x) => !fn(x);
+
+const getValues = (o) => Object.values(o);
+
+const notUndefined = (x) => x !== undefined;
+
+// Error
+const isXError = (x) => (error) => error.keyword === x;
+const isRequiredError = isXError('required');
+const isAnyOfError = isXError('anyOf');
+const isEnumError = isXError('enum');
+const getErrors = (node) => (node && node.errors) || [];
+
+// Node
+const getChildren = (node) => (node && getValues(node.children)) || [];
+
+const getSiblings =
+  (parent /*: Node */) => (node /*: Node */) /*: $ReadOnlyArray<Node> */ =>
+    getChildren(parent).filter(not(eq(node)));
+
+const concatAll =
+  /* ::<T> */
+
+
+    (xs /*: $ReadOnlyArray<T> */) =>
+    (ys /* : $ReadOnlyArray<T> */) /* : $ReadOnlyArray<T> */ =>
+      ys.reduce((zs, z) => zs.concat(z), xs);
+
+export { concatAll, getChildren, getErrors, getSiblings, isAnyOfError, isEnumError, isRequiredError, notUndefined };

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

@@ -1 +1,20 @@
-import t from"./base.js";class e extends t{constructor(...t){super(...t),this.name="AdditionalPropValidationError",this.options.isIdentifierLocation=!0}getError(){const{params:t}=this.options;return{message:`Property ${t.additionalProperty} is not expected to be here`,path:this.instancePath}}}export{e as default};
+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,
+    }
+  }
+}
+
+export { AdditionalPropValidationError as default };

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

@@ -1 +1,34 @@
-class t{constructor(t={isIdentifierLocation:!1},{data:s,schema:o,jsonAst:i,jsonRaw:n}){this.options=t,this.data=s,this.schema=o,this.jsonAst=i,this.jsonRaw=n}get instancePath(){return void 0!==this.options.instancePath?this.options.instancePath:this.options.dataPath}getError(){throw new Error(`Implement the 'getError' method inside ${this.constructor.name}!`)}}export{t as default};
+// import { codeFrameColumns } from '@babel/code-frame';
+// import chalk from 'chalk';
+// import { getMetaFromPath } from '../json/index'
+
+class BaseValidationError {
+  // eslint-disable-next-line default-param-last
+  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 };

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

@@ -1 +1,20 @@
-import s from"./base.js";class t extends s{constructor(...s){super(...s),this.name="DefaultValidationError",this.options.isSkipEndLocation=!0}getError(){const{keyword:s,message:t}=this.options;return{message:`${s} ${t}`,path:this.instancePath}}}export{t as default};
+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,
+    }
+  }
+}
+
+export { DefaultValidationError as default };

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

@@ -1 +1,58 @@
-import t from"jsonpointer";import e from"leven";import s from"./base.js";class a extends s{constructor(...t){super(...t),this.name="EnumValidationError"}getError(){const{message:t,params:e}=this.options,s=this.findBestMatch(),a={message:`${t}: ${e.allowedValues.join(", ")}`,path:this.instancePath};return null!==s&&(a.suggestion=`Did you mean ${s}?`),a}findBestMatch(){const{params:{allowedValues:s}}=this.options,a=""===this.instancePath?this.data:t.get(this.data,this.instancePath);if(!a)return null;const i=s.map((t=>({value:t,weight:e(t,a.toString())}))).sort(((t,e)=>t.weight>e.weight?1:t.weight<e.weight?-1:0))[0];return 1===s.length||i.weight<i.value.length?i.value:null}}export{a as default};
+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}?`;
+    }
+
+    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
+  }
+}
+
+export { EnumValidationError as default };

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

@@ -1 +1,20 @@
-import t from"./base.js";class r extends t{constructor(...t){super(...t),this.name="PatternValidationError",this.options.isIdentifierLocation=!0}getError(){const{params:t,propertyName:r}=this.options;return{message:`Property "${r}" must match pattern ${t.pattern}`,path:this.instancePath}}}export{r as default};
+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,
+    }
+  }
+}
+
+export { PatternValidationError as default };

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

@@ -1 +1,19 @@
-import s from"./base.js";class t extends s{constructor(...s){super(...s),this.name="RequiredValidationError"}getError(){const{message:s}=this.options;return{message:`${s}`,path:this.instancePath}}}export{t as default};
+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,
+    }
+  }
+}
+
+export { RequiredValidationError as default };

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

@@ -1 +1,20 @@
-import t from"./base.js";class e extends t{constructor(...t){super(...t),this.name="UnevaluatedPropValidationError",this.options.isIdentifierLocation=!0}getError(){const{params:t}=this.options;return{message:`Property ${t.unevaluatedProperty} is not expected to be here`,path:this.instancePath}}}export{e as default};
+import BaseValidationError from './base.js';
+
+class UnevaluatedPropValidationError extends BaseValidationError {
+  constructor(...args) {
+    super(...args);
+    this.name = 'UnevaluatedPropValidationError';
+    this.options.isIdentifierLocation = true;
+  }
+
+  getError() {
+    const { params } = this.options;
+
+    return {
+      message: `Property ${params.unevaluatedProperty} is not expected to be here`,
+      path: this.instancePath,
+    }
+  }
+}
+
+export { UnevaluatedPropValidationError as default };

package/dist/utils/dereference.js

@@ -1 +1,21 @@
-import{details as e}from"./details.js";import{getEntrypoint as r}from"./getEntrypoint.js";import{makeFilesystem as o}from"./makeFilesystem.js";import{resolveReferences as s}from"./resolveReferences.js";async function i(i,t){const c=o(i),m=r(c),n=s(c,t);return{specification:m.specification,errors:n.errors,schema:n.schema,...e(m.specification)}}export{i as dereference};
+import { details } from './details.js';
+import { getEntrypoint } from './getEntrypoint.js';
+import { makeFilesystem } from './makeFilesystem.js';
+import { resolveReferences } from './resolveReferences.js';
+
+/**
+ * Validates an OpenAPI schema and resolves all references.
+ */
+async function dereference(value, options) {
+    const filesystem = makeFilesystem(value);
+    const entrypoint = getEntrypoint(filesystem);
+    const result = resolveReferences(filesystem, options);
+    return {
+        specification: entrypoint.specification,
+        errors: result.errors,
+        schema: result.schema,
+        ...details(entrypoint.specification),
+    };
+}
+
+export { dereference };

package/dist/utils/details.js

@@ -1 +1,25 @@
-import{OpenApiVersions as i}from"../configuration/index.js";function o(o){for(const n of new Set(i)){const i="2.0"===n?"swagger":"openapi",e=o[i];if("string"==typeof e&&e.startsWith(n))return{version:n,specificationType:i,specificationVersion:e}}return{version:void 0,specificationType:void 0,specificationVersion:void 0}}export{o as details};
+import { OpenApiVersions } from '../configuration/index.js';
+
+/**
+ * Get versions of the OpenAPI specification.
+ */
+function details(specification) {
+    for (const version of new Set(OpenApiVersions)) {
+        const specificationType = version === '2.0' ? 'swagger' : 'openapi';
+        const value = specification[specificationType];
+        if (typeof value === 'string' && value.startsWith(version)) {
+            return {
+                version: version,
+                specificationType,
+                specificationVersion: value,
+            };
+        }
+    }
+    return {
+        version: undefined,
+        specificationType: undefined,
+        specificationVersion: undefined,
+    };
+}
+
+export { details };

package/dist/utils/escapeJsonPointer.js

@@ -1 +1,10 @@
-function e(e){return e.replace(/~/g,"~0").replace(/\//g,"~1")}export{e as escapeJsonPointer};
+/**
+ * Escapes a JSON pointer string.
+ *
+ * Example: `/foo/bar~baz` -> `/foo~1bar~0baz`
+ */
+function escapeJsonPointer(str) {
+    return str.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+
+export { escapeJsonPointer };

package/dist/utils/filter.js

@@ -1 +1,17 @@
-import{getEntrypoint as t}from"./getEntrypoint.js";import{makeFilesystem as i}from"./makeFilesystem.js";import{traverse as o}from"./traverse.js";function r(r,e){const s=i(r);return{specification:o(t(s).specification,(t=>e(t)?t:void 0))}}export{r as filter};
+import { getEntrypoint } from './getEntrypoint.js';
+import { makeFilesystem } from './makeFilesystem.js';
+import { traverse } from './traverse.js';
+
+/**
+ * Filter the specification based on the callback
+ */
+function filter(specification, callback) {
+    const filesystem = makeFilesystem(specification);
+    return {
+        specification: traverse(getEntrypoint(filesystem).specification, (schema) => {
+            return callback(schema) ? schema : undefined;
+        }),
+    };
+}
+
+export { filter };

package/dist/utils/getEntrypoint.js

@@ -1 +1,8 @@
-function n(n){return n?.find((n=>n.isEntrypoint))}export{n as getEntrypoint};
+/**
+ * Return just the entrypoint of the filesystem.
+ */
+function getEntrypoint(filesystem) {
+    return filesystem?.find((file) => file.isEntrypoint);
+}
+
+export { getEntrypoint };

package/dist/utils/getListOfReferences.js

@@ -1 +1,27 @@
-import{traverse as t}from"./traverse.js";function e(e){const r=[];return e&&"object"==typeof e?(t(e,(t=>(t.$ref&&"string"==typeof t.$ref&&!t.$ref.startsWith("#")&&r.push(t.$ref.split("#")[0]),t))),[...new Set(r)]):r}export{e as getListOfReferences};
+import { traverse } from './traverse.js';
+
+/**
+ * Walks through the specification and returns all references as an array.
+ *
+ * Warning: Doesn’t return internal references.
+ */
+function getListOfReferences(specification) {
+    const references = [];
+    // Make sure we’re dealing with an object
+    if (!specification || typeof specification !== 'object') {
+        return references;
+    }
+    // Traverse the specification and collect all references
+    traverse(specification, (value) => {
+        if (value.$ref &&
+            typeof value.$ref === 'string' &&
+            !value.$ref.startsWith('#')) {
+            references.push(value.$ref.split('#')[0]);
+        }
+        return value;
+    });
+    // Remove duplicates
+    return [...new Set(references)];
+}
+
+export { getListOfReferences };

package/dist/utils/getSegmentsFromPath.js

@@ -1 +1,18 @@
-import{unescapeJsonPointer as e}from"./unescapeJsonPointer.js";function n(n){return n.split("/").slice(1).map(e)}export{n as getSegmentsFromPath};
+import { unescapeJsonPointer } from './unescapeJsonPointer.js';
+
+/**
+ * Translate `/paths/~1test` to `['paths', '/test']`
+ */
+function getSegmentsFromPath(path) {
+    return (
+    // /paths/~1test
+    path
+        // ['', 'paths', '~1test']
+        .split('/')
+        // ['paths', '~test']
+        .slice(1)
+        // ['paths', '/test']
+        .map(unescapeJsonPointer));
+}
+
+export { getSegmentsFromPath };

package/dist/utils/isFilesystem.js

@@ -1 +1,11 @@
-function r(r){return void 0!==r&&Array.isArray(r)&&r.length>0&&r.some((r=>!0===r.isEntrypoint))}export{r as isFilesystem};
+/**
+ * Check if the value is a filesystem
+ */
+function isFilesystem(value) {
+    return (typeof value !== 'undefined' &&
+        Array.isArray(value) &&
+        value.length > 0 &&
+        value.some((file) => file.isEntrypoint === true));
+}
+
+export { isFilesystem };

package/dist/utils/isJson.js

@@ -1 +1,11 @@
-function r(r){try{return JSON.parse(r),!0}catch{return!1}}export{r as isJson};
+function isJson(value) {
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+export { isJson };

package/dist/utils/isObject.js

@@ -1 +1,6 @@
-const r=r=>"object"==typeof r&&!Array.isArray(r)&&null!==r;export{r as isObject};
+/**
+ * Check if the given value is an object
+ */
+const isObject = (obj) => typeof obj === 'object' && !Array.isArray(obj) && obj !== null;
+
+export { isObject };

package/dist/utils/isYaml.js

@@ -1 +1,19 @@
-import{parse as r}from"yaml";function t(t){if(!t.includes("\n"))return!1;try{return r(t,{maxAliasCount:1e4}),!0}catch(r){return!1}}export{t as isYaml};
+import { parse } from 'yaml';
+
+function isYaml(value) {
+    // Line breaks
+    if (!value.includes('\n')) {
+        return false;
+    }
+    try {
+        parse(value, {
+            maxAliasCount: 10000,
+        });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+
+export { isYaml };