@mintlify/validation 0.1.98 → 0.1.100

package/dist/index.d.ts

@@ -2,8 +2,8 @@ import type { ConfigType } from '@mintlify/models';
 import { MintValidationResults } from './mint-config/common.js';
 export declare function validateMintConfig(config: ConfigType): MintValidationResults;
 export * from './openapi/types/endpoint.js';
-export { convertOpenAPIV3_1ToEndpoint } from './openapi/convertOpenApi.js';
-export { convertSchema } from './openapi/convertSchema.js';
+export { OpenApiToEndpointConverter } from './openapi/OpenApiToEndpointConverter.js';
+export { SchemaConverter } from './openapi/SchemaConverter.js';
 export { generateExampleFromSchema } from './openapi/generateExampleFromSchema.js';
 export declare const mintConfigSchema: any;
 export { sort } from './sort.js';

package/dist/index.js

@@ -44,8 +44,8 @@ export function validateMintConfig(config) {
     return results;
 }
 export * from './openapi/types/endpoint.js';
-export { convertOpenAPIV3_1ToEndpoint } from './openapi/convertOpenApi.js';
-export { convertSchema } from './openapi/convertSchema.js';
+export { OpenApiToEndpointConverter } from './openapi/OpenApiToEndpointConverter.js';
+export { SchemaConverter } from './openapi/SchemaConverter.js';
 export { generateExampleFromSchema } from './openapi/generateExampleFromSchema.js';
 export const mintConfigSchema = (() => {
     var _a, _b, _c, _d, _e, _f;

package/dist/openapi/BaseConverter.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class BaseConverter {
+    readonly safeParse: boolean;
+    protected constructor(safeParse?: boolean);
+    protected handleExistingError(error: unknown, path: string[], ...messages: string[]): void;
+    protected handleNewError(E: new (path: string[], ...messages: string[]) => Error, path: string[], ...messages: string[]): void;
+}

package/dist/openapi/BaseConverter.js

@@ -0,0 +1,22 @@
+import { generateMessage } from './errors.js';
+export class BaseConverter {
+    constructor(safeParse = false) {
+        this.safeParse = safeParse;
+    }
+    handleExistingError(error, path, ...messages) {
+        if (this.safeParse) {
+            console.error(generateMessage(path, ...messages));
+        }
+        else {
+            throw error;
+        }
+    }
+    handleNewError(E, path, ...messages) {
+        if (this.safeParse) {
+            console.error(generateMessage(path, ...messages));
+        }
+        else {
+            throw new E(path, ...messages);
+        }
+    }
+}

package/dist/openapi/OpenApiToEndpointConverter.d.ts

@@ -0,0 +1,15 @@
+import { OpenAPIV3_1 } from 'openapi-types';
+import { BaseConverter } from './BaseConverter.js';
+import type { Endpoint, HttpMethod } from './types/endpoint.js';
+export declare class OpenApiToEndpointConverter extends BaseConverter {
+    readonly document: OpenAPIV3_1.Document;
+    readonly path: string;
+    readonly method: HttpMethod;
+    readonly safeParse: boolean;
+    private constructor();
+    private convert;
+    private convertContent;
+    private convertExamples;
+    private convertResponses;
+    static convert(spec: OpenAPIV3_1.Document, path: string, method: HttpMethod, safeParse?: boolean): Endpoint | undefined;
+}

package/dist/openapi/OpenApiToEndpointConverter.js

@@ -0,0 +1,100 @@
+import { BaseConverter } from './BaseConverter.js';
+import { ParametersConverter } from './ParametersConverter.js';
+import { SchemaConverter } from './SchemaConverter.js';
+import { SecurityConverter } from './SecurityConverter.js';
+import { ServersConverter } from './ServersConverter.js';
+import { InvalidSchemaError } from './errors.js';
+import { generateExampleFromSchema } from './generateExampleFromSchema.js';
+export class OpenApiToEndpointConverter extends BaseConverter {
+    constructor(document, path, method, safeParse = false) {
+        super(safeParse);
+        this.document = document;
+        this.path = path;
+        this.method = method;
+        this.safeParse = safeParse;
+    }
+    convert() {
+        var _a, _b, _c, _d, _e;
+        const paths = this.document.paths;
+        if (paths === undefined) {
+            throw new InvalidSchemaError(['#'], 'paths not defined');
+        }
+        const pathObject = paths[this.path];
+        if (pathObject === undefined) {
+            throw new InvalidSchemaError(['#', 'paths'], `path not defined: ${this.path}`);
+        }
+        const operationObject = pathObject[this.method];
+        if (operationObject === undefined) {
+            throw new InvalidSchemaError(['#', 'paths', this.path], `operation does not exist: ${this.method}`);
+        }
+        const securityRequirements = (_a = operationObject.security) !== null && _a !== void 0 ? _a : this.document.security;
+        const securitySchemes = (_b = this.document.components) === null || _b === void 0 ? void 0 : _b.securitySchemes;
+        const security = SecurityConverter.convert(securityRequirements, securitySchemes, this.safeParse);
+        const pathParameters = pathObject.parameters;
+        const operationParameters = operationObject.parameters;
+        const parameters = ParametersConverter.convert(this.method, pathParameters, operationParameters, ['#', 'paths', this.path], this.safeParse);
+        const servers = ServersConverter.convert((_d = (_c = operationObject.servers) !== null && _c !== void 0 ? _c : pathObject.servers) !== null && _d !== void 0 ? _d : this.document.servers);
+        const description = (_e = operationObject.description) !== null && _e !== void 0 ? _e : pathObject.description;
+        const requestBody = operationObject.requestBody;
+        const body = this.convertContent(['#', 'paths', this.path, this.method, 'requestBody', 'content'], requestBody === null || requestBody === void 0 ? void 0 : requestBody.content, requestBody === null || requestBody === void 0 ? void 0 : requestBody.required);
+        const deprecated = !!operationObject.deprecated;
+        const response = this.convertResponses(['#', 'paths', this.path, this.method, 'responses'], operationObject.responses);
+        return {
+            description,
+            path: this.path,
+            method: this.method,
+            servers,
+            request: {
+                security,
+                parameters,
+                body,
+            },
+            response,
+            deprecated,
+        };
+    }
+    convertContent(debugPath, content, required) {
+        if (content === undefined) {
+            return {};
+        }
+        const newEntries = Object.entries(content).map(([contentType, mediaObject]) => {
+            const schemaArray = SchemaConverter.convert({
+                schema: mediaObject.schema,
+                path: [...debugPath, contentType, 'schema'],
+                required,
+                safeParse: this.safeParse,
+            });
+            const examples = this.convertExamples(mediaObject.examples, mediaObject.example, schemaArray);
+            return [contentType, { schemaArray, examples }];
+        });
+        return Object.fromEntries(newEntries);
+    }
+    convertExamples(examples, example, schemaArray) {
+        if (examples && Object.values(examples).some(({ value }) => value !== undefined)) {
+            return Object.fromEntries(Object.entries(examples)
+                .filter(([_, { value }]) => value !== undefined)
+                .map(([key, example]) => [
+                key,
+                {
+                    summary: example.summary,
+                    description: example.description,
+                    value: example.value,
+                },
+            ]));
+        }
+        if (example !== undefined) {
+            return { example: { value: example } };
+        }
+        return { example: { value: generateExampleFromSchema(schemaArray[0]) } };
+    }
+    convertResponses(debugPath, responses) {
+        const newEntries = Object.entries(responses).map(([statusCode, response]) => [
+            statusCode,
+            this.convertContent([...debugPath, statusCode, 'content'], response.content),
+        ]);
+        return Object.fromEntries(newEntries);
+    }
+    static convert(spec, path, method, safeParse) {
+        return new OpenApiToEndpointConverter(spec, path, method, safeParse).convert();
+    }
+}

package/dist/openapi/ParametersConverter.d.ts

@@ -0,0 +1,15 @@
+import { OpenAPIV3_1 } from 'openapi-types';
+import { BaseConverter } from './BaseConverter.js';
+import { ParameterSections } from './types/endpoint.js';
+export declare class ParametersConverter extends BaseConverter {
+    readonly method: string;
+    readonly pathParameters: OpenAPIV3_1.ParameterObject[] | undefined;
+    readonly operationParameters: OpenAPIV3_1.ParameterObject[] | undefined;
+    readonly path: string[];
+    readonly safeParse: boolean;
+    private parameterSections;
+    private constructor();
+    private convert;
+    private addParameter;
+    static convert(method: string, pathParameters: OpenAPIV3_1.ParameterObject[] | undefined, operationParameters: OpenAPIV3_1.ParameterObject[] | undefined, path: string[], safeParse?: boolean): ParameterSections;
+}

package/dist/openapi/ParametersConverter.js

@@ -0,0 +1,50 @@
+import { BaseConverter } from './BaseConverter.js';
+import { SchemaConverter } from './SchemaConverter.js';
+import { InvalidSchemaError } from './errors.js';
+import { copyKeyIfDefined } from './utils.js';
+export class ParametersConverter extends BaseConverter {
+    constructor(method, pathParameters, operationParameters, path, safeParse = false) {
+        super(safeParse);
+        this.method = method;
+        this.pathParameters = pathParameters;
+        this.operationParameters = operationParameters;
+        this.path = path;
+        this.safeParse = safeParse;
+        this.parameterSections = {
+            path: {},
+            query: {},
+            header: {},
+            cookie: {},
+        };
+    }
+    convert() {
+        var _a, _b;
+        (_a = this.pathParameters) === null || _a === void 0 ? void 0 : _a.forEach((parameterObject, i) => {
+            this.addParameter([...this.path, 'parameters', i.toString()], parameterObject);
+        });
+        (_b = this.operationParameters) === null || _b === void 0 ? void 0 : _b.forEach((parameterObject, i) => {
+            this.addParameter([...this.path, this.method, 'parameters', i.toString()], parameterObject);
+        });
+        return this.parameterSections;
+    }
+    addParameter(path, parameter) {
+        if (!['path', 'header', 'query', 'cookie'].includes(parameter.in)) {
+            this.handleNewError(InvalidSchemaError, path, `invalid parameter location: '${parameter.in}'`);
+            return;
+        }
+        const location = parameter.in;
+        // parameter.schema may be undefined (if the schema is instead defined in parameter.content), but this is likely super rare
+        const parameterSchema = parameter.schema;
+        copyKeyIfDefined('description', parameter, parameterSchema);
+        copyKeyIfDefined('deprecated', parameter, parameterSchema);
+        const newParameter = SchemaConverter.convert({
+            schema: parameter.schema,
+            path: [...path, 'schema'],
+            required: location === 'path' ? true : parameter.required,
+        });
+        this.parameterSections[location][parameter.name] = { schema: newParameter };
+    }
+    static convert(method, pathParameters, operationParameters, path, safeParse) {
+        return new ParametersConverter(method, pathParameters, operationParameters, path, safeParse).convert();
+    }
+}

package/dist/openapi/SchemaConverter.d.ts

@@ -0,0 +1,62 @@
+import { OpenAPIV3_1 } from 'openapi-types';
+import { BaseConverter } from './BaseConverter.js';
+import { DataSchemaArray } from './types/endpoint.js';
+export declare class SchemaConverter extends BaseConverter {
+    readonly schema: OpenAPIV3_1.SchemaObject | undefined;
+    readonly required?: boolean | undefined;
+    readonly path: string[];
+    readonly location?: "request" | "response" | undefined;
+    readonly safeParse: boolean;
+    private constructor();
+    /**
+     * This function converts the `schema` property into a `DataSchemaArray`. Due to
+     * the recursive nature of OpenAPI schemas, this conversion happens in two parts:
+     *
+     * 1. **Reduction**\*: The schema is transformed into its *reduced form*. In this form,
+     * the schema and any subschemas are represented by a schema with one property, `oneOf`,
+     * whose items are guaranteed NOT to have a `oneOf`, `anyOf`, or `allOf` property.
+     *
+     * 2. **Conversion**: In this step, we take a schema in its reduced form and convert it
+     * into a new data type. This is fairly straightforward, as we just need to convert
+     * each element of each `oneOf` schema to a `DataSchema`, and do this for all subschemas.
+     *
+     * \*We call this step a reduction rather than a conversion because the result is still
+     * of the `OpenAPIV3_1.SchemaObject` type.
+     *
+     * @returns An array of `DataSchema` objects representing all valid schemas
+     */
+    private convert;
+    /**
+     * This function should be used to reduce strictly `oneOf` and `anyOf` compositions.
+     *
+     * @param schemaArray `schema.allOf` or `schema.oneOf`
+     * @returns a schema array equivalent to the `schemaArray` argument, but in reduced form
+     */
+    private reduceOptionsCompositions;
+    private reduceCompositionsRecursive;
+    private generateTopLevelSchemaArray;
+    /**
+     * Given two arrays representing schema options, return an array representing schema options that satisfy one element in both arrays.
+     *
+     * It is helpful to think of each array as a union of all the schemas in the array. This function can then be thought of as taking
+     * the intersection of the two union types.
+     *
+     * Used in the Reduction step.
+     *
+     * @param a first array of schema options
+     * @param b second array of schema options
+     * @returns array of schemas that satisfy both arrays
+     */
+    private multiplySchemaArrays;
+    private combineReducedSchemas;
+    private combineTopLevelSchemas;
+    private convertSchemaRecursive;
+    private convertProperties;
+    static convert({ schema, required, path, location, safeParse, }: {
+        schema: OpenAPIV3_1.SchemaObject | undefined;
+        required?: boolean;
+        path?: string[];
+        location?: 'request' | 'response';
+        safeParse?: boolean;
+    }): DataSchemaArray;
+}