@redocly/openapi-core 1.0.0-beta.100

package/lib/rules/oas3/no-server-trailing-slash.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoServerTrailingSlash = void 0;
+const NoServerTrailingSlash = () => {
+    return {
+        Server(server, { report, location }) {
+            if (!server.url)
+                return;
+            if (server.url.endsWith('/') && server.url !== '/') {
+                report({
+                    message: 'Server `url` should not have a trailing slash.',
+                    location: location.child(['url']),
+                });
+            }
+        },
+    };
+};
+exports.NoServerTrailingSlash = NoServerTrailingSlash;

package/lib/rules/oas3/no-servers-empty-enum.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule } from '../../visitors';
+export declare const NoEmptyEnumServers: Oas3Rule;

package/lib/rules/oas3/no-servers-empty-enum.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoEmptyEnumServers = void 0;
+var enumError;
+(function (enumError) {
+    enumError["empty"] = "empty";
+    enumError["invalidDefaultValue"] = "invalidDefaultValue";
+})(enumError || (enumError = {}));
+const NoEmptyEnumServers = () => {
+    return {
+        DefinitionRoot(root, { report, location }) {
+            if (!root.servers || root.servers.length === 0)
+                return;
+            const invalidVariables = [];
+            if (Array.isArray(root.servers)) {
+                for (const server of root.servers) {
+                    const enumErrors = checkEnumVariables(server);
+                    if (!enumErrors)
+                        continue;
+                    invalidVariables.push(...enumErrors);
+                }
+            }
+            else {
+                const enumErrors = checkEnumVariables(root.servers);
+                if (!enumErrors)
+                    return;
+                invalidVariables.push(...enumErrors);
+            }
+            for (const invalidVariable of invalidVariables) {
+                if (invalidVariable === enumError.empty) {
+                    report({
+                        message: 'Server variable with `enum` must be a non-empty array.',
+                        location: location.child(['servers']).key(),
+                    });
+                }
+                if (invalidVariable === enumError.invalidDefaultValue) {
+                    report({
+                        message: 'Server variable define `enum` and `default`. `enum` must include default value',
+                        location: location.child(['servers']).key(),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.NoEmptyEnumServers = NoEmptyEnumServers;
+function checkEnumVariables(server) {
+    var _a;
+    if (server.variables && Object.keys(server.variables).length === 0)
+        return;
+    const errors = [];
+    for (var variable in server.variables) {
+        const serverVariable = server.variables[variable];
+        if (!serverVariable.enum)
+            continue;
+        if (Array.isArray(serverVariable.enum) && ((_a = serverVariable.enum) === null || _a === void 0 ? void 0 : _a.length) === 0)
+            errors.push(enumError.empty);
+        if (!serverVariable.default)
+            continue;
+        const defaultValue = server.variables[variable].default;
+        if (serverVariable.enum && !serverVariable.enum.includes(defaultValue))
+            errors.push(enumError.invalidDefaultValue);
+    }
+    if (errors.length)
+        return errors;
+    return;
+}

package/lib/rules/oas3/no-undefined-server-variable.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule } from '../../visitors';
+export declare const NoUndefinedServerVariable: Oas3Rule;

package/lib/rules/oas3/no-undefined-server-variable.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoUndefinedServerVariable = void 0;
+const NoUndefinedServerVariable = () => {
+    return {
+        Server(server, { report, location }) {
+            var _a;
+            if (!server.url)
+                return;
+            const urlVariables = ((_a = server.url.match(/{[^}]+}/g)) === null || _a === void 0 ? void 0 : _a.map((e) => e.slice(1, e.length - 1))) || [];
+            const definedVariables = ((server === null || server === void 0 ? void 0 : server.variables) && Object.keys(server.variables)) || [];
+            for (const serverVar of urlVariables) {
+                if (!definedVariables.includes(serverVar)) {
+                    report({
+                        message: `The \`${serverVar}\` variable is not defined in the \`variables\` objects.`,
+                        location: location.child(['url']),
+                    });
+                }
+            }
+            for (const definedServerVar of definedVariables) {
+                if (!urlVariables.includes(definedServerVar)) {
+                    report({
+                        message: `The \`${definedServerVar}\` variable is not used in the server's \`url\` field.`,
+                        location: location.child(['variables', definedServerVar]).key(),
+                        from: location.child('url'),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.NoUndefinedServerVariable = NoUndefinedServerVariable;

package/lib/rules/oas3/no-unused-components.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule } from '../../visitors';
+export declare const NoUnusedComponents: Oas3Rule;

package/lib/rules/oas3/no-unused-components.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoUnusedComponents = void 0;
+const NoUnusedComponents = () => {
+    let components = new Map();
+    function registerComponent(location, name) {
+        var _a;
+        components.set(location.absolutePointer, {
+            used: ((_a = components.get(location.absolutePointer)) === null || _a === void 0 ? void 0 : _a.used) || false,
+            location,
+            name,
+        });
+    }
+    return {
+        ref(ref, { type, resolve, key, location }) {
+            if (['Schema', 'Header', 'Parameter', 'Response', 'Example', 'RequestBody'].includes(type.name)) {
+                const resolvedRef = resolve(ref);
+                if (!resolvedRef.location)
+                    return;
+                components.set(resolvedRef.location.absolutePointer, {
+                    used: true,
+                    name: key.toString(),
+                    location,
+                });
+            }
+        },
+        DefinitionRoot: {
+            leave(_, { report }) {
+                components.forEach((usageInfo) => {
+                    if (!usageInfo.used) {
+                        report({
+                            message: `Component: "${usageInfo.name}" is never used.`,
+                            location: usageInfo.location.key(),
+                        });
+                    }
+                });
+            },
+        },
+        NamedSchemas: {
+            Schema(schema, { location, key }) {
+                if (!schema.allOf) {
+                    // FIXME: find a better way to detect possible discriminator
+                    registerComponent(location, key.toString());
+                }
+            },
+        },
+        NamedParameters: {
+            Parameter(_parameter, { location, key }) {
+                registerComponent(location, key.toString());
+            },
+        },
+        NamedResponses: {
+            Response(_response, { location, key }) {
+                registerComponent(location, key.toString());
+            },
+        },
+        NamedExamples: {
+            Example(_example, { location, key }) {
+                registerComponent(location, key.toString());
+            },
+        },
+        NamedRequestBodies: {
+            RequestBody(_requestBody, { location, key }) {
+                registerComponent(location, key.toString());
+            },
+        },
+        NamedHeaders: {
+            Header(_header, { location, key }) {
+                registerComponent(location, key.toString());
+            },
+        },
+    };
+};
+exports.NoUnusedComponents = NoUnusedComponents;

package/lib/rules/oas3/remove-unused-components.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule } from '../../visitors';
+export declare const RemoveUnusedComponents: Oas3Rule;

package/lib/rules/oas3/remove-unused-components.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveUnusedComponents = void 0;
+const utils_1 = require("../../utils");
+const RemoveUnusedComponents = () => {
+    let components = new Map();
+    function registerComponent(location, componentType, name) {
+        var _a;
+        components.set(location.absolutePointer, {
+            used: ((_a = components.get(location.absolutePointer)) === null || _a === void 0 ? void 0 : _a.used) || false,
+            componentType,
+            name,
+        });
+    }
+    return {
+        ref: {
+            leave(ref, { type, resolve, key }) {
+                if (['Schema', 'Header', 'Parameter', 'Response', 'Example', 'RequestBody'].includes(type.name)) {
+                    const resolvedRef = resolve(ref);
+                    if (!resolvedRef.location)
+                        return;
+                    components.set(resolvedRef.location.absolutePointer, {
+                        used: true,
+                        name: key.toString(),
+                    });
+                }
+            }
+        },
+        DefinitionRoot: {
+            leave(root, ctx) {
+                const data = ctx.getVisitorData();
+                data.removedCount = 0;
+                components.forEach(usageInfo => {
+                    const { used, componentType, name } = usageInfo;
+                    if (!used && componentType) {
+                        let componentChild = root.components[componentType];
+                        delete componentChild[name];
+                        data.removedCount++;
+                        if (utils_1.isEmptyObject(componentChild)) {
+                            delete root.components[componentType];
+                        }
+                    }
+                });
+                if (utils_1.isEmptyObject(root.components)) {
+                    delete root.components;
+                }
+            },
+        },
+        NamedSchemas: {
+            Schema(schema, { location, key }) {
+                if (!schema.allOf) {
+                    registerComponent(location, 'schemas', key.toString());
+                }
+            },
+        },
+        NamedParameters: {
+            Parameter(_parameter, { location, key }) {
+                registerComponent(location, 'parameters', key.toString());
+            },
+        },
+        NamedResponses: {
+            Response(_response, { location, key }) {
+                registerComponent(location, 'responses', key.toString());
+            },
+        },
+        NamedExamples: {
+            Example(_example, { location, key }) {
+                registerComponent(location, 'examples', key.toString());
+            },
+        },
+        NamedRequestBodies: {
+            RequestBody(_requestBody, { location, key }) {
+                registerComponent(location, 'requestBodies', key.toString());
+            },
+        },
+        NamedHeaders: {
+            Header(_header, { location, key }) {
+                registerComponent(location, 'headers', key.toString());
+            },
+        },
+    };
+};
+exports.RemoveUnusedComponents = RemoveUnusedComponents;

package/lib/rules/oas3/request-mime-type.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule } from '../../visitors';
+export declare const RequestMimeType: Oas3Rule;

package/lib/rules/oas3/request-mime-type.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestMimeType = void 0;
+const utils_1 = require("../../utils");
+const RequestMimeType = ({ allowedValues }) => {
+    return {
+        PathMap: {
+            RequestBody: {
+                leave(requestBody, ctx) {
+                    utils_1.validateMimeTypeOAS3({ type: 'consumes', value: requestBody }, ctx, allowedValues);
+                },
+            },
+            Callback: {
+                RequestBody() { },
+                Response: {
+                    leave(response, ctx) {
+                        utils_1.validateMimeTypeOAS3({ type: 'consumes', value: response }, ctx, allowedValues);
+                    },
+                },
+            },
+        },
+        WebhooksMap: {
+            Response: {
+                leave(response, ctx) {
+                    utils_1.validateMimeTypeOAS3({ type: 'consumes', value: response }, ctx, allowedValues);
+                },
+            },
+        },
+    };
+};
+exports.RequestMimeType = RequestMimeType;

package/lib/rules/oas3/response-contains-property.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule } from '../../visitors';
+export declare const ResponseContainsProperty: Oas3Rule;

package/lib/rules/oas3/response-contains-property.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseContainsProperty = void 0;
+const utils_1 = require("../../utils");
+const ResponseContainsProperty = (options) => {
+    const names = options.names || {};
+    let key;
+    return {
+        Operation: {
+            Response: {
+                skip: (_response, key) => {
+                    return `${key}` === '204';
+                },
+                enter: (_response, ctx) => {
+                    key = ctx.key;
+                },
+                MediaType: {
+                    Schema(schema, { report, location }) {
+                        var _a;
+                        if (schema.type !== 'object')
+                            return;
+                        const expectedProperties = names[key] ||
+                            names[utils_1.getMatchingStatusCodeRange(key)] ||
+                            names[utils_1.getMatchingStatusCodeRange(key).toLowerCase()] ||
+                            [];
+                        for (const expectedProperty of expectedProperties) {
+                            if (!((_a = schema.properties) === null || _a === void 0 ? void 0 : _a[expectedProperty])) {
+                                report({
+                                    message: `Response object must contain a top-level "${expectedProperty}" property.`,
+                                    location: location.child('properties').key(),
+                                });
+                            }
+                        }
+                    },
+                },
+            },
+        },
+    };
+};
+exports.ResponseContainsProperty = ResponseContainsProperty;

package/lib/rules/oas3/response-mime-type.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule } from '../../visitors';
+export declare const ResponseMimeType: Oas3Rule;

package/lib/rules/oas3/response-mime-type.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseMimeType = void 0;
+const utils_1 = require("../../utils");
+const ResponseMimeType = ({ allowedValues }) => {
+    return {
+        PathMap: {
+            Response: {
+                leave(response, ctx) {
+                    utils_1.validateMimeTypeOAS3({ type: 'produces', value: response }, ctx, allowedValues);
+                },
+            },
+            Callback: {
+                Response() { },
+                RequestBody: {
+                    leave(requestBody, ctx) {
+                        utils_1.validateMimeTypeOAS3({ type: 'produces', value: requestBody }, ctx, allowedValues);
+                    },
+                },
+            },
+        },
+        WebhooksMap: {
+            RequestBody: {
+                leave(requestBody, ctx) {
+                    utils_1.validateMimeTypeOAS3({ type: 'produces', value: requestBody }, ctx, allowedValues);
+                },
+            },
+        },
+    };
+};
+exports.ResponseMimeType = ResponseMimeType;

package/lib/rules/other/stats.d.ts

@@ -0,0 +1,41 @@
+import { Oas3Parameter, OasRef, Oas3Tag } from '../../typings/openapi';
+import { Oas2Parameter } from '../../typings/swagger';
+import { StatsAccumulator } from '../../typings/common';
+export declare const Stats: (statsAccumulator: StatsAccumulator) => {
+    ExternalDocs: {
+        leave(): void;
+    };
+    ref: {
+        enter(ref: OasRef): void;
+    };
+    Tag: {
+        leave(tag: Oas3Tag): void;
+    };
+    Link: {
+        leave(link: any): void;
+    };
+    DefinitionRoot: {
+        leave(): void;
+    };
+    WebhooksMap: {
+        Operation: {
+            leave(operation: any): void;
+        };
+    };
+    PathMap: {
+        PathItem: {
+            leave(): void;
+            Operation: {
+                leave(operation: any): void;
+            };
+            Parameter: {
+                leave(parameter: Oas2Parameter | Oas3Parameter): void;
+            };
+        };
+    };
+    NamedSchemas: {
+        Schema: {
+            leave(): void;
+        };
+    };
+};

package/lib/rules/other/stats.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stats = void 0;
+const Stats = (statsAccumulator) => {
+    return {
+        ExternalDocs: { leave() { statsAccumulator.externalDocs.total++; } },
+        ref: { enter(ref) { statsAccumulator.refs.items.add(ref['$ref']); } },
+        Tag: { leave(tag) { statsAccumulator.tags.items.add(tag.name); } },
+        Link: { leave(link) { statsAccumulator.links.items.add(link.operationId); } },
+        DefinitionRoot: {
+            leave() {
+                statsAccumulator.parameters.total = statsAccumulator.parameters.items.size;
+                statsAccumulator.refs.total = statsAccumulator.refs.items.size;
+                statsAccumulator.links.total = statsAccumulator.links.items.size;
+                statsAccumulator.tags.total = statsAccumulator.tags.items.size;
+            },
+        },
+        WebhooksMap: {
+            Operation: {
+                leave(operation) {
+                    operation.tags.forEach((tag) => { statsAccumulator.tags.items.add(tag); });
+                }
+            }
+        },
+        PathMap: {
+            PathItem: {
+                leave() { statsAccumulator.pathItems.total++; },
+                Operation: {
+                    leave(operation) {
+                        statsAccumulator.operations.total++;
+                        operation.tags && operation.tags.forEach((tag) => { statsAccumulator.tags.items.add(tag); });
+                    }
+                },
+                Parameter: { leave(parameter) {
+                        statsAccumulator.parameters.items.add(parameter.name);
+                    } },
+            },
+        },
+        NamedSchemas: {
+            Schema: { leave() { statsAccumulator.schemas.total++; } }
+        }
+    };
+};
+exports.Stats = Stats;

package/lib/rules/utils.d.ts

@@ -0,0 +1,17 @@
+import { UserContext } from '../walk';
+import { Location } from '../ref-utils';
+import { Oas3Schema, Referenced } from '../typings/openapi';
+export declare function oasTypeOf(value: unknown): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "array" | "null";
+/**
+ * Checks if value matches specified JSON schema type
+ *
+ * @param {*} value - value to check
+ * @param {JSONSchemaType} type - JSON Schema type
+ * @returns boolean
+ */
+export declare function matchesJsonSchemaType(value: unknown, type: string, nullable: boolean): boolean;
+export declare function missingRequiredField(type: string, field: string): string;
+export declare function fieldNonEmpty(type: string, field: string): string;
+export declare function validateDefinedAndNonEmpty(fieldName: string, value: any, ctx: UserContext): void;
+export declare function getSuggest(given: string, variants: string[]): string[];
+export declare function validateExample(example: any, schema: Referenced<Oas3Schema>, dataLoc: Location, { resolve, location, report }: UserContext, disallowAdditionalProperties: boolean): void;

package/lib/rules/utils.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExample = exports.getSuggest = exports.validateDefinedAndNonEmpty = exports.fieldNonEmpty = exports.missingRequiredField = exports.matchesJsonSchemaType = exports.oasTypeOf = void 0;
+const levenshtein = require("js-levenshtein");
+const ref_utils_1 = require("../ref-utils");
+const ajv_1 = require("./ajv");
+function oasTypeOf(value) {
+    if (Array.isArray(value)) {
+        return 'array';
+    }
+    else if (value === null) {
+        return 'null';
+    }
+    else {
+        return typeof value;
+    }
+}
+exports.oasTypeOf = oasTypeOf;
+/**
+ * Checks if value matches specified JSON schema type
+ *
+ * @param {*} value - value to check
+ * @param {JSONSchemaType} type - JSON Schema type
+ * @returns boolean
+ */
+function matchesJsonSchemaType(value, type, nullable) {
+    if (nullable && value === null) {
+        return value === null;
+    }
+    switch (type) {
+        case 'array':
+            return Array.isArray(value);
+        case 'object':
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        case 'null':
+            return value === null;
+        case 'integer':
+            return Number.isInteger(value);
+        default:
+            return typeof value === type;
+    }
+}
+exports.matchesJsonSchemaType = matchesJsonSchemaType;
+function missingRequiredField(type, field) {
+    return `${type} object should contain \`${field}\` field.`;
+}
+exports.missingRequiredField = missingRequiredField;
+function fieldNonEmpty(type, field) {
+    return `${type} object \`${field}\` must be non-empty string.`;
+}
+exports.fieldNonEmpty = fieldNonEmpty;
+function validateDefinedAndNonEmpty(fieldName, value, ctx) {
+    if (typeof value !== 'object') {
+        return;
+    }
+    if (value[fieldName] === undefined) {
+        ctx.report({
+            message: missingRequiredField(ctx.type.name, fieldName),
+            location: ctx.location.child([fieldName]).key(),
+        });
+    }
+    else if (!value[fieldName]) {
+        ctx.report({
+            message: fieldNonEmpty(ctx.type.name, fieldName),
+            location: ctx.location.child([fieldName]).key(),
+        });
+    }
+}
+exports.validateDefinedAndNonEmpty = validateDefinedAndNonEmpty;
+function getSuggest(given, variants) {
+    if (typeof given !== 'string' || !variants.length)
+        return [];
+    const distances = [];
+    for (let i = 0; i < variants.length; i++) {
+        const distance = levenshtein(given, variants[i]);
+        if (distance < 4) {
+            distances.push({ distance, variant: variants[i] });
+        }
+    }
+    distances.sort((a, b) => a.distance - b.distance);
+    // if (bestMatch.distance <= 4) return bestMatch.string;
+    return distances.map((d) => d.variant);
+}
+exports.getSuggest = getSuggest;
+function validateExample(example, schema, dataLoc, { resolve, location, report }, disallowAdditionalProperties) {
+    try {
+        const { valid, errors } = ajv_1.validateJsonSchema(example, schema, location.child('schema'), dataLoc.pointer, resolve, disallowAdditionalProperties);
+        if (!valid) {
+            for (let error of errors) {
+                report({
+                    message: `Example value must conform to the schema: ${error.message}.`,
+                    location: Object.assign(Object.assign({}, new ref_utils_1.Location(dataLoc.source, error.instancePath)), { reportOnKey: error.keyword === 'additionalProperties' }),
+                    from: location,
+                    suggest: error.suggest,
+                });
+            }
+        }
+    }
+    catch (e) {
+        report({
+            message: `Example validation errored: ${e.message}.`,
+            location: location.child('schema'),
+            from: location,
+        });
+    }
+}
+exports.validateExample = validateExample;