@redocly/openapi-core 1.0.0-beta.111 → 1.0.0-beta.112

package/lib/config/all.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     rules: {
-        'info-description': 'error',
         'info-contact': 'error',
         'info-license': 'error',
         'info-license-url': 'error',

package/lib/config/config-resolvers.js

@@ -254,18 +254,10 @@ function groupStyleguideAssertionRules({ rules, plugins, }) {
         if (ruleKey.startsWith('assert/') && typeof rule === 'object' && rule !== null) {
             const assertion = rule;
             if (plugins) {
-                for (const field of Object.keys(assertion)) {
-                    const [pluginId, fn] = field.split('/');
-                    if (!pluginId || !fn)
-                        continue;
-                    const plugin = plugins.find((plugin) => plugin.id === pluginId);
-                    if (!plugin) {
-                        throw Error(logger_1.colorize.red(`Plugin ${logger_1.colorize.blue(pluginId)} isn't found.`));
-                    }
-                    if (!plugin.assertions || !plugin.assertions[fn]) {
-                        throw Error(`Plugin ${logger_1.colorize.red(pluginId)} doesn't export assertions function with name ${logger_1.colorize.red(fn)}.`);
-                    }
-                    asserts_1.asserts[field] = asserts_1.buildAssertCustomFunction(plugin.assertions[fn]);
+                registerCustomAssertions(plugins, assertion);
+                // We may have custom assertion inside where block
+                for (const context of assertion.where || []) {
+                    registerCustomAssertions(plugins, context);
                 }
             }
             assertions.push(Object.assign(Object.assign({}, assertion), { assertionId: ruleKey.replace('assert/', '') }));
@@ -280,3 +272,18 @@ function groupStyleguideAssertionRules({ rules, plugins, }) {
     }
     return transformedRules;
 }
+function registerCustomAssertions(plugins, assertion) {
+    for (const field of utils_3.keysOf(assertion.assertions)) {
+        const [pluginId, fn] = field.split('/');
+        if (!pluginId || !fn)
+            continue;
+        const plugin = plugins.find((plugin) => plugin.id === pluginId);
+        if (!plugin) {
+            throw Error(logger_1.colorize.red(`Plugin ${logger_1.colorize.blue(pluginId)} isn't found.`));
+        }
+        if (!plugin.assertions || !plugin.assertions[fn]) {
+            throw Error(`Plugin ${logger_1.colorize.red(pluginId)} doesn't export assertions function with name ${logger_1.colorize.red(fn)}.`);
+        }
+        asserts_1.asserts[field] = asserts_1.buildAssertCustomFunction(plugin.assertions[fn]);
+    }
+}

package/lib/config/load.d.ts

@@ -10,7 +10,7 @@ export declare function loadConfig(options?: {
 }): Promise<Config>;
 export declare const CONFIG_FILE_NAMES: string[];
 export declare function findConfig(dir?: string): string | undefined;
-export declare function getConfig(configPath?: string | undefined): Promise<RawConfig>;
+export declare function getConfig(configPath?: string | undefined, processRawConfig?: (rawConfig: RawConfig) => void | Promise<void>): Promise<RawConfig>;
 declare type CreateConfigOptions = {
     extends?: string[];
     tokens?: RegionalTokenWithValidity[];

package/lib/config/load.js

@@ -62,11 +62,8 @@ function addConfigMetadata({ rawConfig, customExtends, configPath, tokens, }) {
 function loadConfig(options = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         const { configPath = findConfig(), customExtends, processRawConfig, files, region } = options;
-        const config = yield getConfig(configPath);
+        const config = yield getConfig(configPath, processRawConfig);
         const rawConfig = Object.assign(Object.assign({}, config), { files: files !== null && files !== void 0 ? files : config.files, region: region !== null && region !== void 0 ? region : config.region });
-        if (typeof processRawConfig === 'function') {
-            yield processRawConfig(rawConfig);
-        }
         const redoclyClient = new redocly_1.RedoclyClient();
         const tokens = yield redoclyClient.getTokens();
         return addConfigMetadata({
@@ -93,12 +90,15 @@ function findConfig(dir) {
     return existingConfigFiles[0];
 }
 exports.findConfig = findConfig;
-function getConfig(configPath = findConfig()) {
+function getConfig(configPath = findConfig(), processRawConfig) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!configPath || !utils_1.doesYamlFileExist(configPath))
             return {};
         try {
             const rawConfig = (yield utils_1.loadYaml(configPath)) || {};
+            if (typeof processRawConfig === 'function') {
+                yield processRawConfig(rawConfig);
+            }
             return utils_2.transformConfig(rawConfig);
         }
         catch (e) {

package/lib/config/minimal.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     rules: {
-        'info-description': 'warn',
         'info-contact': 'off',
         'info-license': 'off',
         'info-license-url': 'off',

package/lib/config/recommended.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     rules: {
-        'info-description': 'warn',
         'info-contact': 'off',
         'info-license': 'warn',
         'info-license-url': 'warn',

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

@@ -1,8 +1,25 @@
 import { AssertResult, CustomFunction } from 'core/src/config/types';
 import { Location } from '../../../ref-utils';
-declare type Asserts = Record<string, (value: any, condition: any, baseLocation: Location, rawValue?: any) => AssertResult[]>;
-export declare const runOnKeysSet: Set<string>;
-export declare const runOnValuesSet: Set<string>;
+export declare type AssertionFn = (value: any, condition: any, baseLocation: Location, rawValue?: any) => AssertResult[];
+export declare type Asserts = {
+    pattern: AssertionFn;
+    enum: AssertionFn;
+    defined: AssertionFn;
+    required: AssertionFn;
+    disallowed: AssertionFn;
+    undefined: AssertionFn;
+    nonEmpty: AssertionFn;
+    minLength: AssertionFn;
+    maxLength: AssertionFn;
+    casing: AssertionFn;
+    sortOrder: AssertionFn;
+    mutuallyExclusive: AssertionFn;
+    mutuallyRequired: AssertionFn;
+    requireAny: AssertionFn;
+    ref: AssertionFn;
+    const: AssertionFn;
+};
+export declare const runOnKeysSet: Set<keyof Asserts>;
+export declare const runOnValuesSet: Set<keyof Asserts>;
 export declare const asserts: Asserts;
-export declare function buildAssertCustomFunction(fn: CustomFunction): (value: string[], options: any, baseLocation: Location) => any;
-export {};
+export declare function buildAssertCustomFunction(fn: CustomFunction): AssertionFn;

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

@@ -16,6 +16,8 @@ exports.runOnKeysSet = new Set([
     'required',
     'requireAny',
     'ref',
+    'const',
+    'defined', // In case if `property` for assertions is not added
 ]);
 exports.runOnValuesSet = new Set([
     'pattern',
@@ -28,6 +30,7 @@ exports.runOnValuesSet = new Set([
     'casing',
     'sortOrder',
     'ref',
+    'const',
 ]);
 exports.asserts = {
     pattern: (value, condition, baseLocation) => {
@@ -84,6 +87,28 @@ exports.asserts = {
         })
             .filter(utils_1.isTruthy);
     },
+    const: (value, condition, baseLocation) => {
+        if (typeof value === 'undefined')
+            return [];
+        if (Array.isArray(value)) {
+            return value
+                .map((_val) => condition !== _val && {
+                message: `"${_val}" should be equal ${condition} `,
+                location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+            })
+                .filter(utils_1.isTruthy);
+        }
+        else {
+            return value !== condition
+                ? [
+                    {
+                        message: `${value} should be equal ${condition}`,
+                        location: baseLocation,
+                    },
+                ]
+                : [];
+        }
+    },
     undefined: (value, condition = true, baseLocation) => {
         const isUndefined = typeof value === 'undefined';
         const isValid = condition ? isUndefined : !isUndefined;

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,8 +1,8 @@
 "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) => {
     const visitors = [];
     // As 'Assertions' has an array of asserts,
@@ -13,35 +13,12 @@ const Assertions = (opts) => {
     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 {
-                name: assertName,
-                conditions: assertion[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.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(assertId, assertion, assertsToApply);
-            const visitorObject = utils_1.buildVisitorObject(subject, assertion.context, subjectVisitor);
-            visitors.push(visitorObject);
+        if (!utils_2.isString(assertion.subject.type)) {
+            throw new Error(`${assertId}: 'type' (String) is required`);
         }
+        const subjectVisitor = utils_1.buildSubjectVisitor(assertId, assertion);
+        const visitorObject = utils_1.buildVisitorObject(assertion, subjectVisitor);
+        visitors.push(visitorObject);
     }
     return visitors;
 };

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

@@ -1,27 +1,20 @@
-import type { RuleSeverity } from '../../../config';
-import { UserContext } from '../../../walk';
+import { Asserts } from './asserts';
+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;
 };
-declare type Assertion = {
-    property: string | string[];
-    context?: Record<string, any>[];
-    severity?: RuleSeverity;
-    suggest?: any[];
-    message?: string;
-    subject: string;
-};
 export declare type AssertToApply = {
-    name: string;
+    name: keyof Asserts;
     conditions: any;
     runsOnKeys: boolean;
     runsOnValues: boolean;
 };
-export declare function buildVisitorObject(subject: string, context: Record<string, any>[], subjectVisitor: any): Record<string, any>;
-export declare function buildSubjectVisitor(assertId: string, assertion: Assertion, asserts: AssertToApply[]): (node: any, { report, location, rawLocation, key, type, resolve, rawNode }: UserContext) => void;
+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 regexFromString(input: string): RegExp | null;
-export {};

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

@@ -1,122 +1,154 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.regexFromString = exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = void 0;
+exports.regexFromString = exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = exports.getAssertsToApply = void 0;
+const asserts_1 = require("./asserts");
 const logger_1 = require("../../../logger");
 const ref_utils_1 = require("../../../ref-utils");
-const asserts_1 = require("./asserts");
-function buildVisitorObject(subject, context, subjectVisitor) {
-    if (!context) {
-        return { [subject]: subjectVisitor };
+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, { rawLocation, rawNode, resolve, location, node }) {
+    var _a;
+    const properties = getAssertionProperties(assertionDefinition);
+    const assertResults = [];
+    for (const assert of asserts) {
+        const currentLocation = assert.name === 'ref' ? rawLocation : location;
+        if (properties.length) {
+            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];
+                assertResults.push(runAssertion({
+                    values: value,
+                    rawValues: rawNode[property],
+                    assert,
+                    location: currentLocation.child(property),
+                }));
+            }
+        }
+        else {
+            const value = assert.name === 'ref' ? rawNode : Object.keys(node);
+            assertResults.push(runAssertion({
+                values: Object.keys(node),
+                rawValues: value,
+                assert,
+                location: currentLocation,
+            }));
+        }
+    }
+    return assertResults.flat();
+}
+function buildVisitorObject(assertion, subjectVisitor) {
+    var _a, _b;
+    const targetVisitorLocatorPredicates = getPredicatesFromLocators(assertion.subject);
+    const targetVisitorSkipFunction = targetVisitorLocatorPredicates.length
+        ? (node, 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 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`);
         }
-        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`);
-        }
-        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, { location, rawLocation, resolve, rawNode }) => !locatorPredicates.every((predicate) => predicate(key)) ||
+            !!applyAssertions(assertionDefinitionNode, assertsToApply, {
+                location,
+                node,
+                rawLocation,
+                rawNode,
+                resolve,
+            }).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(assertId, assertion, asserts) {
-    return (node, { report, location, rawLocation, key, type, resolve, rawNode }) => {
-        var _a;
-        let properties = assertion.property;
-        // 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 (assertion.context) {
-            const lastContextNode = assertion.context[assertion.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];
-        }
-        const defaultMessage = `${logger_1.colorize.blue(assertId)} failed because the ${logger_1.colorize.blue(assertion.subject)}${logger_1.colorize.blue(properties ? ` ${properties.join(', ')}` : '')} didn't meet the assertions: {{problems}}`;
-        const assertResults = [];
-        for (const assert of asserts) {
-            const currentLocation = assert.name === 'ref' ? rawLocation : location;
-            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];
-                    assertResults.push(runAssertion({
-                        values: value,
-                        rawValues: rawNode[property],
-                        assert,
-                        location: currentLocation.child(property),
-                    }));
-                }
-            }
-            else {
-                const value = assert.name === 'ref' ? rawNode : Object.keys(node);
-                assertResults.push(runAssertion({
-                    values: Object.keys(node),
-                    rawValues: value,
-                    assert,
-                    location: currentLocation,
-                }));
-            }
-        }
-        const problems = assertResults.flat();
+function buildSubjectVisitor(assertId, assertion) {
+    return (node, { report, location, rawLocation, resolve, rawNode }) => {
+        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), {
+            rawLocation,
+            rawNode,
+            resolve,
+            location,
+            node,
+        });
         if (problems.length) {
             const message = assertion.message || defaultMessage;
-            report({
-                message: message.replace('{{problems}}', getProblemsMessage(problems)),
-                location: getProblemsLocation(problems) || location,
-                forceSeverity: assertion.severity || 'error',
-                suggest: assertion.suggest || [],
-                ruleId: assertId,
-            });
+            for (const problem of problems) {
+                const problemMessage = problem.message ? problem.message : defaultMessage;
+                report({
+                    message: message.replace(assertionMessageTemplates.problems, problemMessage),
+                    location: problem.location || location,
+                    forceSeverity: assertion.severity || 'error',
+                    suggest: assertion.suggest || [],
+                    ruleId: assertId,
+                });
+            }
         }
     };
 }
 exports.buildSubjectVisitor = buildSubjectVisitor;
-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;

package/lib/rules/oas2/index.d.ts

@@ -3,7 +3,6 @@ export declare const rules: {
     spec: Oas2Rule;
     'no-invalid-schema-examples': any;
     'no-invalid-parameter-examples': any;
-    'info-description': Oas2Rule;
     'info-contact': Oas2Rule;
     'info-license': Oas2Rule;
     'info-license-url': Oas2Rule;

package/lib/rules/oas2/index.js

@@ -4,7 +4,6 @@ exports.preprocessors = exports.rules = void 0;
 const spec_1 = require("../common/spec");
 const no_invalid_schema_examples_1 = require("../common/no-invalid-schema-examples");
 const no_invalid_parameter_examples_1 = require("../common/no-invalid-parameter-examples");
-const info_description_1 = require("../common/info-description");
 const info_contact_1 = require("../common/info-contact");
 const info_license_1 = require("../common/info-license");
 const info_license_url_1 = require("../common/info-license-url");
@@ -46,7 +45,6 @@ exports.rules = {
     spec: spec_1.OasSpec,
     'no-invalid-schema-examples': no_invalid_schema_examples_1.NoInvalidSchemaExamples,
     'no-invalid-parameter-examples': no_invalid_parameter_examples_1.NoInvalidParameterExamples,
-    'info-description': info_description_1.InfoDescription,
     'info-contact': info_contact_1.InfoContact,
     'info-license': info_license_1.InfoLicense,
     'info-license-url': info_license_url_1.InfoLicenseUrl,

package/lib/rules/oas3/index.js

@@ -17,7 +17,6 @@ const operation_operationId_url_safe_1 = require("../common/operation-operationI
 const tags_alphabetical_1 = require("../common/tags-alphabetical");
 const no_server_example_com_1 = require("./no-server-example.com");
 const no_server_trailing_slash_1 = require("./no-server-trailing-slash");
-const info_description_1 = require("../common/info-description");
 const tag_description_1 = require("../common/tag-description");
 const info_contact_1 = require("../common/info-contact");
 const info_license_1 = require("../common/info-license");
@@ -54,7 +53,6 @@ const spec_components_invalid_map_name_1 = require("./spec-components-invalid-ma
 const operation_4xx_problem_details_rfc7807_1 = require("./operation-4xx-problem-details-rfc7807");
 exports.rules = {
     spec: spec_1.OasSpec,
-    'info-description': info_description_1.InfoDescription,
     'info-contact': info_contact_1.InfoContact,
     'info-license': info_license_1.InfoLicense,
     'info-license-url': info_license_url_1.InfoLicenseUrl,