@scalar/openapi-parser 0.8.6 → 0.8.8

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @scalar/openapi-parser
 
+## 0.8.8
+
+### Patch Changes
+
+- 7323370: Allow relative URLs in v3.1 documents
+
+## 0.8.7
+
+### Patch Changes
+
+- 6394a5d: chore: switch to @scalar/build-tooling
+
 ## 0.8.6
 
 ### Patch Changes

package/README.md

@@ -242,4 +242,4 @@ Thanks a ton for all the help and inspiration:
 
 ## License
 
-The source code in this repository is licensed under [MIT](https://github.com/scalar/openapi-parser/blob/main/LICENSE).
+The source code in this repository is licensed under [MIT](https://github.com/scalar/scalar/blob/main/LICENSE).

package/dist/configuration/index.js

@@ -1 +1,27 @@
-import e from"../schemas/v2.0/schema.json.js";import s from"../schemas/v3.0/schema.json.js";import n from"../schemas/v3.1/schema.json.js";const o={"2.0":e,"3.0":s,3.1:n},r=Object.keys(o),t={EMPTY_OR_INVALID:"Can’t find JSON, YAML or filename in data",OPENAPI_VERSION_NOT_SUPPORTED:"Can’t find supported Swagger/OpenAPI version in specification, version must be a string.",INVALID_REFERENCE:"Can’t resolve reference: %s",EXTERNAL_REFERENCE_NOT_FOUND:"Can’t resolve external reference: %s",FILE_DOES_NOT_EXIST:"File does not exist: %s",NO_CONTENT:"No content found"};export{t as ERRORS,o as OpenApiSpecifications,r as OpenApiVersions};
+import Swagger20 from '../schemas/v2.0/schema.json.js';
+import OpenApi30 from '../schemas/v3.0/schema.json.js';
+import OpenApi31 from '../schemas/v3.1/schema.json.js';
+
+/**
+ * A list of the supported OpenAPI specifications
+ */
+const OpenApiSpecifications = {
+    '2.0': Swagger20,
+    '3.0': OpenApi30,
+    '3.1': OpenApi31,
+};
+const OpenApiVersions = Object.keys(OpenApiSpecifications);
+/**
+ * List of error messages used in the Validator
+ */
+const ERRORS = {
+    EMPTY_OR_INVALID: 'Can’t find JSON, YAML or filename in data',
+    // URI_MUST_BE_STRING: 'uri parameter or $id attribute must be a string',
+    OPENAPI_VERSION_NOT_SUPPORTED: 'Can’t find supported Swagger/OpenAPI version in specification, version must be a string.',
+    INVALID_REFERENCE: 'Can’t resolve reference: %s',
+    EXTERNAL_REFERENCE_NOT_FOUND: 'Can’t resolve external reference: %s',
+    FILE_DOES_NOT_EXIST: 'File does not exist: %s',
+    NO_CONTENT: 'No content found',
+};
+
+export { ERRORS, OpenApiSpecifications, OpenApiVersions };

package/dist/index.js

@@ -1 +1,26 @@
-export{ERRORS,OpenApiSpecifications,OpenApiVersions}from"./configuration/index.js";export{Validator,jsonSchemaVersions}from"./lib/Validator/Validator.js";export{resolveReferences}from"./utils/resolveReferences.js";export{dereference}from"./utils/dereference.js";export{details}from"./utils/details.js";export{escapeJsonPointer}from"./utils/escapeJsonPointer.js";export{filter}from"./utils/filter.js";export{getEntrypoint}from"./utils/getEntrypoint.js";export{getListOfReferences}from"./utils/getListOfReferences.js";export{getSegmentsFromPath}from"./utils/getSegmentsFromPath.js";export{isFilesystem}from"./utils/isFilesystem.js";export{isJson}from"./utils/isJson.js";export{isObject}from"./utils/isObject.js";export{isYaml}from"./utils/isYaml.js";export{load}from"./utils/load/load.js";export{normalize}from"./utils/normalize.js";export{openapi}from"./utils/openapi/openapi.js";export{toJson}from"./utils/toJson.js";export{toYaml}from"./utils/toYaml.js";export{transformErrors}from"./utils/transformErrors.js";export{traverse}from"./utils/traverse.js";export{unescapeJsonPointer}from"./utils/unescapeJsonPointer.js";export{upgrade}from"./utils/upgrade.js";export{isSchemaPath,upgradeFromThreeToThreeOne}from"./utils/upgradeFromThreeToThreeOne.js";export{upgradeFromTwoToThree}from"./utils/upgradeFromTwoToThree.js";export{validate}from"./utils/validate.js";
+export { ERRORS, OpenApiSpecifications, OpenApiVersions } from './configuration/index.js';
+export { Validator, jsonSchemaVersions } from './lib/Validator/Validator.js';
+export { resolveReferences } from './utils/resolveReferences.js';
+export { dereference } from './utils/dereference.js';
+export { details } from './utils/details.js';
+export { escapeJsonPointer } from './utils/escapeJsonPointer.js';
+export { filter } from './utils/filter.js';
+export { getEntrypoint } from './utils/getEntrypoint.js';
+export { getListOfReferences } from './utils/getListOfReferences.js';
+export { getSegmentsFromPath } from './utils/getSegmentsFromPath.js';
+export { isFilesystem } from './utils/isFilesystem.js';
+export { isJson } from './utils/isJson.js';
+export { isObject } from './utils/isObject.js';
+export { isYaml } from './utils/isYaml.js';
+export { load } from './utils/load/load.js';
+export { normalize } from './utils/normalize.js';
+export { openapi } from './utils/openapi/openapi.js';
+export { toJson } from './utils/toJson.js';
+export { toYaml } from './utils/toYaml.js';
+export { transformErrors } from './utils/transformErrors.js';
+export { traverse } from './utils/traverse.js';
+export { unescapeJsonPointer } from './utils/unescapeJsonPointer.js';
+export { upgrade } from './utils/upgrade.js';
+export { isSchemaPath, upgradeFromThreeToThreeOne } from './utils/upgradeFromThreeToThreeOne.js';
+export { upgradeFromTwoToThree } from './utils/upgradeFromTwoToThree.js';
+export { validate } from './utils/validate.js';

package/dist/lib/Validator/Validator.js

@@ -1 +1,127 @@
-import r from"ajv-draft-04";import i from"ajv-formats";import o from"ajv/dist/2020.js";import{OpenApiVersions as s,ERRORS as t,OpenApiSpecifications as e}from"../../configuration/index.js";import{details as a}from"../../utils/details.js";import{resolveReferences as n}from"../../utils/resolveReferences.js";import{transformErrors as c}from"../../utils/transformErrors.js";const f={"http://json-schema.org/draft-04/schema#":r,"https://json-schema.org/draft/2020-12/schema":o};class h{version;static supportedVersions=s;ajvValidators={};errors;specificationVersion;specificationType;specification;async validate(r,i){const o=r.find((r=>r.isEntrypoint)),s=o?.specification;this.specification=s,this.specification?.info&&!this.specification.info.version&&(this.specification.info.version="0.0.1");try{if(null==s){if(i?.throwOnError)throw new Error(t.EMPTY_OR_INVALID);return{valid:!1,errors:c(o,t.EMPTY_OR_INVALID)}}const{version:e,specificationType:f,specificationVersion:h}=a(s);if(this.version=e,this.specificationVersion=h,this.specificationType=f,!e){if(i?.throwOnError)throw new Error(t.OPENAPI_VERSION_NOT_SUPPORTED);return{valid:!1,errors:c(o,t.OPENAPI_VERSION_NOT_SUPPORTED)}}const p=await this.getAjvValidator(e),m=p(s);if(p.errors&&p.errors.length>0){if(i?.throwOnError)throw new Error(p.errors[0]);return{valid:!1,errors:c(o,p.errors)}}const d=n(r,i);return{valid:m&&d.valid,errors:[...m.errors??[],...d.errors],schema:d.schema}}catch(r){if(i?.throwOnError)throw r;return{valid:!1,errors:c(o,r.message??r)}}}async getAjvValidator(r){if(this.ajvValidators[r])return this.ajvValidators[r];const o=e[r],s=new(0,f[o.$schema])({strict:!1});return i(s),"3.1"===r&&s.addFormat("media-range",!0),this.ajvValidators[r]=s.compile(o)}}export{h as Validator,f as jsonSchemaVersions};
+import Ajv04 from 'ajv-draft-04';
+import addFormats from 'ajv-formats';
+import Ajv2020 from 'ajv/dist/2020.js';
+import { OpenApiVersions, ERRORS, OpenApiSpecifications } from '../../configuration/index.js';
+import { details } from '../../utils/details.js';
+import { resolveReferences } from '../../utils/resolveReferences.js';
+import { transformErrors } from '../../utils/transformErrors.js';
+
+/**
+ * Configure available JSON Schema versions
+ */
+const jsonSchemaVersions = {
+    'http://json-schema.org/draft-04/schema#': Ajv04,
+    'https://json-schema.org/draft/2020-12/schema': Ajv2020,
+};
+class Validator {
+    version;
+    static supportedVersions = OpenApiVersions;
+    // Object with function *or* object { errors: string }
+    ajvValidators = {};
+    errors;
+    specificationVersion;
+    specificationType;
+    specification;
+    /**
+     * Checks whether a specification is valid and all references can be resolved.
+     */
+    async validate(filesystem, options) {
+        const entrypoint = filesystem.find((file) => file.isEntrypoint);
+        const specification = entrypoint?.specification;
+        // TODO: How does this work with a filesystem?
+        this.specification = specification;
+        // TODO: defaulting info.version to keep parser compatible with the previous one
+        // we should bubble this error up and not throw on it
+        if (this.specification?.info && !this.specification.info.version) {
+            this.specification.info.version = '0.0.1';
+        }
+        try {
+            // AnyObject is empty or invalid
+            if (specification === undefined || specification === null) {
+                if (options?.throwOnError) {
+                    throw new Error(ERRORS.EMPTY_OR_INVALID);
+                }
+                return {
+                    valid: false,
+                    errors: transformErrors(entrypoint, ERRORS.EMPTY_OR_INVALID),
+                };
+            }
+            // Meta data about the specification
+            const { version, specificationType, specificationVersion } = details(specification);
+            this.version = version;
+            this.specificationVersion = specificationVersion;
+            this.specificationType = specificationType;
+            // AnyObject is not supported
+            if (!version) {
+                if (options?.throwOnError) {
+                    throw new Error(ERRORS.OPENAPI_VERSION_NOT_SUPPORTED);
+                }
+                return {
+                    valid: false,
+                    errors: transformErrors(entrypoint, ERRORS.OPENAPI_VERSION_NOT_SUPPORTED),
+                };
+            }
+            // Get the correct OpenAPI validator
+            const validateSchema = await this.getAjvValidator(version);
+            const schemaResult = validateSchema(specification);
+            // Error handling
+            if (validateSchema.errors) {
+                if (validateSchema.errors.length > 0) {
+                    if (options?.throwOnError) {
+                        throw new Error(validateSchema.errors[0]);
+                    }
+                    return {
+                        valid: false,
+                        errors: transformErrors(entrypoint, validateSchema.errors),
+                    };
+                }
+            }
+            // Check if the references are valid
+            const resolvedReferences = resolveReferences(filesystem, options);
+            return {
+                valid: schemaResult && resolvedReferences.valid,
+                errors: [...(schemaResult.errors ?? []), ...resolvedReferences.errors],
+                schema: resolvedReferences.schema,
+            };
+        }
+        catch (error) {
+            // Something went horribly wrong!
+            if (options?.throwOnError) {
+                throw error;
+            }
+            return {
+                valid: false,
+                errors: transformErrors(entrypoint, error.message ?? error),
+            };
+        }
+    }
+    /**
+     * Ajv JSON schema validator
+     */
+    async getAjvValidator(version) {
+        // Schema loaded already
+        if (this.ajvValidators[version]) {
+            return this.ajvValidators[version];
+        }
+        // Load OpenAPI Schema
+        const schema = OpenApiSpecifications[version];
+        // Load JSON Schema
+        const AjvClass = jsonSchemaVersions[schema.$schema];
+        // Get the correct Ajv validator
+        const ajv = new AjvClass({
+            // Ajv is a bit too strict in its strict validation of OpenAPI schemas.
+            // Switch strict mode off.
+            strict: false,
+        });
+        // Register formats
+        // https://ajv.js.org/packages/ajv-formats.html#formats
+        addFormats(ajv);
+        // OpenAPI 3.1 uses media-range format
+        if (version === '3.1') {
+            ajv.addFormat('media-range', true);
+        }
+        return (this.ajvValidators[version] = ajv.compile(schema));
+    }
+}
+
+export { Validator, jsonSchemaVersions };

package/dist/{utils/load/plugins → plugins/fetch-urls}/fetchUrls.d.ts

@@ -1,4 +1,4 @@
-import type { LoadPlugin } from '../load.js';
+import type { LoadPlugin } from '../../utils/load';
 export declare const fetchUrlsDefaultConfiguration: {
     limit: number;
 };

package/dist/plugins/fetch-urls/fetchUrls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchUrls.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch-urls/fetchUrls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,eAAO,MAAM,6BAA6B;;CAEzC,CAAA;AAED,eAAO,MAAM,SAAS,EAAE,CAAC,mBAAmB,CAAC,EAAE;IAC7C;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAAA;IACtB;;OAEG;IACH,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CAC3C,KAAK,UAiDL,CAAA"}

package/dist/plugins/fetch-urls/fetchUrls.js

@@ -0,0 +1,45 @@
+const fetchUrlsDefaultConfiguration = {
+    limit: 20,
+};
+const fetchUrls = (customConfiguration) => {
+    // State
+    let numberOfRequests = 0;
+    // Configuration
+    const configuration = {
+        ...fetchUrlsDefaultConfiguration,
+        ...customConfiguration,
+    };
+    return {
+        check(value) {
+            // Not a string
+            if (typeof value !== 'string') {
+                return false;
+            }
+            // Not http/https
+            if (!value.startsWith('http://') && !value.startsWith('https://')) {
+                return false;
+            }
+            return true;
+        },
+        async get(value) {
+            // Limit ht enumber of requests
+            if (configuration?.limit !== false &&
+                numberOfRequests >= configuration?.limit) {
+                console.warn(`[fetchUrls] Maximum number of requests reeached (${configuration?.limit}), skipping request`);
+                return undefined;
+            }
+            try {
+                numberOfRequests++;
+                const response = await (configuration?.fetch
+                    ? configuration.fetch(value)
+                    : fetch(value));
+                return await response.text();
+            }
+            catch (error) {
+                console.error('[fetchUrls]', error.message, `(${value})`);
+            }
+        },
+    };
+};
+
+export { fetchUrls, fetchUrlsDefaultConfiguration };

package/dist/plugins/fetch-urls/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fetchUrls.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/fetch-urls/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch-urls/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/dist/plugins/fetch-urls/index.js

@@ -0,0 +1 @@
+export { fetchUrls, fetchUrlsDefaultConfiguration } from './fetchUrls.js';

package/dist/plugins/read-files/index.d.ts

@@ -0,0 +1,2 @@
+export * from './readFiles.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/read-files/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/read-files/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/dist/plugins/read-files/index.js

@@ -0,0 +1 @@
+export { readFiles } from './readFiles.js';

package/dist/plugins/read-files/readFiles.d.ts

@@ -0,0 +1,3 @@
+import type { LoadPlugin } from '../../utils/load';
+export declare const readFiles: () => LoadPlugin;
+//# sourceMappingURL=readFiles.d.ts.map

package/dist/plugins/read-files/readFiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readFiles.d.ts","sourceRoot":"","sources":["../../../src/plugins/read-files/readFiles.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,eAAO,MAAM,SAAS,EAAE,MAAM,UAoD7B,CAAA"}

package/dist/plugins/read-files/readFiles.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs';
+import { ERRORS } from '../../configuration/index.js';
+import { dirname, join } from '../../polyfills/path.js';
+import { isJson } from '../../utils/isJson.js';
+import { isYaml } from '../../utils/isYaml.js';
+
+const readFiles = () => {
+    return {
+        check(value) {
+            // Not a string
+            if (typeof value !== 'string') {
+                return false;
+            }
+            // URL
+            if (value.startsWith('http://') || value.startsWith('https://')) {
+                return false;
+            }
+            // Line breaks
+            if (value.includes('\n')) {
+                return false;
+            }
+            // JSON
+            if (isJson(value)) {
+                return false;
+            }
+            // YAML (run through YAML.parse)
+            if (isYaml(value)) {
+                return false;
+            }
+            return true;
+        },
+        async get(value) {
+            if (!fs.existsSync(value)) {
+                throw new Error(ERRORS.FILE_DOES_NOT_EXIST.replace('%s', value));
+            }
+            try {
+                return fs.readFileSync(value, 'utf-8');
+            }
+            catch (error) {
+                console.error('[readFiles]', error);
+            }
+        },
+        resolvePath(value, reference) {
+            const dir = dirname(value);
+            return join(dir, reference);
+        },
+        getDir(value) {
+            return dirname(value);
+        },
+        getFilename(value) {
+            return value.split('/').pop();
+        },
+    };
+};
+
+export { readFiles };

package/dist/polyfills/path.js

@@ -1 +1,120 @@
-const t=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^/]+?|)(\.[^./]*|))(?:[/]*)$/;function n(t){const n=r(t),e="/"===s(t,-1);return(t=function(t,n){let r=0;for(let n=t.length-1;n>=0;n--){const e=t[n];"."===e?t.splice(n,1):".."===e?(t.splice(n,1),r++):r&&(t.splice(n,1),r--)}if(n)for(;r--;r)t.unshift("..");return t}(o(t.split("/"),(function(t){return!!t})),!n).join("/"))||n||(t="."),t&&e&&(t+="/"),(n?"/":"")+t}function r(t){return"/"===t.charAt(0)}function e(...t){return n(o(t,(function(t,n){if("string"!=typeof t)throw new TypeError("Arguments to path.join must be strings");return t})).join("/"))}function u(n){const r=(u=n,t.exec(u).slice(1)),e=r[0];var u;let o=r[1];return e||o?(o&&(o=o.substr(0,o.length-1)),e+o):"."}function o(t,n){if(t.filter)return t.filter(n);const r=[];for(let e=0;e<t.length;e++)n(t[e],e,t)&&r.push(t[e]);return r}const s="b"==="ab".substr(-1)?function(t,n,r){return t.substr(n,r)}:function(t,n,r){return n<0&&(n=t.length+n),t.substr(n,r)};export{u as dirname,r as isAbsolute,e as join,n as normalize};
+// @ts-nocheck
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+// resolves . and .. elements in a path array with directory names there
+// must be no slashes, empty elements, or device names (c:\) in the array
+// (so also no leading and trailing slashes - it does not distinguish
+// relative and absolute paths)
+function normalizeArray(parts, allowAboveRoot) {
+    // if the path tries to go above the root, `up` ends up > 0
+    let up = 0;
+    for (let i = parts.length - 1; i >= 0; i--) {
+        const last = parts[i];
+        if (last === '.') {
+            parts.splice(i, 1);
+        }
+        else if (last === '..') {
+            parts.splice(i, 1);
+            up++;
+        }
+        else if (up) {
+            parts.splice(i, 1);
+            up--;
+        }
+    }
+    // if the path is allowed to go above the root, restore leading ..s
+    if (allowAboveRoot) {
+        for (; up--; up) {
+            parts.unshift('..');
+        }
+    }
+    return parts;
+}
+// Split a filename into [root, dir, basename, ext], unix version
+// 'root' is just a slash, or nothing.
+const splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^/]+?|)(\.[^./]*|))(?:[/]*)$/;
+const splitPath = function (filename) {
+    return splitPathRe.exec(filename).slice(1);
+};
+// path.normalize(path)
+// posix version
+function normalize(path) {
+    const isPathAbsolute = isAbsolute(path), trailingSlash = substr(path, -1) === '/';
+    // Normalize the path
+    path = normalizeArray(filter(path.split('/'), function (p) {
+        return !!p;
+    }), !isPathAbsolute).join('/');
+    if (!path && !isPathAbsolute) {
+        path = '.';
+    }
+    if (path && trailingSlash) {
+        path += '/';
+    }
+    return (isPathAbsolute ? '/' : '') + path;
+}
+// posix version
+function isAbsolute(path) {
+    return path.charAt(0) === '/';
+}
+// posix version
+function join(...paths) {
+    return normalize(filter(paths, function (p, index) {
+        if (typeof p !== 'string') {
+            throw new TypeError('Arguments to path.join must be strings');
+        }
+        return p;
+    }).join('/'));
+}
+function dirname(path) {
+    const result = splitPath(path), root = result[0];
+    let dir = result[1];
+    if (!root && !dir) {
+        // No dirname whatsoever
+        return '.';
+    }
+    if (dir) {
+        // It has a dirname, strip trailing slash
+        dir = dir.substr(0, dir.length - 1);
+    }
+    return root + dir;
+}
+function filter(xs, f) {
+    if (xs.filter)
+        return xs.filter(f);
+    const res = [];
+    for (let i = 0; i < xs.length; i++) {
+        if (f(xs[i], i, xs))
+            res.push(xs[i]);
+    }
+    return res;
+}
+// String.prototype.substr - negative index don't work in IE8
+const substr = 'ab'.substr(-1) === 'b'
+    ? function (str, start, len) {
+        return str.substr(start, len);
+    }
+    : function (str, start, len) {
+        if (start < 0)
+            start = str.length + start;
+        return str.substr(start, len);
+    };
+
+export { dirname, isAbsolute, join, normalize };