@redocly/openapi-core 1.0.0-beta.99 → 1.0.0-rc.1

package/lib/rules/common/assertions/index.d.ts

@@ -1,2 +1,27 @@
-import { Oas2Rule, Oas3Rule } from '../../../visitors';
-export declare const Assertions: Oas3Rule | Oas2Rule;
+import { asserts, AssertionFn } from './asserts';
+import { Oas2Visitor, Oas3Visitor } from '../../../visitors';
+import { RuleSeverity } from '../../../config';
+export declare type AssertionLocators = {
+    filterInParentKeys?: (string | number)[];
+    filterOutParentKeys?: (string | number)[];
+    matchParentKeys?: string;
+};
+export declare type AssertionDefinition = {
+    subject: {
+        type: string;
+        property?: string | string[];
+    } & AssertionLocators;
+    assertions: {
+        [name in keyof typeof asserts]?: AssertionFn;
+    };
+};
+export declare type RawAssertion = AssertionDefinition & {
+    where?: AssertionDefinition[];
+    message?: string;
+    suggest?: string[];
+    severity?: RuleSeverity;
+};
+export declare type Assertion = RawAssertion & {
+    assertionId: string;
+};
+export declare const Assertions: (opts: Record<string, Assertion>) => (Oas3Visitor | Oas2Visitor)[];

package/lib/rules/common/assertions/index.js

@@ -1,51 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Assertions = void 0;
-const asserts_1 = require("./asserts");
 const utils_1 = require("./utils");
+const utils_2 = require("../../../utils");
 const Assertions = (opts) => {
-    let visitors = [];
+    const visitors = [];
     // As 'Assertions' has an array of asserts,
     // that array spreads into an 'opts' object on init rules phase here
-    // https://github.com/Redocly/redocly-cli/blob/master/packages/core/src/config/config.ts#L311
+    // https://github.com/Redocly/redocly-cli/blob/main/packages/core/src/config/config.ts#L311
     // that is why we need to iterate through 'opts' values;
     // before - filter only object 'opts' values
     const assertions = Object.values(opts).filter((opt) => typeof opt === 'object' && opt !== null);
-    for (const [index, assertion] of assertions.entries()) {
-        const assertId = (assertion.assertionId && `${assertion.assertionId} assertion`) || `assertion #${index + 1}`;
-        if (!assertion.subject) {
-            throw new Error(`${assertId}: 'subject' is required`);
-        }
-        const subjects = Array.isArray(assertion.subject)
-            ? assertion.subject
-            : [assertion.subject];
-        const assertsToApply = Object.keys(asserts_1.asserts)
-            .filter((assertName) => assertion[assertName] !== undefined)
-            .map((assertName) => {
-            return {
-                assertId,
-                name: assertName,
-                conditions: assertion[assertName],
-                message: assertion.message,
-                severity: assertion.severity || 'error',
-                suggest: assertion.suggest || [],
-                runsOnKeys: asserts_1.runOnKeysSet.has(assertName),
-                runsOnValues: asserts_1.runOnValuesSet.has(assertName),
-            };
-        });
-        const shouldRunOnKeys = assertsToApply.find((assert) => assert.runsOnKeys && !assert.runsOnValues);
-        const shouldRunOnValues = assertsToApply.find((assert) => assert.runsOnValues && !assert.runsOnKeys);
-        if (shouldRunOnValues && !assertion.property) {
-            throw new Error(`${shouldRunOnValues.name} can't be used on all keys. Please provide a single property.`);
-        }
-        if (shouldRunOnKeys && assertion.property) {
-            throw new Error(`${shouldRunOnKeys.name} can't be used on a single property. Please use 'property'.`);
-        }
-        for (const subject of subjects) {
-            const subjectVisitor = utils_1.buildSubjectVisitor(assertion.property, assertsToApply, assertion.context);
-            const visitorObject = utils_1.buildVisitorObject(subject, assertion.context, subjectVisitor);
-            visitors.push(visitorObject);
+    for (const [_, assertion] of assertions.entries()) {
+        if (!utils_2.isString(assertion.subject.type)) {
+            throw new Error(`${assertion.assertionId}: 'type' (String) is required`);
         }
+        const subjectVisitor = utils_1.buildSubjectVisitor(assertion.assertionId, assertion);
+        const visitorObject = utils_1.buildVisitorObject(assertion, subjectVisitor);
+        visitors.push(visitorObject);
     }
     return visitors;
 };

package/lib/rules/common/assertions/utils.d.ts

@@ -1,20 +1,28 @@
-import { ProblemSeverity, UserContext } from '../../../walk';
+import { Asserts } from './asserts';
+import type { AssertionContext, AssertResult } from '../../../config';
+import type { Assertion, AssertionDefinition } from '.';
+import type { Oas2Visitor, Oas3Visitor, VisitFunction } from '../../../visitors';
 export declare type OrderDirection = 'asc' | 'desc';
 export declare type OrderOptions = {
     direction: OrderDirection;
     property: string;
 };
 export declare type AssertToApply = {
-    name: string;
-    assertId?: string;
+    name: keyof Asserts;
     conditions: any;
-    message?: string;
-    severity?: ProblemSeverity;
-    suggest?: string[];
     runsOnKeys: boolean;
     runsOnValues: boolean;
 };
-export declare function buildVisitorObject(subject: string, context: Record<string, any>[], subjectVisitor: any): Record<string, any>;
-export declare function buildSubjectVisitor(properties: string | string[], asserts: AssertToApply[], context?: Record<string, any>[]): (node: any, { report, location, key, type, resolve }: UserContext) => void;
+declare type RunAssertionParams = {
+    ctx: AssertionContext;
+    assert: AssertToApply;
+    assertionProperty?: string;
+};
+export declare function getAssertsToApply(assertion: AssertionDefinition): AssertToApply[];
+export declare function buildVisitorObject(assertion: Assertion, subjectVisitor: VisitFunction<any>): Oas2Visitor | Oas3Visitor;
+export declare function buildSubjectVisitor(assertId: string, assertion: Assertion): VisitFunction<any>;
 export declare function getIntersectionLength(keys: string[], properties: string[]): number;
 export declare function isOrdered(value: any[], options: OrderOptions | OrderDirection): boolean;
+export declare function runAssertion({ assert, ctx, assertionProperty, }: RunAssertionParams): AssertResult[];
+export declare function regexFromString(input: string): RegExp | null;
+export {};

package/lib/rules/common/assertions/utils.js

@@ -1,86 +1,154 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = void 0;
-const ref_utils_1 = require("../../../ref-utils");
+exports.regexFromString = exports.runAssertion = exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = exports.getAssertsToApply = void 0;
 const asserts_1 = require("./asserts");
-function buildVisitorObject(subject, context, subjectVisitor) {
-    if (!context) {
-        return { [subject]: subjectVisitor };
+const logger_1 = require("../../../logger");
+const ref_utils_1 = require("../../../ref-utils");
+const utils_1 = require("../../../utils");
+const assertionMessageTemplates = {
+    problems: '{{problems}}',
+};
+function getPredicatesFromLocators(locators) {
+    const { filterInParentKeys, filterOutParentKeys, matchParentKeys } = locators;
+    const keyMatcher = matchParentKeys && regexFromString(matchParentKeys);
+    const matchKeysPredicate = keyMatcher && ((key) => keyMatcher.test(key.toString()));
+    const filterInPredicate = Array.isArray(filterInParentKeys) &&
+        ((key) => filterInParentKeys.includes(key.toString()));
+    const filterOutPredicate = Array.isArray(filterOutParentKeys) &&
+        ((key) => !filterOutParentKeys.includes(key.toString()));
+    return [matchKeysPredicate, filterInPredicate, filterOutPredicate].filter(utils_1.isTruthy);
+}
+function getAssertsToApply(assertion) {
+    const assertsToApply = utils_1.keysOf(asserts_1.asserts)
+        .filter((assertName) => assertion.assertions[assertName] !== undefined)
+        .map((assertName) => {
+        return {
+            name: assertName,
+            conditions: assertion.assertions[assertName],
+            runsOnKeys: asserts_1.runOnKeysSet.has(assertName),
+            runsOnValues: asserts_1.runOnValuesSet.has(assertName),
+        };
+    });
+    const shouldRunOnKeys = assertsToApply.find((assert) => assert.runsOnKeys && !assert.runsOnValues);
+    const shouldRunOnValues = assertsToApply.find((assert) => assert.runsOnValues && !assert.runsOnKeys);
+    if (shouldRunOnValues && !assertion.subject.property) {
+        throw new Error(`${shouldRunOnValues.name} can't be used on all keys. Please provide a single property`);
+    }
+    if (shouldRunOnKeys && assertion.subject.property) {
+        throw new Error(`${shouldRunOnKeys.name} can't be used on a single property. Please use 'property'.`);
+    }
+    return assertsToApply;
+}
+exports.getAssertsToApply = getAssertsToApply;
+function getAssertionProperties({ subject }) {
+    return (Array.isArray(subject.property) ? subject.property : [subject === null || subject === void 0 ? void 0 : subject.property]).filter(Boolean);
+}
+function applyAssertions(assertionDefinition, asserts, ctx) {
+    const properties = getAssertionProperties(assertionDefinition);
+    const assertResults = [];
+    for (const assert of asserts) {
+        if (properties.length) {
+            for (const property of properties) {
+                assertResults.push(runAssertion({
+                    assert,
+                    ctx,
+                    assertionProperty: property,
+                }));
+            }
+        }
+        else {
+            assertResults.push(runAssertion({
+                assert,
+                ctx,
+            }));
+        }
+    }
+    return assertResults.flat();
+}
+function buildVisitorObject(assertion, subjectVisitor) {
+    var _a, _b;
+    const targetVisitorLocatorPredicates = getPredicatesFromLocators(assertion.subject);
+    const targetVisitorSkipFunction = targetVisitorLocatorPredicates.length
+        ? (_, key) => !targetVisitorLocatorPredicates.every((predicate) => predicate(key))
+        : undefined;
+    const targetVisitor = {
+        [assertion.subject.type]: Object.assign({ enter: subjectVisitor }, (targetVisitorSkipFunction && { skip: targetVisitorSkipFunction })),
+    };
+    if (!Array.isArray(assertion.where)) {
+        return targetVisitor;
     }
     let currentVisitorLevel = {};
     const visitor = currentVisitorLevel;
+    const context = assertion.where;
     for (let index = 0; index < context.length; index++) {
-        const node = context[index];
-        if (context.length === index + 1 && node.type === subject) {
-            // Visitors don't work properly for the same type nested nodes, so
-            // as a workaround for that we don't create separate visitor for the last element
-            // which is the same as subject;
-            // we will check includes/excludes it in the last visitor.
-            continue;
-        }
-        const matchParentKeys = node.matchParentKeys;
-        const excludeParentKeys = node.excludeParentKeys;
-        if (matchParentKeys && excludeParentKeys) {
-            throw new Error(`Both 'matchParentKeys' and 'excludeParentKeys' can't be under one context item`);
+        const assertionDefinitionNode = context[index];
+        if (!utils_1.isString((_a = assertionDefinitionNode.subject) === null || _a === void 0 ? void 0 : _a.type)) {
+            throw new Error(`${assertion.assertionId} -> where -> [${index}]: 'type' (String) is required`);
         }
-        if (matchParentKeys || excludeParentKeys) {
-            currentVisitorLevel[node.type] = {
-                skip: (_value, key) => {
-                    if (matchParentKeys) {
-                        return !matchParentKeys.includes(key);
-                    }
-                    if (excludeParentKeys) {
-                        return excludeParentKeys.includes(key);
-                    }
-                },
-            };
+        const locatorPredicates = getPredicatesFromLocators(assertionDefinitionNode.subject);
+        const assertsToApply = getAssertsToApply(assertionDefinitionNode);
+        const skipFunction = (node, key, ctx) => !locatorPredicates.every((predicate) => predicate(key)) ||
+            !!applyAssertions(assertionDefinitionNode, assertsToApply, Object.assign(Object.assign({}, ctx), { node })).length;
+        const nodeVisitor = Object.assign({}, ((locatorPredicates.length || assertsToApply.length) && { skip: skipFunction }));
+        if (assertionDefinitionNode.subject.type === assertion.subject.type &&
+            index === context.length - 1) {
+            // We have to merge the visitors if the last node inside the `where` is the same as the subject.
+            targetVisitor[assertion.subject.type] = Object.assign({ enter: subjectVisitor }, ((nodeVisitor.skip && { skip: nodeVisitor.skip }) ||
+                (targetVisitorSkipFunction && {
+                    skip: (node, key, ctx // We may have locators defined on assertion level and on where level for the same node type
+                    ) => { var _a; return !!(((_a = nodeVisitor.skip) === null || _a === void 0 ? void 0 : _a.call(nodeVisitor, node, key, ctx)) || (targetVisitorSkipFunction === null || targetVisitorSkipFunction === void 0 ? void 0 : targetVisitorSkipFunction(node, key))); },
+                })));
         }
         else {
-            currentVisitorLevel[node.type] = {};
+            currentVisitorLevel = currentVisitorLevel[(_b = assertionDefinitionNode.subject) === null || _b === void 0 ? void 0 : _b.type] =
+                nodeVisitor;
         }
-        currentVisitorLevel = currentVisitorLevel[node.type];
     }
-    currentVisitorLevel[subject] = subjectVisitor;
+    currentVisitorLevel[assertion.subject.type] = targetVisitor[assertion.subject.type];
     return visitor;
 }
 exports.buildVisitorObject = buildVisitorObject;
-function buildSubjectVisitor(properties, asserts, context) {
-    return function (node, { report, location, key, type, resolve }) {
-        var _a;
-        // We need to check context's last node if it has the same type as subject node;
-        // if yes - that means we didn't create context's last node visitor,
-        // so we need to handle 'matchParentKeys' and 'excludeParentKeys' conditions here;
-        if (context) {
-            const lastContextNode = context[context.length - 1];
-            if (lastContextNode.type === type.name) {
-                const matchParentKeys = lastContextNode.matchParentKeys;
-                const excludeParentKeys = lastContextNode.excludeParentKeys;
-                if (matchParentKeys && !matchParentKeys.includes(key)) {
-                    return;
-                }
-                if (excludeParentKeys && excludeParentKeys.includes(key)) {
-                    return;
-                }
-            }
-        }
-        if (properties) {
-            properties = Array.isArray(properties) ? properties : [properties];
-        }
-        for (const assert of asserts) {
-            if (properties) {
-                for (const property of properties) {
-                    // we can have resolvable scalar so need to resolve value here.
-                    const value = ref_utils_1.isRef(node[property]) ? (_a = resolve(node[property])) === null || _a === void 0 ? void 0 : _a.node : node[property];
-                    runAssertion(value, assert, location.child(property), report);
-                }
-            }
-            else {
-                runAssertion(Object.keys(node), assert, location.key(), report);
+function buildSubjectVisitor(assertId, assertion) {
+    return (node, ctx) => {
+        const properties = getAssertionProperties(assertion);
+        const defaultMessage = `${logger_1.colorize.blue(assertId)} failed because the ${logger_1.colorize.blue(assertion.subject.type)} ${logger_1.colorize.blue(properties.join(', '))} didn't meet the assertions: ${assertionMessageTemplates.problems}`.replace(/ +/g, ' ');
+        const problems = applyAssertions(assertion, getAssertsToApply(assertion), Object.assign(Object.assign({}, ctx), { node }));
+        if (problems.length) {
+            for (const problemGroup of groupProblemsByPointer(problems)) {
+                const message = assertion.message || defaultMessage;
+                const problemMessage = getProblemsMessage(problemGroup);
+                ctx.report({
+                    message: message.replace(assertionMessageTemplates.problems, problemMessage),
+                    location: getProblemsLocation(problemGroup) || ctx.location,
+                    forceSeverity: assertion.severity || 'error',
+                    suggest: assertion.suggest || [],
+                    ruleId: assertId,
+                });
             }
         }
     };
 }
 exports.buildSubjectVisitor = buildSubjectVisitor;
+function groupProblemsByPointer(problems) {
+    const groups = {};
+    for (const problem of problems) {
+        if (!problem.location)
+            continue;
+        const pointer = problem.location.pointer;
+        groups[pointer] = groups[pointer] || [];
+        groups[pointer].push(problem);
+    }
+    return Object.values(groups);
+}
+function getProblemsLocation(problems) {
+    return problems.length ? problems[0].location : undefined;
+}
+function getProblemsMessage(problems) {
+    var _a;
+    return problems.length === 1
+        ? (_a = problems[0].message) !== null && _a !== void 0 ? _a : ''
+        : problems.map((problem) => { var _a; return `\n- ${(_a = problem.message) !== null && _a !== void 0 ? _a : ''}`; }).join('');
+}
 function getIntersectionLength(keys, properties) {
     const props = new Set(properties);
     let count = 0;
@@ -99,11 +167,17 @@ function isOrdered(value, options) {
         let currValue = value[i];
         let prevVal = value[i - 1];
         if (property) {
-            if (!value[i][property] || !value[i - 1][property]) {
+            const currPropValue = value[i][property];
+            const prevPropValue = value[i - 1][property];
+            if (!currPropValue || !prevPropValue) {
                 return false; // property doesn't exist, so collection is not ordered
             }
-            currValue = value[i][property];
-            prevVal = value[i - 1][property];
+            currValue = currPropValue;
+            prevVal = prevPropValue;
+        }
+        if (typeof currValue === 'string' && typeof prevVal === 'string') {
+            currValue = currValue.toLowerCase();
+            prevVal = prevVal.toLowerCase();
         }
         const result = direction === 'asc' ? currValue >= prevVal : currValue <= prevVal;
         if (!result) {
@@ -113,15 +187,25 @@ function isOrdered(value, options) {
     return true;
 }
 exports.isOrdered = isOrdered;
-function runAssertion(values, assert, location, report) {
-    const lintResult = asserts_1.asserts[assert.name](values, assert.conditions);
-    if (!lintResult) {
-        report({
-            message: assert.message || `The ${assert.assertId} doesn't meet required conditions`,
-            location,
-            forceSeverity: assert.severity,
-            suggest: assert.suggest,
-            ruleId: assert.assertId,
-        });
+function runAssertion({ assert, ctx, assertionProperty, }) {
+    var _a;
+    const currentLocation = assert.name === 'ref' ? ctx.rawLocation : ctx.location;
+    if (assertionProperty) {
+        const values = ref_utils_1.isRef(ctx.node[assertionProperty])
+            ? (_a = ctx.resolve(ctx.node[assertionProperty])) === null || _a === void 0 ? void 0 : _a.node
+            : ctx.node[assertionProperty];
+        const rawValues = ctx.rawNode[assertionProperty];
+        const location = currentLocation.child(assertionProperty);
+        return asserts_1.asserts[assert.name](values, assert.conditions, Object.assign(Object.assign({}, ctx), { baseLocation: location, rawValue: rawValues }));
+    }
+    else {
+        const value = Array.isArray(ctx.node) ? ctx.node : Object.keys(ctx.node);
+        return asserts_1.asserts[assert.name](value, assert.conditions, Object.assign(Object.assign({}, ctx), { rawValue: ctx.rawNode, baseLocation: currentLocation }));
     }
 }
+exports.runAssertion = runAssertion;
+function regexFromString(input) {
+    const matches = input.match(/^\/(.*)\/(.*)|(.*)/);
+    return matches && new RegExp(matches[1] || matches[3], matches[2]);
+}
+exports.regexFromString = regexFromString;

package/lib/rules/common/info-license-url.d.ts

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

package/lib/rules/common/info-license-url.js

@@ -1,17 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InfoLicense = void 0;
+exports.InfoLicenseUrl = void 0;
 const utils_1 = require("../utils");
-const InfoLicense = () => {
+const InfoLicenseUrl = () => {
     return {
-        Info(info, { report }) {
-            if (!info.license) {
-                report({
-                    message: utils_1.missingRequiredField('Info', 'license'),
-                    location: { reportOnKey: true }
-                });
-            }
+        License(license, ctx) {
+            utils_1.validateDefinedAndNonEmpty('url', license, ctx);
         },
     };
 };
-exports.InfoLicense = InfoLicense;
+exports.InfoLicenseUrl = InfoLicenseUrl;

package/lib/rules/common/info-license.d.ts

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

package/lib/rules/common/info-license.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoLicense = void 0;
+const utils_1 = require("../utils");
+const InfoLicense = () => {
+    return {
+        Info(info, { report }) {
+            if (!info.license) {
+                report({
+                    message: utils_1.missingRequiredField('Info', 'license'),
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+exports.InfoLicense = InfoLicense;

package/lib/rules/common/no-ambiguous-paths.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoAmbiguousPaths = void 0;
 const NoAmbiguousPaths = () => {
     return {
-        PathMap(pathMap, { report, location }) {
+        Paths(pathMap, { report, location }) {
             const seenPaths = [];
             for (const currentPath of Object.keys(pathMap)) {
                 const ambiguousPath = seenPaths.find((seenPath) => arePathsAmbiguous(seenPath, currentPath));

package/lib/rules/common/no-enum-type-mismatch.js

@@ -28,14 +28,12 @@ const NoEnumTypeMismatch = () => {
                     if (mismatchedResults[enumValue].length !== schema.type.length)
                         delete mismatchedResults[enumValue];
                 }
-                ;
                 for (const mismatchedKey of Object.keys(mismatchedResults)) {
                     report({
-                        message: `Enum value \`${mismatchedKey}\` must be of one type. Allowed types: \`${schema.type}\`.`,
+                        message: `Enum value \`${mismatchedKey}\` must be of allowed types: \`${schema.type}\`.`,
                         location: location.child(['enum', schema.enum.indexOf(mismatchedKey)]),
                     });
                 }
-                ;
             }
         },
     };

package/lib/rules/common/no-identical-paths.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoIdenticalPaths = void 0;
 const NoIdenticalPaths = () => {
     return {
-        PathMap(pathMap, { report, location }) {
-            const pathsMap = new Map();
+        Paths(pathMap, { report, location }) {
+            const Paths = new Map();
             for (const pathName of Object.keys(pathMap)) {
                 const id = pathName.replace(/{.+?}/g, '{VARIABLE}');
-                const existingSamePath = pathsMap.get(id);
+                const existingSamePath = Paths.get(id);
                 if (existingSamePath) {
                     report({
                         message: `The path already exists which differs only by path parameter name(s): \`${existingSamePath}\` and \`${pathName}\`.`,
@@ -15,7 +15,7 @@ const NoIdenticalPaths = () => {
                     });
                 }
                 else {
-                    pathsMap.set(id, pathName);
+                    Paths.set(id, pathName);
                 }
             }
         },

package/lib/rules/common/no-invalid-parameter-examples.js

@@ -4,17 +4,17 @@ exports.NoInvalidParameterExamples = void 0;
 const utils_1 = require("../utils");
 const NoInvalidParameterExamples = (opts) => {
     var _a;
-    const disallowAdditionalProperties = (_a = opts.disallowAdditionalProperties) !== null && _a !== void 0 ? _a : true;
+    const allowAdditionalProperties = (_a = utils_1.getAdditionalPropertiesOption(opts)) !== null && _a !== void 0 ? _a : false;
     return {
         Parameter: {
             leave(parameter, ctx) {
                 if (parameter.example) {
-                    utils_1.validateExample(parameter.example, parameter.schema, ctx.location.child('example'), ctx, disallowAdditionalProperties);
+                    utils_1.validateExample(parameter.example, parameter.schema, ctx.location.child('example'), ctx, allowAdditionalProperties);
                 }
                 if (parameter.examples) {
                     for (const [key, example] of Object.entries(parameter.examples)) {
                         if ('value' in example) {
-                            utils_1.validateExample(example.value, parameter.schema, ctx.location.child(['examples', key]), ctx, false);
+                            utils_1.validateExample(example.value, parameter.schema, ctx.location.child(['examples', key]), ctx, true);
                         }
                     }
                 }

package/lib/rules/common/no-invalid-schema-examples.js

@@ -4,17 +4,17 @@ exports.NoInvalidSchemaExamples = void 0;
 const utils_1 = require("../utils");
 const NoInvalidSchemaExamples = (opts) => {
     var _a;
-    const disallowAdditionalProperties = (_a = opts.disallowAdditionalProperties) !== null && _a !== void 0 ? _a : true;
+    const allowAdditionalProperties = (_a = utils_1.getAdditionalPropertiesOption(opts)) !== null && _a !== void 0 ? _a : false;
     return {
         Schema: {
             leave(schema, ctx) {
                 if (schema.examples) {
                     for (const example of schema.examples) {
-                        utils_1.validateExample(example, schema, ctx.location.child(['examples', schema.examples.indexOf(example)]), ctx, disallowAdditionalProperties);
+                        utils_1.validateExample(example, schema, ctx.location.child(['examples', schema.examples.indexOf(example)]), ctx, allowAdditionalProperties);
                     }
                 }
                 if (schema.example) {
-                    utils_1.validateExample(schema.example, schema, ctx.location.child('example'), ctx, false);
+                    utils_1.validateExample(schema.example, schema, ctx.location.child('example'), ctx, true);
                 }
             },
         },

package/lib/rules/common/operation-2xx-response.js

@@ -1,16 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Operation2xxResponse = void 0;
-const Operation2xxResponse = () => {
+const utils_1 = require("../utils");
+const Operation2xxResponse = ({ validateWebhooks }) => {
     return {
-        ResponsesMap(responses, { report }) {
-            const codes = Object.keys(responses);
-            if (!codes.some((code) => code === 'default' || /2[Xx0-9]{2}/.test(code))) {
-                report({
-                    message: 'Operation must have at least one `2xx` response.',
-                    location: { reportOnKey: true },
-                });
-            }
+        Paths: {
+            Responses(responses, { report }) {
+                const codes = Object.keys(responses || {});
+                utils_1.validateResponseCodes(codes, '2XX', { report });
+            },
+        },
+        WebhooksMap: {
+            Responses(responses, { report }) {
+                if (!validateWebhooks)
+                    return;
+                const codes = Object.keys(responses || {});
+                utils_1.validateResponseCodes(codes, '2XX', { report });
+            },
         },
     };
 };

package/lib/rules/common/operation-4xx-response.js

@@ -1,16 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Operation4xxResponse = void 0;
-const Operation4xxResponse = () => {
+const utils_1 = require("../utils");
+const Operation4xxResponse = ({ validateWebhooks }) => {
     return {
-        ResponsesMap(responses, { report }) {
-            const codes = Object.keys(responses);
-            if (!codes.some((code) => /4[Xx0-9]{2}/.test(code))) {
-                report({
-                    message: 'Operation must have at least one `4xx` response.',
-                    location: { reportOnKey: true },
-                });
-            }
+        Paths: {
+            Responses(responses, { report }) {
+                const codes = Object.keys(responses || {});
+                utils_1.validateResponseCodes(codes, '4XX', { report });
+            },
+        },
+        WebhooksMap: {
+            Responses(responses, { report }) {
+                if (!validateWebhooks)
+                    return;
+                const codes = Object.keys(responses || {});
+                utils_1.validateResponseCodes(codes, '4XX', { report });
+            },
         },
     };
 };

package/lib/rules/common/operation-operationId.js

@@ -4,13 +4,13 @@ exports.OperationOperationId = void 0;
 const utils_1 = require("../utils");
 const OperationOperationId = () => {
     return {
-        DefinitionRoot: {
+        Root: {
             PathItem: {
                 Operation(operation, ctx) {
                     utils_1.validateDefinedAndNonEmpty('operationId', operation, ctx);
                 },
             },
-        }
+        },
     };
 };
 exports.OperationOperationId = OperationOperationId;