@mintlify/validation 0.1.58 → 0.1.60

package/dist/openapi/convertOpenApi.js

@@ -0,0 +1,166 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { convertParameters } from './convertParameters.js';
+import { convertSchema } from './convertSchema.js';
+import { convertSecurity } from './convertSecurity.js';
+import { convertServers } from './convertServers.js';
+export var generateMessage = function (path, messages) {
+    if (messages === void 0) { messages = []; }
+    var pathString = path
+        .map(function (component) { return component.replace('\\', '\\\\').replace('/', '\\/'); })
+        .join('/');
+    return __spreadArray([pathString], messages, true).join('\n');
+};
+var InvalidSchemaError = /** @class */ (function (_super) {
+    __extends(InvalidSchemaError, _super);
+    function InvalidSchemaError(path) {
+        var messages = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            messages[_i - 1] = arguments[_i];
+        }
+        var _this = _super.call(this, generateMessage(path, messages)) || this;
+        _this.name = 'InvalidSchemaError';
+        Object.setPrototypeOf(_this, InvalidSchemaError.prototype);
+        return _this;
+    }
+    return InvalidSchemaError;
+}(Error));
+export { InvalidSchemaError };
+var ImpossibleSchemaError = /** @class */ (function (_super) {
+    __extends(ImpossibleSchemaError, _super);
+    function ImpossibleSchemaError(path) {
+        var messages = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            messages[_i - 1] = arguments[_i];
+        }
+        var _this = _super.call(this, generateMessage(path, messages)) || this;
+        _this.name = 'ImpossibleSchemaError';
+        Object.setPrototypeOf(_this, ImpossibleSchemaError.prototype);
+        return _this;
+    }
+    return ImpossibleSchemaError;
+}(Error));
+export { ImpossibleSchemaError };
+var ConversionError = /** @class */ (function (_super) {
+    __extends(ConversionError, _super);
+    function ConversionError(path) {
+        var messages = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            messages[_i - 1] = arguments[_i];
+        }
+        var _this = _super.call(this, generateMessage(path, messages)) || this;
+        _this.name = 'ConversionError';
+        Object.setPrototypeOf(_this, ConversionError.prototype);
+        return _this;
+    }
+    return ConversionError;
+}(Error));
+export { ConversionError };
+export var convertBody = function (path, body) {
+    if (body === undefined) {
+        return {};
+    }
+    var newEntries = Object.entries(body.content).map(function (_a) {
+        var contentType = _a[0], mediaObject = _a[1];
+        return [
+            contentType,
+            convertSchema(__spreadArray(__spreadArray([], path, true), [contentType, 'schema'], false), mediaObject.schema, body.required),
+        ];
+    });
+    return Object.fromEntries(newEntries);
+};
+export var convertResponses = function (path, responses) {
+    var newEntries = Object.entries(responses).map(function (_a) {
+        var statusCode = _a[0], response = _a[1];
+        return [
+            statusCode,
+            convertResponse(__spreadArray(__spreadArray([], path, true), [statusCode], false), response),
+        ];
+    });
+    return Object.fromEntries(newEntries);
+};
+export var convertResponse = function (path, response) {
+    if (response.content === undefined) {
+        return {};
+    }
+    var newEntries = Object.entries(response.content).map(function (_a) {
+        var contentType = _a[0], mediaType = _a[1];
+        return [
+            contentType,
+            convertSchema(__spreadArray(__spreadArray([], path, true), ['content', contentType, 'schema'], false), mediaType.schema),
+        ];
+    });
+    return Object.fromEntries(newEntries);
+};
+export var convertOpenAPIV3_1ToEndpoint = function (spec, path, method) {
+    var _a, _b, _c, _d, _e;
+    var paths = spec.paths;
+    if (paths === undefined) {
+        throw new InvalidSchemaError(['#'], 'paths not defined');
+    }
+    var pathObject = paths[path];
+    if (pathObject === undefined) {
+        throw new InvalidSchemaError(['#', 'paths'], "path not defined: ".concat(path));
+    }
+    var operationObject = pathObject[method];
+    if (operationObject === undefined) {
+        throw new InvalidSchemaError(['#', 'paths', path], "operation does not exist: ".concat(method));
+    }
+    var securityRequirements = (_a = operationObject.security) !== null && _a !== void 0 ? _a : spec.security;
+    var securitySchemes = (_b = spec.components) === null || _b === void 0 ? void 0 : _b.securitySchemes;
+    var security = convertSecurity({
+        securityRequirements: securityRequirements,
+        securitySchemes: securitySchemes,
+    });
+    var pathParameters = pathObject.parameters;
+    var operationParameters = operationObject.parameters;
+    var parameters = convertParameters({
+        path: ['#', 'paths', path],
+        method: method,
+        pathParameters: pathParameters,
+        operationParameters: operationParameters,
+    });
+    var servers = convertServers({
+        servers: (_d = (_c = operationObject.servers) !== null && _c !== void 0 ? _c : pathObject.servers) !== null && _d !== void 0 ? _d : spec.servers,
+    });
+    var description = (_e = operationObject.description) !== null && _e !== void 0 ? _e : pathObject === null || pathObject === void 0 ? void 0 : pathObject.description;
+    var requestBody = operationObject.requestBody;
+    var body = convertBody(['#', 'paths', path, method, 'requestBody'], requestBody);
+    var deprecated = !!operationObject.deprecated;
+    var response = convertResponses(['#', 'paths', path, method, 'responses'], operationObject.responses);
+    return {
+        description: description,
+        path: path,
+        method: method,
+        servers: servers,
+        request: {
+            security: security,
+            parameters: parameters,
+            body: body,
+        },
+        response: response,
+        deprecated: deprecated,
+    };
+};

package/dist/openapi/convertParameters.d.ts

@@ -1,5 +1,5 @@
 import { OpenAPIV3_1 } from 'openapi-types';
-import { ParameterSections } from './types/endpoint';
+import { ParameterSections } from './types/endpoint.js';
 export type ConvertParametersParams = {
     path: string[];
     method: string;

package/dist/openapi/convertParameters.js

@@ -0,0 +1,60 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { InvalidSchemaError } from './convertOpenApi.js';
+import { convertSchema, copyKeyIfDefined } from './convertSchema.js';
+export var convertParameters = function (_a) {
+    var path = _a.path, method = _a.method, pathParameters = _a.pathParameters, operationParameters = _a.operationParameters;
+    var parameterSections = {
+        path: {},
+        query: {},
+        header: {},
+        cookie: {},
+    };
+    pathParameters === null || pathParameters === void 0 ? void 0 : pathParameters.forEach(function (parameterObject, i) {
+        addParameter({
+            path: __spreadArray(__spreadArray([], path, true), ['parameters', i.toString()], false),
+            parameter: parameterObject,
+            parameterSections: parameterSections,
+        });
+    });
+    operationParameters === null || operationParameters === void 0 ? void 0 : operationParameters.forEach(function (parameterObject, i) {
+        addParameter({
+            path: __spreadArray(__spreadArray([], path, true), [method, 'parameters', i.toString()], false),
+            parameter: parameterObject,
+            parameterSections: parameterSections,
+        });
+    });
+    return parameterSections;
+};
+var addParameter = function (_a) {
+    var path = _a.path, parameter = _a.parameter, parameterSections = _a.parameterSections;
+    if (!['path', 'header', 'query', 'cookie'].includes(parameter.in)) {
+        throw new InvalidSchemaError(path, "invalid parameter location: '".concat(parameter.in, "'"));
+    }
+    var location = parameter.in;
+    if (location === 'path') {
+        var newParameter = {
+            required: true,
+            schema: convertSchema(__spreadArray(__spreadArray([], path, true), ['schema'], false), parameter.schema, true),
+        };
+        copyKeyIfDefined('description', parameter, newParameter);
+        copyKeyIfDefined('deprecated', parameter, newParameter);
+        parameterSections.path[parameter.name] = newParameter;
+    }
+    else {
+        var newParameter = {
+            schema: convertSchema(__spreadArray(__spreadArray([], path, true), ['schema'], false), parameter.schema, true),
+        };
+        copyKeyIfDefined('description', parameter, newParameter);
+        copyKeyIfDefined('deprecated', parameter, newParameter);
+        copyKeyIfDefined('required', parameter, newParameter);
+        parameterSections[location][parameter.name] = newParameter;
+    }
+};

package/dist/openapi/convertSchema.d.ts

@@ -1,5 +1,5 @@
 import { OpenAPIV3_1 } from 'openapi-types';
-import { DataSchemaArray } from './types/endpoint';
+import { DataSchemaArray } from './types/endpoint.js';
 export declare const convertSchema: (path: string[], schema: OpenAPIV3_1.SchemaObject | undefined, required?: boolean) => DataSchemaArray;
 export declare const combineTopLevelSchemas: (path: string[], schema1: OpenAPIV3_1.SchemaObject, schema2: OpenAPIV3_1.SchemaObject) => OpenAPIV3_1.SchemaObject;
 export declare const addKeyIfDefined: <D, K extends keyof D>(key: K, value: D[K], destination: D) => void;