@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/rules/common/path-http-verbs-order.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathHttpVerbsOrder = void 0;
+const defaultOrder = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
+const PathHttpVerbsOrder = (opts) => {
+    const order = (opts && opts.order) || defaultOrder;
+    if (!Array.isArray(order)) {
+        throw new Error('path-http-verbs-order `order` option must be an array');
+    }
+    return {
+        PathItem(path, { report, location }) {
+            const httpVerbs = Object.keys(path).filter((k) => order.includes(k));
+            for (let i = 0; i < httpVerbs.length - 1; i++) {
+                const aIdx = order.indexOf(httpVerbs[i]);
+                const bIdx = order.indexOf(httpVerbs[i + 1]);
+                if (bIdx < aIdx) {
+                    report({
+                        message: 'Operation http verbs must be ordered.',
+                        location: { reportOnKey: true, ...location.child(httpVerbs[i + 1]) },
+                    });
+                }
+            }
+        },
+    };
+};
+exports.PathHttpVerbsOrder = PathHttpVerbsOrder;

package/lib/rules/common/path-not-include-query.d.ts

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

package/lib/rules/common/path-not-include-query.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathNotIncludeQuery = void 0;
+const PathNotIncludeQuery = () => {
+    return {
+        Paths: {
+            PathItem(_operation, { report, key }) {
+                if (key.toString().includes('?')) {
+                    report({
+                        message: `Don't put query string items in the path, they belong in parameters with \`in: query\`.`,
+                        location: { reportOnKey: true },
+                    });
+                }
+            },
+        },
+    };
+};
+exports.PathNotIncludeQuery = PathNotIncludeQuery;

package/lib/rules/common/path-params-defined.d.ts

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

package/lib/rules/common/path-params-defined.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathParamsDefined = void 0;
+const pathRegex = /\{([a-zA-Z0-9_.-]+)\}+/g;
+const PathParamsDefined = () => {
+    let pathTemplateParams;
+    let definedPathParams;
+    let currentPath;
+    let definedOperationParams;
+    return {
+        PathItem: {
+            enter(_, { key }) {
+                definedPathParams = new Set();
+                currentPath = key;
+                pathTemplateParams = new Set(Array.from(key.toString().matchAll(pathRegex)).map((m) => m[1]));
+            },
+            Parameter(parameter, { report, location }) {
+                if (parameter.in === 'path' && parameter.name) {
+                    definedPathParams.add(parameter.name);
+                    if (!pathTemplateParams.has(parameter.name)) {
+                        report({
+                            message: `Path parameter \`${parameter.name}\` is not used in the path \`${currentPath}\`.`,
+                            location: location.child(['name']),
+                        });
+                    }
+                }
+            },
+            Operation: {
+                enter() {
+                    definedOperationParams = new Set();
+                },
+                leave(_op, { report, location }) {
+                    for (const templateParam of Array.from(pathTemplateParams.keys())) {
+                        if (!definedOperationParams.has(templateParam) &&
+                            !definedPathParams.has(templateParam)) {
+                            report({
+                                message: `The operation does not define the path parameter \`{${templateParam}}\` expected by path \`${currentPath}\`.`,
+                                location: location.child(['parameters']).key(), // report on operation
+                            });
+                        }
+                    }
+                },
+                Parameter(parameter, { report, location }) {
+                    if (parameter.in === 'path' && parameter.name) {
+                        definedOperationParams.add(parameter.name);
+                        if (!pathTemplateParams.has(parameter.name)) {
+                            report({
+                                message: `Path parameter \`${parameter.name}\` is not used in the path \`${currentPath}\`.`,
+                                location: location.child(['name']),
+                            });
+                        }
+                    }
+                },
+            },
+        },
+    };
+};
+exports.PathParamsDefined = PathParamsDefined;

package/lib/rules/common/path-segment-plural.d.ts

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

package/lib/rules/common/path-segment-plural.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathSegmentPlural = void 0;
+const pluralize = require("pluralize");
+const utils_1 = require("../../utils");
+const PathSegmentPlural = (opts) => {
+    const { ignoreLastPathSegment, exceptions } = opts;
+    return {
+        PathItem: {
+            leave(_path, { report, key, location }) {
+                const pathKey = key.toString();
+                if (pathKey.startsWith('/')) {
+                    const pathSegments = pathKey.split('/');
+                    pathSegments.shift();
+                    if (ignoreLastPathSegment && pathSegments.length > 1) {
+                        pathSegments.pop();
+                    }
+                    for (const pathSegment of pathSegments) {
+                        if (exceptions && exceptions.includes(pathSegment))
+                            continue;
+                        if (!(0, utils_1.isPathParameter)(pathSegment) && pluralize.isSingular(pathSegment)) {
+                            report({
+                                message: `path segment \`${pathSegment}\` should be plural.`,
+                                location: location.key(),
+                            });
+                        }
+                    }
+                }
+            },
+        },
+    };
+};
+exports.PathSegmentPlural = PathSegmentPlural;

package/lib/rules/common/paths-kebab-case.d.ts

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

package/lib/rules/common/paths-kebab-case.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathsKebabCase = void 0;
+const PathsKebabCase = () => {
+    return {
+        PathItem(_path, { report, key }) {
+            const segments = key
+                .substr(1)
+                .split('/')
+                .filter((s) => s !== ''); // filter out empty segments
+            if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
+                report({
+                    message: `\`${key}\` does not use kebab-case.`,
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+exports.PathsKebabCase = PathsKebabCase;

package/lib/rules/common/required-string-property-missing-min-length.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule } from 'core/src/visitors';
+export declare const RequiredStringPropertyMissingMinLength: Oas3Rule;

package/lib/rules/common/required-string-property-missing-min-length.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredStringPropertyMissingMinLength = void 0;
+const RequiredStringPropertyMissingMinLength = () => {
+    let skipSchemaProperties;
+    let requiredPropertiesSet;
+    return {
+        Schema: {
+            enter(schema) {
+                if (!schema?.required) {
+                    skipSchemaProperties = true;
+                    return;
+                }
+                requiredPropertiesSet = new Set(schema.required);
+                skipSchemaProperties = false;
+            },
+            SchemaProperties: {
+                skip() {
+                    return skipSchemaProperties;
+                },
+                Schema: {
+                    enter(schema, { key, location, report }) {
+                        if (requiredPropertiesSet.has(key) && schema.type === 'string') {
+                            if (!schema?.minLength) {
+                                report({
+                                    message: 'Property minLength is required.',
+                                    location: location.key(),
+                                });
+                            }
+                        }
+                    },
+                },
+            },
+        },
+    };
+};
+exports.RequiredStringPropertyMissingMinLength = RequiredStringPropertyMissingMinLength;

package/lib/rules/common/response-contains-header.d.ts

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

package/lib/rules/common/response-contains-header.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseContainsHeader = void 0;
+const utils_1 = require("../../utils");
+const ResponseContainsHeader = (options) => {
+    const names = options.names || {};
+    return {
+        Operation: {
+            Response: {
+                enter: (response, { report, location, key }) => {
+                    const expectedHeaders = names[key] ||
+                        names[(0, utils_1.getMatchingStatusCodeRange)(key)] ||
+                        names[(0, utils_1.getMatchingStatusCodeRange)(key).toLowerCase()] ||
+                        [];
+                    for (const expectedHeader of expectedHeaders) {
+                        if (!response?.headers ||
+                            !Object.keys(response?.headers).some((header) => header.toLowerCase() === expectedHeader.toLowerCase())) {
+                            report({
+                                message: `Response object must contain a "${expectedHeader}" header.`,
+                                location: location.child('headers').key(),
+                            });
+                        }
+                    }
+                },
+            },
+        },
+    };
+};
+exports.ResponseContainsHeader = ResponseContainsHeader;

package/lib/rules/common/scalar-property-missing-example.d.ts

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

package/lib/rules/common/scalar-property-missing-example.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalarPropertyMissingExample = void 0;
+const oas_types_1 = require("../../oas-types");
+const SCALAR_TYPES = ['string', 'integer', 'number', 'boolean', 'null'];
+const ScalarPropertyMissingExample = () => {
+    return {
+        SchemaProperties(properties, { report, location, oasVersion, resolve }) {
+            for (const propName of Object.keys(properties)) {
+                const propSchema = resolve(properties[propName]).node;
+                if (!propSchema || !isScalarSchema(propSchema)) {
+                    continue;
+                }
+                if (propSchema.example === undefined &&
+                    propSchema.examples === undefined) {
+                    report({
+                        message: `Scalar property should have "example"${oasVersion === oas_types_1.SpecVersion.OAS3_1 ? ' or "examples"' : ''} defined.`,
+                        location: location.child(propName).key(),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.ScalarPropertyMissingExample = ScalarPropertyMissingExample;
+function isScalarSchema(schema) {
+    if (!schema.type) {
+        return false;
+    }
+    if (schema.allOf || schema.anyOf || schema.oneOf) {
+        // Skip allOf/oneOf/anyOf as it's complicated to validate it right now.
+        // We need core support for checking contrstrains through those keywords.
+        return false;
+    }
+    if (schema.format === 'binary') {
+        return false;
+    }
+    if (Array.isArray(schema.type)) {
+        return schema.type.every((t) => SCALAR_TYPES.includes(t));
+    }
+    return SCALAR_TYPES.includes(schema.type);
+}

package/lib/rules/common/security-defined.d.ts

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

package/lib/rules/common/security-defined.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityDefined = void 0;
+const SecurityDefined = (opts) => {
+    const referencedSchemes = new Map();
+    const operationsWithoutSecurity = [];
+    let eachOperationHasSecurity = true;
+    let path;
+    return {
+        Root: {
+            leave(root, { report }) {
+                for (const [name, scheme] of referencedSchemes.entries()) {
+                    if (scheme.defined)
+                        continue;
+                    for (const reportedFromLocation of scheme.from) {
+                        report({
+                            message: `There is no \`${name}\` security scheme defined.`,
+                            location: reportedFromLocation.key(),
+                        });
+                    }
+                }
+                if (root.security || eachOperationHasSecurity) {
+                    return;
+                }
+                else {
+                    for (const operationLocation of operationsWithoutSecurity) {
+                        report({
+                            message: `Every operation should have security defined on it or on the root level.`,
+                            location: operationLocation.key(),
+                        });
+                    }
+                }
+            },
+        },
+        SecurityScheme(_securityScheme, { key }) {
+            referencedSchemes.set(key.toString(), { defined: true, from: [] });
+        },
+        SecurityRequirement(requirements, { location }) {
+            for (const requirement of Object.keys(requirements)) {
+                const authScheme = referencedSchemes.get(requirement);
+                const requirementLocation = location.child([requirement]);
+                if (!authScheme) {
+                    referencedSchemes.set(requirement, { from: [requirementLocation] });
+                }
+                else {
+                    authScheme.from.push(requirementLocation);
+                }
+            }
+        },
+        PathItem: {
+            enter(pathItem, { key }) {
+                path = key;
+            },
+            Operation(operation, { location, key }) {
+                const isException = opts.exceptions?.some((item) => item.path === path &&
+                    (!item.methods || item.methods?.some((method) => method.toLowerCase() === key)));
+                if (!operation?.security && !isException) {
+                    eachOperationHasSecurity = false;
+                    operationsWithoutSecurity.push(location);
+                }
+            },
+        },
+    };
+};
+exports.SecurityDefined = SecurityDefined;

package/lib/rules/common/spec-strict-refs.d.ts

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

package/lib/rules/common/spec-strict-refs.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecStrictRefs = void 0;
+const ref_utils_1 = require("../../ref-utils");
+const SpecStrictRefs = () => {
+    const nodesToSkip = [
+        'Schema',
+        'Response',
+        'Parameter',
+        'RequestBody',
+        'Example',
+        'Header',
+        'SecurityScheme',
+        'Link',
+        'Callback',
+        'PathItem',
+    ];
+    return {
+        any(_node, { report, rawNode, rawLocation, type }) {
+            const shouldCheck = !nodesToSkip.includes(type.name);
+            if (shouldCheck && (0, ref_utils_1.isRef)(rawNode)) {
+                report({
+                    message: 'Field $ref is not expected here.',
+                    location: rawLocation.child('$ref').key(),
+                });
+            }
+        },
+    };
+};
+exports.SpecStrictRefs = SpecStrictRefs;

package/lib/rules/common/struct.d.ts

@@ -0,0 +1,2 @@
+import type { Oas3Rule, Oas2Rule, Async2Rule, Async3Rule, Arazzo1Rule } from '../../visitors';
+export declare const Struct: Oas3Rule | Oas2Rule | Async2Rule | Async3Rule | Arazzo1Rule;

package/lib/rules/common/struct.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Struct = void 0;
+const types_1 = require("../../types");
+const utils_1 = require("../utils");
+const ref_utils_1 = require("../../ref-utils");
+const utils_2 = require("../../utils");
+const Struct = () => {
+    return {
+        any(node, { report, type, location, rawLocation, key, resolve, ignoreNextVisitorsOnNode }) {
+            const nodeType = (0, utils_1.oasTypeOf)(node);
+            const refLocation = rawLocation !== location ? rawLocation : undefined;
+            if (type.items) {
+                if (nodeType !== 'array') {
+                    report({
+                        message: `Expected type \`${type.name}\` (array) but got \`${nodeType}\``,
+                        from: refLocation,
+                    });
+                    ignoreNextVisitorsOnNode();
+                }
+                return;
+            }
+            else if (nodeType !== 'object') {
+                if (type !== types_1.SpecExtension) {
+                    // do not validate unknown extensions structure
+                    report({
+                        message: `Expected type \`${type.name}\` (object) but got \`${nodeType}\``,
+                        from: refLocation,
+                    });
+                }
+                ignoreNextVisitorsOnNode();
+                return;
+            }
+            const required = typeof type.required === 'function' ? type.required(node, key) : type.required;
+            for (const propName of required || []) {
+                if (!node.hasOwnProperty(propName)) {
+                    report({
+                        message: `The field \`${propName}\` must be present on this level.`,
+                        from: refLocation,
+                        location: [{ reportOnKey: true }],
+                    });
+                }
+            }
+            const allowed = type.allowed?.(node);
+            if (allowed && (0, utils_2.isPlainObject)(node)) {
+                for (const propName in node) {
+                    if (allowed.includes(propName) ||
+                        (type.extensionsPrefix && propName.startsWith(type.extensionsPrefix)) ||
+                        !Object.keys(type.properties).includes(propName)) {
+                        continue;
+                    }
+                    report({
+                        message: `The field \`${propName}\` is not allowed here.`,
+                        from: refLocation,
+                        location: location.child([propName]).key(),
+                    });
+                }
+            }
+            const requiredOneOf = type.requiredOneOf || null;
+            if (requiredOneOf) {
+                let hasProperty = false;
+                for (const propName of requiredOneOf || []) {
+                    if (node.hasOwnProperty(propName)) {
+                        hasProperty = true;
+                    }
+                }
+                if (!hasProperty)
+                    report({
+                        message: `Must contain at least one of the following fields: ${type.requiredOneOf?.join(', ')}.`,
+                        from: refLocation,
+                        location: [{ reportOnKey: true }],
+                    });
+            }
+            for (const propName of Object.keys(node)) {
+                const propLocation = location.child([propName]);
+                let propValue = node[propName];
+                let propType = type.properties[propName];
+                if (propType === undefined)
+                    propType = type.additionalProperties;
+                if (typeof propType === 'function')
+                    propType = propType(propValue, propName);
+                if ((0, types_1.isNamedType)(propType)) {
+                    continue; // do nothing for named schema, it is executed with the next any call
+                }
+                const propSchema = propType;
+                const propValueType = (0, utils_1.oasTypeOf)(propValue);
+                if (propSchema === undefined) {
+                    if (propName.startsWith('x-'))
+                        continue;
+                    report({
+                        message: `Property \`${propName}\` is not expected here.`,
+                        suggest: (0, utils_1.getSuggest)(propName, Object.keys(type.properties)),
+                        from: refLocation,
+                        location: propLocation.key(),
+                    });
+                    continue;
+                }
+                if (propSchema === null) {
+                    continue; // just defined, no validation
+                }
+                if (propSchema.resolvable !== false && (0, ref_utils_1.isRef)(propValue)) {
+                    propValue = resolve(propValue).node;
+                }
+                if (propSchema.items && propSchema.items?.enum && Array.isArray(propValue)) {
+                    for (let i = 0; i < propValue.length; i++) {
+                        (0, utils_1.validateSchemaEnumType)(propSchema.items?.enum, propValue[i], propName, refLocation, {
+                            report,
+                            location: location.child([propName, i]),
+                        });
+                    }
+                }
+                if (propSchema.enum) {
+                    (0, utils_1.validateSchemaEnumType)(propSchema.enum, propValue, propName, refLocation, {
+                        report,
+                        location: location.child([propName]),
+                    });
+                }
+                else if (propSchema.type && !(0, utils_1.matchesJsonSchemaType)(propValue, propSchema.type, false)) {
+                    report({
+                        message: `Expected type \`${propSchema.type}\` but got \`${propValueType}\`.`,
+                        from: refLocation,
+                        location: propLocation,
+                    });
+                    ignoreNextVisitorsOnNode();
+                }
+                else if (propValueType === 'array' && propSchema.items?.type) {
+                    const itemsType = propSchema.items?.type;
+                    for (let i = 0; i < propValue.length; i++) {
+                        const item = propValue[i];
+                        if (!(0, utils_1.matchesJsonSchemaType)(item, itemsType, false)) {
+                            report({
+                                message: `Expected type \`${itemsType}\` but got \`${(0, utils_1.oasTypeOf)(item)}\`.`,
+                                from: refLocation,
+                                location: propLocation.child([i]),
+                            });
+                        }
+                    }
+                }
+                if (typeof propSchema.minimum === 'number') {
+                    if (propSchema.minimum > node[propName]) {
+                        report({
+                            message: `The value of the ${propName} field must be greater than or equal to ${propSchema.minimum}`,
+                            from: refLocation,
+                            location: location.child([propName]),
+                        });
+                    }
+                }
+                if (propName === 'nullable' && !node.type) {
+                    report({
+                        message: 'The `type` field must be defined when the `nullable` field is used.',
+                        location: location.child([propName]),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.Struct = Struct;

package/lib/rules/common/tag-description.d.ts

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

package/lib/rules/common/tag-description.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagDescription = void 0;
+const utils_1 = require("../utils");
+const TagDescription = () => {
+    return {
+        Tag(tag, ctx) {
+            (0, utils_1.validateDefinedAndNonEmpty)('description', tag, ctx);
+        },
+    };
+};
+exports.TagDescription = TagDescription;

package/lib/rules/common/tags-alphabetical.d.ts

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

package/lib/rules/common/tags-alphabetical.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagsAlphabetical = void 0;
+const TagsAlphabetical = ({ ignoreCase = false }) => {
+    return {
+        Root(root, { report, location }) {
+            if (!root.tags)
+                return;
+            for (let i = 0; i < root.tags.length - 1; i++) {
+                if (getTagName(root.tags[i], ignoreCase) > getTagName(root.tags[i + 1], ignoreCase)) {
+                    report({
+                        message: 'The `tags` array should be in alphabetical order.',
+                        location: location.child(['tags', i]),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.TagsAlphabetical = TagsAlphabetical;
+function getTagName(tag, ignoreCase) {
+    return ignoreCase ? tag.name.toLowerCase() : tag.name;
+}

package/lib/rules/no-unresolved-refs.d.ts

@@ -0,0 +1,5 @@
+import type { Oas3Rule } from '../visitors';
+import type { ResolveResult, Problem } from '../walk';
+import type { Location } from '../ref-utils';
+export declare const NoUnresolvedRefs: Oas3Rule;
+export declare function reportUnresolvedRef(resolved: ResolveResult<any>, report: (m: Problem) => void, location: Location): void;