@scalar/openapi-parser 0.8.6 → 0.8.8

package/dist/utils/resolveReferences.js

@@ -1 +1,153 @@
-import{ERRORS as e}from"../configuration/index.js";import{getEntrypoint as r}from"./getEntrypoint.js";import{getSegmentsFromPath as t}from"./getSegmentsFromPath.js";import{makeFilesystem as o}from"./makeFilesystem.js";function i(e,t,i,E){void 0===E&&(E=[]);const s=structuredClone(e),c=o(s),f=r(c);return a(i?.specification??f.specification,c,i??f),a(i?.specification??f.specification,c,i??f),{valid:0===(E=E.filter(((e,r,t)=>r===t.findIndex((r=>r.message===e.message&&r.code===e.code))))).length,errors:E,schema:(i??r(c)).specification};function a(e,r,o){let i;return Object.entries(e??{}).forEach((([s,c])=>{if(void 0!==e.$ref){const i=n(e.$ref,t,o,r,E);if(void 0===i)return;delete e.$ref,"object"==typeof i&&Object.keys(i).forEach((r=>{void 0===e[r]&&(e[r]=i[r])}))}"object"!=typeof c||function(e){try{return JSON.stringify(e),!1}catch(e){return!0}}(c)||(i=a(c,r,o))})),{errors:i?.errors??[]}}}function n(r,o,E,s,c){if("string"!=typeof r){if(o?.throwOnError)throw new Error(e.INVALID_REFERENCE.replace("%s",r));return void c.push({code:"INVALID_REFERENCE",message:e.INVALID_REFERENCE.replace("%s",r)})}const[f,a]=r.split("#",2),p=f!==E.filename;if(f&&p){const r=s.find((e=>e.filename===f));if(!r){if(o?.throwOnError)throw new Error(e.EXTERNAL_REFERENCE_NOT_FOUND.replace("%s",f));return void c.push({code:"EXTERNAL_REFERENCE_NOT_FOUND",message:e.EXTERNAL_REFERENCE_NOT_FOUND.replace("%s",f)})}const t=i(s,o,r,c);return void 0===a?t.schema:n(`#${a}`,o,r,s,c)}const N=t(a);try{return N.reduce(((e,r)=>e[r]),E.specification)}catch(t){if(o?.throwOnError)throw new Error(e.INVALID_REFERENCE.replace("%s",r));c.push({code:"INVALID_REFERENCE",message:e.INVALID_REFERENCE.replace("%s",r)})}}export{i as resolveReferences};
+import { ERRORS } from '../configuration/index.js';
+import { getEntrypoint } from './getEntrypoint.js';
+import { getSegmentsFromPath } from './getSegmentsFromPath.js';
+import { makeFilesystem } from './makeFilesystem.js';
+
+/**
+ * Takes a specification and resolves all references.
+ */
+function resolveReferences(
+// Just a specification, or a set of files.
+input, 
+// Additional options to control the behaviour
+options, 
+// Fallback to the entrypoint
+file, 
+// Errors that occurred during the process
+errors) {
+    // Initialize errors
+    if (errors === undefined) {
+        errors = [];
+    }
+    // Detach from input
+    const clonedInput = structuredClone(input);
+    // Make it a filesystem, even if it’s just one file
+    const filesystem = makeFilesystem(clonedInput);
+    // Get the main file
+    const entrypoint = getEntrypoint(filesystem);
+    // Recursively resolve all references
+    resolve(file?.specification ?? entrypoint.specification, filesystem, file ?? entrypoint);
+    // If we replace references with content, that includes a reference, we can’t deal with that right-away.
+    // That’s why we need a second run.
+    resolve(file?.specification ?? entrypoint.specification, filesystem, file ?? entrypoint);
+    // Remove duplicats (according to message) from errors
+    errors = errors.filter((error, index, self) => index ===
+        self.findIndex((t) => t.message === error.message && t.code === error.code));
+    // Return the resolved specification
+    return {
+        valid: errors.length === 0,
+        errors: errors,
+        schema: (file ?? getEntrypoint(filesystem))
+            .specification,
+    };
+    /**
+     * Resolves the circular reference to an object and deletes the $ref properties.
+     */
+    function resolve(schema, resolveFilesystem, resolveFile) {
+        let result;
+        // Iterate over the whole objecct
+        Object.entries(schema ?? {}).forEach(([_, value]) => {
+            // Ignore parts without a reference
+            if (schema.$ref !== undefined) {
+                // Find the referenced content
+                const target = resolveUri(schema.$ref, options, resolveFile, resolveFilesystem, errors);
+                if (target === undefined) {
+                    return undefined;
+                }
+                // Get rid of the reference
+                delete schema.$ref;
+                if (typeof target === 'object') {
+                    Object.keys(target).forEach((key) => {
+                        if (schema[key] === undefined) {
+                            schema[key] = target[key];
+                        }
+                    });
+                }
+            }
+            if (typeof value === 'object' && !isCircular(value)) {
+                result = resolve(value, resolveFilesystem, resolveFile);
+            }
+        });
+        return {
+            errors: result?.errors ?? [],
+        };
+    }
+}
+// TODO: Is there a better way? :D
+function isCircular(schema) {
+    try {
+        JSON.stringify(schema);
+        return false;
+    }
+    catch (error) {
+        return true;
+    }
+}
+/**
+ * Resolves a URI to a part of the specification
+ */
+function resolveUri(
+// 'foobar.json#/foo/bar'
+uri, options, 
+// { filename: './foobar.json '}
+file, 
+// [ { filename: './foobar.json '} ]
+filesystem, errors) {
+    // Ignore invalid URIs
+    if (typeof uri !== 'string') {
+        if (options?.throwOnError) {
+            throw new Error(ERRORS.INVALID_REFERENCE.replace('%s', uri));
+        }
+        errors.push({
+            code: 'INVALID_REFERENCE',
+            message: ERRORS.INVALID_REFERENCE.replace('%s', uri),
+        });
+        return;
+    }
+    // Understand the URI
+    const [prefix, path] = uri.split('#', 2);
+    /** Check whether the file is pointing to itself */
+    const isDifferentFile = prefix !== file.filename;
+    // External references
+    if (prefix && isDifferentFile) {
+        const externalReference = filesystem.find((entry) => {
+            return entry.filename === prefix;
+        });
+        if (!externalReference) {
+            if (options?.throwOnError) {
+                throw new Error(ERRORS.EXTERNAL_REFERENCE_NOT_FOUND.replace('%s', prefix));
+            }
+            errors.push({
+                code: 'EXTERNAL_REFERENCE_NOT_FOUND',
+                message: ERRORS.EXTERNAL_REFERENCE_NOT_FOUND.replace('%s', prefix),
+            });
+            return;
+        }
+        const result = resolveReferences(filesystem, options, externalReference, errors);
+        // $ref: 'other-file.yaml'
+        if (path === undefined) {
+            return result.schema;
+        }
+        // $ref: 'other-file.yaml#/foo/bar'
+        return resolveUri(`#${path}`, options, externalReference, filesystem, errors);
+    }
+    // Pointers
+    const segments = getSegmentsFromPath(path);
+    // Try to find the URI
+    try {
+        return segments.reduce((acc, key) => {
+            return acc[key];
+        }, file.specification);
+    }
+    catch (error) {
+        if (options?.throwOnError) {
+            throw new Error(ERRORS.INVALID_REFERENCE.replace('%s', uri));
+        }
+        errors.push({
+            code: 'INVALID_REFERENCE',
+            message: ERRORS.INVALID_REFERENCE.replace('%s', uri),
+        });
+    }
+}
+
+export { resolveReferences };

package/dist/utils/toJson.js

@@ -1 +1,3 @@
-const n=n=>JSON.stringify(n,null,2);export{n as toJson};
+const toJson = (value) => JSON.stringify(value, null, 2);
+
+export { toJson };

package/dist/utils/toYaml.js

@@ -1 +1,5 @@
-import{stringify as o}from"yaml";const m=m=>o(m);export{m as toYaml};
+import { stringify } from 'yaml';
+
+const toYaml = (value) => stringify(value);
+
+export { toYaml };

package/dist/utils/transformErrors.js

@@ -1 +1,23 @@
-import{betterAjvErrors as e}from"./betterAjvErrors/index.js";function r(r,t){return"string"==typeof t?[{message:t}]:e(r,null,t,{indent:2}).map((e=>(e.message=e.message.trim(),e)))}export{r as transformErrors};
+import { betterAjvErrors } from './betterAjvErrors/index.js';
+
+/**
+ * Transforms ajv errors, finds the positions in the schema and returns an enriched format.
+ */
+function transformErrors(specification, errors) {
+    // TODO: This should work with multiple files
+    if (typeof errors === 'string') {
+        return [
+            {
+                message: errors,
+            },
+        ];
+    }
+    return betterAjvErrors(specification, null, errors, {
+        indent: 2,
+    }).map((error) => {
+        error.message = error.message.trim();
+        return error;
+    });
+}
+
+export { transformErrors };

package/dist/utils/traverse.js

@@ -1 +1,26 @@
-function t(o,n,r=[]){const e={};for(const[c,f]of Object.entries(o)){const o=[...r,c];Array.isArray(f)?e[c]=f.map(((r,e)=>"object"==typeof r&&null!==r?t(r,n,[...o,e.toString()]):r)):e[c]="object"==typeof f&&null!==f?t(f,n,o):f}return n(e,r)}export{t as traverse};
+/**
+ * Recursively traverses the specification and applies the transform function to each node.
+ */
+function traverse(specification, transform, path = []) {
+    const result = {};
+    for (const [key, value] of Object.entries(specification)) {
+        const currentPath = [...path, key];
+        if (Array.isArray(value)) {
+            result[key] = value.map((item, index) => {
+                if (typeof item === 'object' && item !== null) {
+                    return traverse(item, transform, [...currentPath, index.toString()]);
+                }
+                return item;
+            });
+        }
+        else if (typeof value === 'object' && value !== null) {
+            result[key] = traverse(value, transform, currentPath);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return transform(result, path);
+}
+
+export { traverse };

package/dist/utils/unescapeJsonPointer.js

@@ -1 +1,11 @@
-function e(e){return decodeURI(e.replace(/~1/g,"/").replace(/~0/g,"~"))}export{e as unescapeJsonPointer};
+/**
+ * Unescape JSON pointer
+ *
+ * Examples:
+ * /foo~1bar~0baz -> /foo/bar~baz
+ */
+function unescapeJsonPointer(uri) {
+    return decodeURI(uri.replace(/~1/g, '/').replace(/~0/g, '~'));
+}
+
+export { unescapeJsonPointer };

package/dist/utils/upgrade.js

@@ -1 +1,20 @@
-import{getEntrypoint as r}from"./getEntrypoint.js";import{makeFilesystem as e}from"./makeFilesystem.js";import{upgradeFromThreeToThreeOne as o}from"./upgradeFromThreeToThreeOne.js";import{upgradeFromTwoToThree as i}from"./upgradeFromTwoToThree.js";function t(t){return{specification:[i,o].reduce(((r,e)=>e(r)),r(e(t)).specification),version:"3.1"}}export{t as upgrade};
+import { getEntrypoint } from './getEntrypoint.js';
+import { makeFilesystem } from './makeFilesystem.js';
+import { upgradeFromThreeToThreeOne } from './upgradeFromThreeToThreeOne.js';
+import { upgradeFromTwoToThree } from './upgradeFromTwoToThree.js';
+
+/**
+ * Upgrade specification to OpenAPI 3.1.0
+ */
+function upgrade(value) {
+    const upgraders = [upgradeFromTwoToThree, upgradeFromThreeToThreeOne];
+    // TODO: Run upgrade over the whole filesystem
+    const result = upgraders.reduce((currentSpecification, upgrader) => upgrader(currentSpecification), getEntrypoint(makeFilesystem(value)).specification);
+    return {
+        specification: result,
+        // TODO: Make dynamic
+        version: '3.1',
+    };
+}
+
+export { upgrade };

package/dist/utils/upgradeFromThreeToThreeOne.js

@@ -1 +1,122 @@
-import{traverse as e}from"./traverse.js";function t(t){let m=t;return m.openapi?.startsWith("3.0")?(m.openapi="3.1.0",m=e(m,(e=>("undefined"!==e.type&&!0===e.nullable&&(e.type=["null",e.type],delete e.nullable),e))),m=e(m,(e=>(!0===e.exclusiveMinimum?(e.exclusiveMinimum=e.minimum,delete e.minimum):!1===e.exclusiveMinimum&&delete e.exclusiveMinimum,!0===e.exclusiveMaximum?(e.exclusiveMaximum=e.maximum,delete e.maximum):!1===e.exclusiveMaximum&&delete e.exclusiveMaximum,e))),m=e(m,((e,t)=>(void 0!==e.example&&(i(t)?e.examples=[e.example]:e.examples={default:e.example},delete e.example),e))),m=e(m,(e=>{if("object"===e.type&&void 0!==e.properties){const t=Object.entries(e.properties);for(const[e,i]of t)"object"==typeof i&&"string"===i.type&&"binary"===i.format&&(i.contentEncoding="application/octet-stream",delete i.format)}return e})),m=e(m,(e=>{if("string"!==e.type||"binary"!==e.format)return e})),m=e(m,(e=>"string"===e.type&&"base64"===e.format?{type:"string",contentEncoding:"base64"}:e)),m):m}function i(e){return[["components","schemas"],"properties","items","allOf","anyOf","oneOf","not","additionalProperties"].some((t=>Array.isArray(t)?t.every(((t,i)=>e[i]===t)):e.includes(t)))||e.includes("schema")||e.some((e=>e.endsWith("Schema")))}export{i as isSchemaPath,t as upgradeFromThreeToThreeOne};
+import { traverse } from './traverse.js';
+
+/**
+ * Upgrade from OpenAPI 3.0.x to 3.1.0
+ *
+ * https://www.openapis.org/blog/2021/02/16/migrating-from-openapi-3-0-to-3-1-0
+ */
+function upgradeFromThreeToThreeOne(originalSpecification) {
+    let specification = originalSpecification;
+    // Version
+    if (specification.openapi?.startsWith('3.0')) {
+        specification.openapi = '3.1.0';
+    }
+    else {
+        // Skip if it’s something else than 3.0.x
+        return specification;
+    }
+    // Nullable types
+    specification = traverse(specification, (schema) => {
+        if (schema.type !== 'undefined' && schema.nullable === true) {
+            schema.type = ['null', schema.type];
+            delete schema.nullable;
+        }
+        return schema;
+    });
+    // exclusiveMinimum and exclusiveMaximum
+    specification = traverse(specification, (schema) => {
+        if (schema.exclusiveMinimum === true) {
+            schema.exclusiveMinimum = schema.minimum;
+            delete schema.minimum;
+        }
+        else if (schema.exclusiveMinimum === false) {
+            delete schema.exclusiveMinimum;
+        }
+        if (schema.exclusiveMaximum === true) {
+            schema.exclusiveMaximum = schema.maximum;
+            delete schema.maximum;
+        }
+        else if (schema.exclusiveMaximum === false) {
+            delete schema.exclusiveMaximum;
+        }
+        return schema;
+    });
+    // Use examples not example
+    specification = traverse(specification, (schema, path) => {
+        if (schema.example !== undefined) {
+            // Arrays in schemas
+            if (isSchemaPath(path)) {
+                schema.examples = [schema.example];
+            }
+            // Objects everywhere else
+            else {
+                schema.examples = {
+                    default: schema.example,
+                };
+            }
+            delete schema.example;
+        }
+        return schema;
+    });
+    // Multipart file uploads with a binary file
+    specification = traverse(specification, (schema) => {
+        if (schema.type === 'object' && schema.properties !== undefined) {
+            // Types
+            const entries = Object.entries(schema.properties);
+            for (const [_, value] of entries) {
+                if (typeof value === 'object' &&
+                    value.type === 'string' &&
+                    value.format === 'binary') {
+                    value.contentEncoding = 'application/octet-stream';
+                    delete value.format;
+                }
+            }
+        }
+        return schema;
+    });
+    // Uploading a binary file in a POST request
+    specification = traverse(specification, (schema) => {
+        if (schema.type === 'string' && schema.format === 'binary') {
+            return undefined;
+        }
+        return schema;
+    });
+    // Uploading an image with base64 encoding
+    specification = traverse(specification, (schema) => {
+        if (schema.type === 'string' && schema.format === 'base64') {
+            return {
+                type: 'string',
+                contentEncoding: 'base64',
+            };
+        }
+        return schema;
+    });
+    // Declaring $schema Dialects to protect against change
+    // if (typeof specification.$schema === 'undefined') {
+    //   specification.$schema = 'http://json-schema.org/draft-07/schema#'
+    // }
+    return specification;
+}
+/** Determine if the current path is within a schema */
+function isSchemaPath(path) {
+    const schemaLocations = [
+        ['components', 'schemas'],
+        'properties',
+        'items',
+        'allOf',
+        'anyOf',
+        'oneOf',
+        'not',
+        'additionalProperties',
+    ];
+    return (schemaLocations.some((location) => {
+        if (Array.isArray(location)) {
+            return location.every((segment, index) => path[index] === segment);
+        }
+        return path.includes(location);
+    }) ||
+        path.includes('schema') ||
+        path.some((segment) => segment.endsWith('Schema')));
+}
+
+export { isSchemaPath, upgradeFromThreeToThreeOne };

package/dist/utils/upgradeFromTwoToThree.js

@@ -1 +1,174 @@
-import{traverse as e}from"./traverse.js";function t(t){if(!t.swagger?.startsWith("2.0"))return t;if(t.openapi="3.0.3",delete t.swagger,console.warn("[upgradeFromTwoToThree] The upgrade from Swagger 2.0 to OpenAPI 3.0 documents is experimental and lacks features."),t.host){const e=t.schemes?.length?t.schemes:["http"];t.servers=e.map((e=>({url:`${e}://${t.host}${t.basePath??""}`}))),delete t.basePath,delete t.schemes,delete t.host}if(t.definitions&&("object"!=typeof t.components&&(t.components={}),t.components.schemas=t.definitions,delete t.definitions,t=e(t,(e=>(e.$ref?.startsWith("#/definitions/")&&(e.$ref=e.$ref.replace(/^#\/definitions\//,"#/components/schemas/")),e)))),t.paths)for(const e in t.paths)if(Object.hasOwn(t.paths,e)){const o=t.paths[e];for(const e in o)if(Object.hasOwn(o,e)){const s=o[e];if(s.parameters){const e=structuredClone(s.parameters.find((e=>"body"===e.in))??{});if(e&&Object.keys(e).length){delete e.name,delete e.in;const o=t.consumes??s.consumes??["application/json"];"object"!=typeof s.requestBody&&(s.requestBody={}),"object"!=typeof s.requestBody.content&&(s.requestBody.content={});const{schema:n,...r}=e;s.requestBody={...s.requestBody,...r};for(const e of o)s.requestBody.content[e]={schema:n}}s.parameters=s.parameters.filter((e=>"body"!==e.in)),delete s.consumes;const o=s.parameters.filter((e=>"formData"===e.in));if(o.length>0){"object"!=typeof s.requestBody&&(s.requestBody={}),"object"!=typeof s.requestBody.content&&(s.requestBody.content={}),s.requestBody.content["application/x-www-form-urlencoded"]={schema:{type:"object",properties:{},required:[]}};for(const e of o)s.requestBody.content["application/x-www-form-urlencoded"].schema.properties[e.name]={type:e.type,description:e.description},e.required&&s.requestBody.content["application/x-www-form-urlencoded"].schema.required.push(e.name);s.parameters=s.parameters.filter((e=>"formData"!==e.in))}}if(s.responses)for(const e in s.responses)if(Object.hasOwn(s.responses,e)){const o=s.responses[e];if(o.schema){const e=t.produces??s.produces??["application/json"];"object"!=typeof o.content&&(o.content={});for(const t of e)o.content[t]={schema:o.schema};delete o.schema}}delete s.produces,0===s.parameters?.length&&delete s.parameters}}if(t.securityDefinitions){"object"!=typeof t.components&&(t.components={}),t.components.securitySchemes={};for(const[e,o]of Object.entries(t.securityDefinitions))if("object"==typeof o)if("type"in o&&"oauth2"===o.type){const{flow:s,authorizationUrl:n,tokenUrl:r,scopes:c}=o;t.components.securitySchemes[e]={type:"oauth2",flows:{[s]:{...n&&{authorizationUrl:n},...r&&{tokenUrl:r},...c&&{scopes:c}}}}}else t.components.securitySchemes[e]=o;delete t.securityDefinitions}return t}export{t as upgradeFromTwoToThree};
+import { traverse } from './traverse.js';
+
+/**
+ * Upgrade Swagger 2.0 to OpenAPI 3.0
+ *
+ * https://swagger.io/blog/news/whats-new-in-openapi-3-0/
+ */
+function upgradeFromTwoToThree(specification) {
+    // Version
+    if (specification.swagger?.startsWith('2.0')) {
+        specification.openapi = '3.0.3';
+        delete specification.swagger;
+    }
+    else {
+        // Skip if it’s something else than 3.0.x
+        return specification;
+    }
+    console.warn(`[upgradeFromTwoToThree] The upgrade from Swagger 2.0 to OpenAPI 3.0 documents is experimental and lacks features.`);
+    // Servers
+    if (specification.host) {
+        const schemes = specification.schemes?.length
+            ? specification.schemes
+            : ['http'];
+        specification.servers = schemes.map((scheme) => ({
+            url: `${scheme}://${specification.host}${specification.basePath ?? ''}`,
+        }));
+        delete specification.basePath;
+        delete specification.schemes;
+        delete specification.host;
+    }
+    // Schemas
+    if (specification.definitions) {
+        if (typeof specification.components !== 'object') {
+            specification.components = {};
+        }
+        specification.components.schemas = specification.definitions;
+        delete specification.definitions;
+        // Rewrite $refs to definitions
+        specification = traverse(specification, (schema) => {
+            if (schema.$ref?.startsWith('#/definitions/')) {
+                schema.$ref = schema.$ref.replace(/^#\/definitions\//, '#/components/schemas/');
+            }
+            return schema;
+        });
+    }
+    // Paths
+    if (specification.paths) {
+        for (const path in specification.paths) {
+            if (Object.hasOwn(specification.paths, path)) {
+                const pathItem = specification.paths[path];
+                for (const method in pathItem) {
+                    if (Object.hasOwn(pathItem, method)) {
+                        const operationItem = pathItem[method];
+                        // Request bodies
+                        if (operationItem.parameters) {
+                            const bodyParameter = structuredClone(operationItem.parameters.find((parameter) => parameter.in === 'body') ?? {});
+                            if (bodyParameter && Object.keys(bodyParameter).length) {
+                                delete bodyParameter.name;
+                                delete bodyParameter.in;
+                                const consumes = specification.consumes ??
+                                    operationItem.consumes ?? ['application/json'];
+                                if (typeof operationItem.requestBody !== 'object') {
+                                    operationItem.requestBody = {};
+                                }
+                                if (typeof operationItem.requestBody.content !== 'object') {
+                                    operationItem.requestBody.content = {};
+                                }
+                                const { schema, ...requestBody } = bodyParameter;
+                                operationItem.requestBody = {
+                                    ...operationItem.requestBody,
+                                    ...requestBody,
+                                };
+                                for (const type of consumes) {
+                                    operationItem.requestBody.content[type] = {
+                                        schema: schema,
+                                    };
+                                }
+                            }
+                            // Delete body parameter
+                            operationItem.parameters = operationItem.parameters.filter((parameter) => parameter.in !== 'body');
+                            delete operationItem.consumes;
+                            // formData parameters
+                            const formDataParameters = operationItem.parameters.filter((parameter) => parameter.in === 'formData');
+                            if (formDataParameters.length > 0) {
+                                if (typeof operationItem.requestBody !== 'object') {
+                                    operationItem.requestBody = {};
+                                }
+                                if (typeof operationItem.requestBody.content !== 'object') {
+                                    operationItem.requestBody.content = {};
+                                }
+                                operationItem.requestBody.content['application/x-www-form-urlencoded'] = {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {},
+                                        required: [], // Initialize required array
+                                    },
+                                };
+                                for (const param of formDataParameters) {
+                                    operationItem.requestBody.content['application/x-www-form-urlencoded'].schema.properties[param.name] = {
+                                        type: param.type,
+                                        description: param.description,
+                                    };
+                                    // Add to required array if param is required
+                                    if (param.required) {
+                                        operationItem.requestBody.content['application/x-www-form-urlencoded'].schema.required.push(param.name);
+                                    }
+                                }
+                                // Remove formData parameters from the parameters array
+                                operationItem.parameters = operationItem.parameters.filter((parameter) => parameter.in !== 'formData');
+                            }
+                        }
+                        // Responses
+                        if (operationItem.responses) {
+                            for (const response in operationItem.responses) {
+                                if (Object.hasOwn(operationItem.responses, response)) {
+                                    const responseItem = operationItem.responses[response];
+                                    if (responseItem.schema) {
+                                        const produces = specification.produces ??
+                                            operationItem.produces ?? ['application/json'];
+                                        if (typeof responseItem.content !== 'object') {
+                                            responseItem.content = {};
+                                        }
+                                        for (const type of produces) {
+                                            responseItem.content[type] = {
+                                                schema: responseItem.schema,
+                                            };
+                                        }
+                                        delete responseItem.schema;
+                                    }
+                                }
+                            }
+                        }
+                        delete operationItem.produces;
+                        // Delete empty parameters
+                        if (operationItem.parameters?.length === 0) {
+                            delete operationItem.parameters;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Upgrade securityDefinitions
+    if (specification.securityDefinitions) {
+        if (typeof specification.components !== 'object') {
+            specification.components = {};
+        }
+        specification.components.securitySchemes = {};
+        for (const [key, securityScheme] of Object.entries(specification.securityDefinitions)) {
+            if (typeof securityScheme === 'object') {
+                if ('type' in securityScheme && securityScheme.type === 'oauth2') {
+                    const { flow, authorizationUrl, tokenUrl, scopes } = securityScheme;
+                    specification.components.securitySchemes[key] = {
+                        type: 'oauth2',
+                        flows: {
+                            [flow]: {
+                                ...(authorizationUrl && { authorizationUrl }),
+                                ...(tokenUrl && { tokenUrl }),
+                                ...(scopes && { scopes }),
+                            },
+                        },
+                    };
+                }
+                else {
+                    specification.components.securitySchemes[key] = securityScheme;
+                }
+            }
+        }
+        delete specification.securityDefinitions;
+    }
+    return specification;
+}
+
+export { upgradeFromTwoToThree };

package/dist/utils/validate.js

@@ -1 +1,18 @@
-import{Validator as i}from"../lib/Validator/Validator.js";import{makeFilesystem as o}from"./makeFilesystem.js";async function t(t,a){const e=o(t),r=new i;return{...await r.validate(e,a),specification:r.specification,version:r.version}}export{t as validate};
+import { makeFilesystem } from './makeFilesystem.js';
+import { Validator } from '../lib/Validator/Validator.js';
+
+/**
+ * Validates an OpenAPI schema.
+ */
+async function validate(value, options) {
+    const filesystem = makeFilesystem(value);
+    const validator = new Validator();
+    const result = await validator.validate(filesystem, options);
+    return {
+        ...result,
+        specification: validator.specification,
+        version: validator.version,
+    };
+}
+
+export { validate };

package/package.json

@@ -17,7 +17,7 @@
     "parser",
     "typescript"
   ],
-  "version": "0.8.6",
+  "version": "0.8.8",
   "engines": {
     "node": ">=18"
   },
@@ -26,13 +26,19 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./plugins/fetch-urls": {
-      "import": "./dist/utils/load/plugins/fetchUrls.js"
+      "import": "./dist/plugins/fetch-urls/index.js",
+      "types": "./dist/plugins/fetch-urls/index.d.ts",
+      "default": "./dist/plugins/fetch-urls/index.js"
     },
     "./plugins/read-files": {
-      "import": "./dist/utils/load/plugins/readFiles.js"
+      "import": "./dist/plugins/read-files/index.js",
+      "types": "./dist/plugins/read-files/index.d.ts",
+      "default": "./dist/plugins/read-files/index.js"
     }
   },
   "files": [
@@ -53,27 +59,23 @@
     "@apidevtools/swagger-parser": "^10.1.0",
     "@babel/code-frame": "^7.24.7",
     "@google-cloud/storage": "^7.12.1",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^11.1.6",
     "@types/node": "^20.14.10",
     "glob": "^10.3.10",
     "json-to-ast": "^2.1.0",
     "just-diff": "^6.0.2",
-    "rollup": "^4.16.4",
-    "rollup-plugin-output-size": "^1.4.1",
     "tinybench": "^2.8.0",
-    "@scalar/openapi-types": "0.1.2"
+    "@scalar/build-tooling": "0.1.11",
+    "@scalar/openapi-types": "0.1.4"
   },
   "scripts": {
-    "build": "pnpm types:check && rollup -c --configPlugin typescript && pnpm types:build",
+    "build": "scalar-build-rollup",
     "format": "prettier --write .",
     "lint:check": "eslint .",
     "lint:fix": "eslint .  --fix",
     "test": "vitest",
     "test:prepare": "vite-node scripts/load-files.ts",
     "test:unit": "vite-node scripts/load-files.ts && vitest",
-    "types:build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    "types:check": "tsc --noEmit --skipLibCheck"
+    "types:build": "scalar-types-build",
+    "types:check": "scalar-types-check"
   }
 }

package/dist/utils/load/plugins/fetchUrls.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetchUrls.d.ts","sourceRoot":"","sources":["../../../../src/utils/load/plugins/fetchUrls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,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/utils/load/plugins/fetchUrls.js

@@ -1 +0,0 @@
-const t={limit:20},e=e=>{let s=0;const r={...t,...e};return{check:t=>"string"==typeof t&&!(!t.startsWith("http://")&&!t.startsWith("https://")),async get(t){if(!1!==r?.limit&&s>=r?.limit)console.warn(`[fetchUrls] Maximum number of requests reeached (${r?.limit}), skipping request`);else try{s++;const e=await(r?.fetch?r.fetch(t):fetch(t));return await e.text()}catch(e){console.error("[fetchUrls]",e.message,`(${t})`)}}}};export{e as fetchUrls,t as fetchUrlsDefaultConfiguration};

package/dist/utils/load/plugins/readFiles.d.ts

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