@mintlify/validation 0.1.395 → 0.1.397

package/dist/openapi/utils.js

@@ -1,3 +1,4 @@
+import lcm from 'lcm';
 export const stringFileFormats = ['binary', 'base64'];
 export const structuredDataContentTypes = [
     'multipart/form-data',
@@ -79,3 +80,232 @@ export function recursivelyFindDescription(schema, name) {
     }
     return undefined;
 }
+export function sortSchemas(schemas) {
+    // all schemas with no `type` field go at the end of the array to avoid
+    // caling `copyKeyIfDefined` for discriminators with empty types unless
+    // we're certain the schema's title is the last possible option
+    schemas.sort((a, b) => {
+        var _a, _b;
+        const aDepth = (_a = a._depth) !== null && _a !== void 0 ? _a : 0;
+        const bDepth = (_b = b._depth) !== null && _b !== void 0 ? _b : 0;
+        if (aDepth !== bDepth) {
+            return aDepth - bDepth;
+        }
+        if (a.type && !b.type)
+            return -1;
+        if (!a.type && b.type)
+            return 1;
+        return 0;
+    });
+}
+export function mergeTypes(acc, curr) {
+    // schemas are meant to be immutable, so copy the type
+    let currType = curr.type;
+    // don't throw an error if type is being constricted
+    if (acc.type === 'integer' && currType === 'number') {
+        currType = 'integer';
+    }
+    else if (acc.type === 'number' && currType === 'integer') {
+        acc.type = 'integer';
+    }
+    else if (acc.type === undefined && currType !== undefined) {
+        acc.type = currType;
+    }
+    else if (acc.type !== undefined && currType === undefined) {
+        currType = acc.type;
+    }
+    if (acc.type !== currType) {
+        throw new Error(`${acc.type} vs ${currType}`);
+    }
+}
+export function normalizeMinMax(schema) {
+    // we're technically breaking immutability rules here, but it's probably okay because
+    // it will be the same every time - we're just normalizing the maximum/minimum
+    // and exclusiveMaximum/exclusiveMinimum properties
+    if (typeof schema.exclusiveMaximum === 'number') {
+        if (schema.maximum === undefined || schema.maximum >= schema.exclusiveMaximum) {
+            schema.maximum = schema.exclusiveMaximum;
+            schema.exclusiveMaximum = true;
+        }
+        else {
+            schema.exclusiveMaximum = undefined;
+        }
+    }
+    if (typeof schema.exclusiveMinimum === 'number') {
+        if (schema.minimum === undefined || schema.minimum <= schema.exclusiveMinimum) {
+            schema.minimum = schema.exclusiveMinimum;
+            schema.exclusiveMinimum = true;
+        }
+        else {
+            schema.exclusiveMinimum = undefined;
+        }
+    }
+}
+const combine = (schema1, schema2, key, transform) => {
+    var _a;
+    return schema1[key] !== undefined && schema2[key] !== undefined
+        ? transform(schema1[key], schema2[key])
+        : (_a = schema1[key]) !== null && _a !== void 0 ? _a : schema2[key];
+};
+const combineKeyIfDefined = (key, source, destination, transform) => {
+    addKeyIfDefined(key, combine(source, destination, key, transform), destination);
+};
+export function combineTitle(acc, curr) {
+    if (curr.discriminator == undefined &&
+        (curr.type != undefined || acc.title == undefined) &&
+        !(curr.isAllOf && curr.refIdentifier && curr.refIdentifier !== curr.isAllOf)) {
+        copyKeyIfDefined('title', curr, acc);
+    }
+}
+export function copyAndCombineKeys(acc, curr) {
+    copyKeyIfDefined('refIdentifier', curr, acc);
+    copyKeyIfDefined('examples', curr, acc);
+    copyKeyIfDefined('format', curr, acc);
+    copyKeyIfDefined('default', curr, acc);
+    copyKeyIfDefined('x-default', curr, acc);
+    copyKeyIfDefined('const', curr, acc);
+    combineKeyIfDefined('multipleOf', curr, acc, lcm);
+    combineKeyIfDefined('maxLength', curr, acc, Math.min);
+    combineKeyIfDefined('minLength', curr, acc, Math.max);
+    combineKeyIfDefined('maxItems', curr, acc, Math.min);
+    combineKeyIfDefined('minItems', curr, acc, Math.max);
+    combineKeyIfDefined('maxProperties', curr, acc, Math.min);
+    combineKeyIfDefined('minProperties', curr, acc, Math.max);
+    combineKeyIfDefined('required', curr, acc, (a, b) => b.concat(a.filter((value) => !b.includes(value))));
+    combineKeyIfDefined('enum', curr, acc, (a, b) => b.filter((value) => a.includes(value)));
+    combineKeyIfDefined('readOnly', curr, acc, (a, b) => a && b);
+    combineKeyIfDefined('writeOnly', curr, acc, (a, b) => a && b);
+    combineKeyIfDefined('deprecated', curr, acc, (a, b) => a || b);
+    const combinedMaximum = combine(curr, acc, 'maximum', Math.min);
+    const combinedMinimum = combine(curr, acc, 'minimum', Math.max);
+    const exclusiveMaximum = (acc.maximum === combinedMaximum ? acc.exclusiveMaximum : undefined) ||
+        (curr.maximum === combinedMaximum ? curr.exclusiveMaximum : undefined);
+    addKeyIfDefined('exclusiveMaximum', exclusiveMaximum, acc);
+    const exclusiveMinimum = (acc.minimum === combinedMinimum ? acc.exclusiveMinimum : undefined) ||
+        (curr.minimum === combinedMinimum ? curr.exclusiveMinimum : undefined);
+    addKeyIfDefined('exclusiveMinimum', exclusiveMinimum, acc);
+    addKeyIfDefined('maximum', combinedMaximum, acc);
+    addKeyIfDefined('minimum', combinedMinimum, acc);
+}
+export function combineExamples(acc, curr) {
+    var _a, _b;
+    // don't use coalesce operator, since null is a valid example
+    const example1 = ((_a = acc.examples) === null || _a === void 0 ? void 0 : _a[0]) !== undefined ? acc.examples[0] : acc.example;
+    const example2 = ((_b = curr.examples) === null || _b === void 0 ? void 0 : _b[0]) !== undefined ? curr.examples[0] : curr.example;
+    if (example1 && example2 && typeof example1 === 'object' && typeof example2 === 'object') {
+        acc.example = Object.assign(Object.assign({}, example1), example2);
+    }
+    else {
+        // don't use coalesce operator, since null is a valid example
+        addKeyIfDefined('example', example2 !== undefined ? example2 : example1, acc);
+    }
+}
+export function combineProperties(acc, curr, componentSchemas, location) {
+    if (curr.properties) {
+        Object.entries(curr.properties)
+            .filter(([_, subschema]) => {
+            // dereference just for the readOnly/writeOnly check
+            if ('$ref' in subschema) {
+                const dereferencedSchema = dereference('schemas', subschema.$ref, componentSchemas);
+                if (!dereferencedSchema)
+                    return true;
+                subschema = dereferencedSchema;
+            }
+            if (subschema.readOnly && location === 'request')
+                return false;
+            if (subschema.writeOnly && location === 'response')
+                return false;
+            return true;
+        })
+            .forEach(([property, subschema]) => {
+            var _a;
+            const properties = (_a = acc.properties) !== null && _a !== void 0 ? _a : {};
+            const currSchemaArr = properties[property];
+            if (currSchemaArr) {
+                currSchemaArr.allOf.push(subschema);
+            }
+            else {
+                properties[property] = { allOf: [subschema] };
+            }
+            acc.properties = properties;
+        });
+    }
+}
+export function combineDescription(acc, curr, schemas) {
+    var _a, _b;
+    if (((_a = acc.properties) === null || _a === void 0 ? void 0 : _a.type) && curr.discriminator && !acc.description) {
+        let name = undefined;
+        const allOf = (_b = acc.properties.type.allOf[0]) !== null && _b !== void 0 ? _b : {};
+        if ('const' in allOf && typeof allOf.const === 'string') {
+            name = allOf.const;
+        }
+        const description = recursivelyFindDescription(curr, name) ||
+            schemas.flatMap((schema) => recursivelyFindDescription(schema, name)).filter(Boolean)[0];
+        if (description) {
+            acc.description = description;
+        }
+    }
+    else if (acc.description &&
+        curr.description &&
+        !curr.discriminator &&
+        !acc.description.includes(curr.description)) {
+        acc.description = `${acc.description}\n${curr.description}`;
+    }
+    else if (!acc.description) {
+        copyKeyIfDefined('description', curr, acc);
+    }
+}
+export function combineAdditionalProperties(acc, curr) {
+    var _a;
+    if (curr.additionalProperties === false) {
+        acc.additionalProperties = false;
+    }
+    else if (acc.additionalProperties !== false &&
+        curr.additionalProperties &&
+        typeof curr.additionalProperties === 'object') {
+        const additionalProperties = (_a = acc.additionalProperties) !== null && _a !== void 0 ? _a : { allOf: [] };
+        additionalProperties.allOf.push(curr.additionalProperties);
+        acc.additionalProperties = additionalProperties;
+    }
+}
+export function discriminatorAndSchemaRefsMatch(schema) {
+    const discriminator = schema.discriminator;
+    if (discriminator === null || discriminator === void 0 ? void 0 : discriminator.mapping) {
+        const discriminatedRefs = Object.values(discriminator.mapping).map((ref) => ref);
+        const schemaRefs = [];
+        if ('allOf' in schema) {
+            if (Array.isArray(schema.allOf)) {
+                schema.allOf.forEach((ref) => {
+                    if ('$ref' in ref) {
+                        schemaRefs.push(ref.$ref);
+                    }
+                });
+            }
+        }
+        if ('oneOf' in schema) {
+            if (Array.isArray(schema.oneOf)) {
+                schema.oneOf.forEach((ref) => {
+                    if ('$ref' in ref) {
+                        schemaRefs.push(ref.$ref);
+                    }
+                });
+            }
+        }
+        if ('anyOf' in schema) {
+            if (Array.isArray(schema.anyOf)) {
+                schema.anyOf.forEach((ref) => {
+                    if ('$ref' in ref) {
+                        schemaRefs.push(ref.$ref);
+                    }
+                });
+            }
+        }
+        const discriminatedRefsSet = new Set(discriminatedRefs);
+        const schemaRefsSet = new Set(schemaRefs);
+        return (discriminatedRefsSet.size === schemaRefsSet.size &&
+            [...discriminatedRefsSet].every((ref) => schemaRefsSet.has(ref)));
+    }
+    else {
+        return false;
+    }
+}